[net-next-2.6.git] / fs / isofs / namei.c

/*
 *  linux/fs/isofs/namei.c
 *
 *  (C) 1992  Eric Youngdale Modified for ISO 9660 filesystem.
 *
 *  (C) 1991  Linus Torvalds - minix filesystem
 */

#include <linux/gfp.h>
#include "isofs.h"

/*
 * ok, we cannot use strncmp, as the name is not in our data space.
 * Thus we'll have to use isofs_match. No big problem. Match also makes
 * some sanity tests.
 */
static int
isofs_cmp(struct dentry *dentry, const char *compare, int dlen)
{
	struct qstr qstr;

	if (!compare)
		return 1;

	/* check special "." and ".." files */
	if (dlen == 1) {
		/* "." */
		if (compare[0] == 0) {
			if (!dentry->d_name.len)
				return 0;
			compare = ".";
		} else if (compare[0] == 1) {
			compare = "..";
			dlen = 2;
		}
	}

	qstr.name = compare;
	qstr.len = dlen;
	return dentry->d_op->d_compare(dentry, &dentry->d_name, &qstr);
}

/*
 *	isofs_find_entry()
 *
 * finds an entry in the specified directory with the wanted name. It
 * returns the inode number of the found entry, or 0 on error.
 */
static unsigned long
isofs_find_entry(struct inode *dir, struct dentry *dentry,
	unsigned long *block_rv, unsigned long *offset_rv,
	char *tmpname, struct iso_directory_record *tmpde)
{
	unsigned long bufsize = ISOFS_BUFFER_SIZE(dir);
	unsigned char bufbits = ISOFS_BUFFER_BITS(dir);
	unsigned long block, f_pos, offset, block_saved, offset_saved;
	struct buffer_head *bh = NULL;
	struct isofs_sb_info *sbi = ISOFS_SB(dir->i_sb);

	if (!ISOFS_I(dir)->i_first_extent)
		return 0;

	f_pos = 0;
	offset = 0;
	block = 0;

	while (f_pos < dir->i_size) {
		struct iso_directory_record *de;
		int de_len, match, i, dlen;
		char *dpnt;

		if (!bh) {
			bh = isofs_bread(dir, block);
			if (!bh)
				return 0;
		}

		de = (struct iso_directory_record *) (bh->b_data + offset);

		de_len = *(unsigned char *) de;
		if (!de_len) {
			brelse(bh);
			bh = NULL;
			f_pos = (f_pos + ISOFS_BLOCK_SIZE) & ~(ISOFS_BLOCK_SIZE - 1);
			block = f_pos >> bufbits;
			offset = 0;
			continue;
		}

		block_saved = bh->b_blocknr;
		offset_saved = offset;
		offset += de_len;
		f_pos += de_len;

		/* Make sure we have a full directory entry */
		if (offset >= bufsize) {
			int slop = bufsize - offset + de_len;
			memcpy(tmpde, de, slop);
			offset &= bufsize - 1;
			block++;
			brelse(bh);
			bh = NULL;
			if (offset) {
				bh = isofs_bread(dir, block);
				if (!bh)
					return 0;
				memcpy((void *) tmpde + slop, bh->b_data, offset);
			}
			de = tmpde;
		}

		dlen = de->name_len[0];
		dpnt = de->name;
		/* Basic sanity check, whether name doesn't exceed dir entry */
		if (de_len < dlen + sizeof(struct iso_directory_record)) {
			printk(KERN_NOTICE "iso9660: Corrupted directory entry"
			       " in block %lu of inode %lu\n", block,
			       dir->i_ino);
			return 0;
		}

		if (sbi->s_rock &&
		    ((i = get_rock_ridge_filename(de, tmpname, dir)))) {
			dlen = i;	/* possibly -1 */
			dpnt = tmpname;
#ifdef CONFIG_JOLIET
		} else if (sbi->s_joliet_level) {
			dlen = get_joliet_filename(de, tmpname, dir);
			dpnt = tmpname;
#endif
		} else if (sbi->s_mapping == 'a') {
			dlen = get_acorn_filename(de, tmpname, dir);
			dpnt = tmpname;
		} else if (sbi->s_mapping == 'n') {
			dlen = isofs_name_translate(de, tmpname, dir);
			dpnt = tmpname;
		}

		/*
		 * Skip hidden or associated files unless hide or showassoc,
		 * respectively, is set
		 */
		match = 0;
		if (dlen > 0 &&
			(!sbi->s_hide ||
				(!(de->flags[-sbi->s_high_sierra] & 1))) &&
			(sbi->s_showassoc ||
				(!(de->flags[-sbi->s_high_sierra] & 4)))) {
			match = (isofs_cmp(dentry, dpnt, dlen) == 0);
		}
		if (match) {
			isofs_normalize_block_and_offset(de,
							 &block_saved,
							 &offset_saved);
			*block_rv = block_saved;
			*offset_rv = offset_saved;
			brelse(bh);
			return 1;
		}
	}
	brelse(bh);
	return 0;
}

struct dentry *isofs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
{
	int found;
	unsigned long uninitialized_var(block);
	unsigned long uninitialized_var(offset);
	struct isofs_sb_info *sbi = ISOFS_SB(dir->i_sb);
	struct inode *inode;
	struct page *page;

	dentry->d_op = dir->i_sb->s_root->d_op;

	page = alloc_page(GFP_USER);
	if (!page)
		return ERR_PTR(-ENOMEM);

	mutex_lock(&sbi->s_mutex);
	found = isofs_find_entry(dir, dentry,
				&block, &offset,
				page_address(page),
				1024 + page_address(page));
	__free_page(page);

	inode = NULL;
	if (found) {
		inode = isofs_iget(dir->i_sb, block, offset);
		if (IS_ERR(inode)) {
			mutex_unlock(&sbi->s_mutex);
			return ERR_CAST(inode);
		}
	}
	mutex_unlock(&sbi->s_mutex);
	return d_splice_alias(inode, dentry);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/isofs/namei.c
	3	*
	4	* (C) 1992 Eric Youngdale Modified for ISO 9660 filesystem.
	5	*
	6	* (C) 1991 Linus Torvalds - minix filesystem
	7	*/
	8
5a0e3ad6	9	#include <linux/gfp.h>
94f2f715	10	#include "isofs.h"
1da177e4 LT	11
	12	/*
	13	* ok, we cannot use strncmp, as the name is not in our data space.
	14	* Thus we'll have to use isofs_match. No big problem. Match also makes
	15	* some sanity tests.
	16	*/
	17	static int
c3ed85a3	18	isofs_cmp(struct dentry dentry, const char compare, int dlen)
1da177e4 LT	19	{
	20	struct qstr qstr;
	21
	22	if (!compare)
	23	return 1;
	24
	25	/* check special "." and ".." files */
	26	if (dlen == 1) {
	27	/* "." */
	28	if (compare[0] == 0) {
	29	if (!dentry->d_name.len)
	30	return 0;
	31	compare = ".";
	32	} else if (compare[0] == 1) {
	33	compare = "..";
	34	dlen = 2;
	35	}
	36	}
	37
	38	qstr.name = compare;
	39	qstr.len = dlen;
	40	return dentry->d_op->d_compare(dentry, &dentry->d_name, &qstr);
	41	}
	42
	43	/*
	44	* isofs_find_entry()
	45	*
	46	* finds an entry in the specified directory with the wanted name. It
	47	* returns the inode number of the found entry, or 0 on error.
	48	*/
	49	static unsigned long
	50	isofs_find_entry(struct inode dir, struct dentry dentry,
c3ed85a3 DJ	51	unsigned long block_rv, unsigned long offset_rv,
c3ed85a3 DJ	52	char tmpname, struct iso_directory_record tmpde)
1da177e4 LT	53	{
	54	unsigned long bufsize = ISOFS_BUFFER_SIZE(dir);
	55	unsigned char bufbits = ISOFS_BUFFER_BITS(dir);
	56	unsigned long block, f_pos, offset, block_saved, offset_saved;
c3ed85a3	57	struct buffer_head *bh = NULL;
1da177e4 LT	58	struct isofs_sb_info *sbi = ISOFS_SB(dir->i_sb);
	59
	60	if (!ISOFS_I(dir)->i_first_extent)
	61	return 0;
c3ed85a3	62
1da177e4 LT	63	f_pos = 0;
	64	offset = 0;
	65	block = 0;
	66
	67	while (f_pos < dir->i_size) {
c3ed85a3	68	struct iso_directory_record *de;
1da177e4 LT	69	int de_len, match, i, dlen;
	70	char *dpnt;
	71
	72	if (!bh) {
	73	bh = isofs_bread(dir, block);
	74	if (!bh)
	75	return 0;
	76	}
	77
	78	de = (struct iso_directory_record *) (bh->b_data + offset);
	79
	80	de_len = (unsigned char ) de;
	81	if (!de_len) {
	82	brelse(bh);
	83	bh = NULL;
	84	f_pos = (f_pos + ISOFS_BLOCK_SIZE) & ~(ISOFS_BLOCK_SIZE - 1);
	85	block = f_pos >> bufbits;
	86	offset = 0;
	87	continue;
	88	}
	89
	90	block_saved = bh->b_blocknr;
	91	offset_saved = offset;
	92	offset += de_len;
	93	f_pos += de_len;
	94
	95	/* Make sure we have a full directory entry */
	96	if (offset >= bufsize) {
	97	int slop = bufsize - offset + de_len;
	98	memcpy(tmpde, de, slop);
	99	offset &= bufsize - 1;
	100	block++;
	101	brelse(bh);
	102	bh = NULL;
	103	if (offset) {
	104	bh = isofs_bread(dir, block);
	105	if (!bh)
	106	return 0;
	107	memcpy((void *) tmpde + slop, bh->b_data, offset);
	108	}
	109	de = tmpde;
	110	}
	111
	112	dlen = de->name_len[0];
	113	dpnt = de->name;
2deb1acc JK	114	/* Basic sanity check, whether name doesn't exceed dir entry */
	115	if (de_len < dlen + sizeof(struct iso_directory_record)) {
	116	printk(KERN_NOTICE "iso9660: Corrupted directory entry"
	117	" in block %lu of inode %lu\n", block,
	118	dir->i_ino);
	119	return 0;
	120	}
1da177e4 LT	121
	122	if (sbi->s_rock &&
	123	((i = get_rock_ridge_filename(de, tmpname, dir)))) {
c3ed85a3	124	dlen = i; /* possibly -1 */
1da177e4 LT	125	dpnt = tmpname;
	126	#ifdef CONFIG_JOLIET
	127	} else if (sbi->s_joliet_level) {
	128	dlen = get_joliet_filename(de, tmpname, dir);
	129	dpnt = tmpname;
	130	#endif
	131	} else if (sbi->s_mapping == 'a') {
	132	dlen = get_acorn_filename(de, tmpname, dir);
	133	dpnt = tmpname;
	134	} else if (sbi->s_mapping == 'n') {
	135	dlen = isofs_name_translate(de, tmpname, dir);
	136	dpnt = tmpname;
	137	}
	138
	139	/*
9769f4eb JW	140	* Skip hidden or associated files unless hide or showassoc,
9769f4eb JW	141	* respectively, is set
1da177e4 LT	142	*/
	143	match = 0;
	144	if (dlen > 0 &&
5404ac8e	145	(!sbi->s_hide \|\|
9769f4eb	146	(!(de->flags[-sbi->s_high_sierra] & 1))) &&
5404ac8e	147	(sbi->s_showassoc \|\|
9769f4eb JW	148	(!(de->flags[-sbi->s_high_sierra] & 4)))) {
9769f4eb JW	149	match = (isofs_cmp(dentry, dpnt, dlen) == 0);
1da177e4 LT	150	}
	151	if (match) {
	152	isofs_normalize_block_and_offset(de,
	153	&block_saved,
	154	&offset_saved);
c3ed85a3 DJ	155	*block_rv = block_saved;
c3ed85a3 DJ	156	*offset_rv = offset_saved;
9769f4eb	157	brelse(bh);
1da177e4 LT	158	return 1;
	159	}
	160	}
9769f4eb	161	brelse(bh);
1da177e4 LT	162	return 0;
	163	}
	164
c3ed85a3	165	struct dentry isofs_lookup(struct inode dir, struct dentry dentry, struct nameidata nd)
1da177e4 LT	166	{
1da177e4 LT	167	int found;
cd215237 BP	168	unsigned long uninitialized_var(block);
cd215237 BP	169	unsigned long uninitialized_var(offset);
4f819a78	170	struct isofs_sb_info *sbi = ISOFS_SB(dir->i_sb);
1da177e4 LT	171	struct inode *inode;
	172	struct page *page;
	173
	174	dentry->d_op = dir->i_sb->s_root->d_op;
	175
	176	page = alloc_page(GFP_USER);
	177	if (!page)
	178	return ERR_PTR(-ENOMEM);
	179
4f819a78	180	mutex_lock(&sbi->s_mutex);
1da177e4	181	found = isofs_find_entry(dir, dentry,
c3ed85a3 DJ	182	&block, &offset,
	183	page_address(page),
	184	1024 + page_address(page));
1da177e4 LT	185	__free_page(page);
	186
	187	inode = NULL;
	188	if (found) {
	189	inode = isofs_iget(dir->i_sb, block, offset);
c4386c83	190	if (IS_ERR(inode)) {
4f819a78	191	mutex_unlock(&sbi->s_mutex);
c4386c83	192	return ERR_CAST(inode);
1da177e4 LT	193	}
1da177e4 LT	194	}
4f819a78	195	mutex_unlock(&sbi->s_mutex);
2ff6b1c2	196	return d_splice_alias(inode, dentry);
1da177e4	197	}