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

/*
 *  linux/fs/isofs/dir.c
 *
 *  (C) 1992, 1993, 1994  Eric Youngdale Modified for ISO 9660 filesystem.
 *
 *  (C) 1991  Linus Torvalds - minix filesystem
 *
 *  Steve Beynon		       : Missing last directory entries fixed
 *  (stephen@askone.demon.co.uk)      : 21st June 1996
 * 
 *  isofs directory handling functions
 */
#include <linux/config.h>
#include <linux/smp_lock.h>
#include "isofs.h"

static int isofs_readdir(struct file *, void *, filldir_t);

struct file_operations isofs_dir_operations =
{
	.read		= generic_read_dir,
	.readdir	= isofs_readdir,
};

/*
 * directories can handle most operations...
 */
struct inode_operations isofs_dir_inode_operations =
{
	.lookup		= isofs_lookup,
};

int isofs_name_translate(struct iso_directory_record *de, char *new, struct inode *inode)
{
	char * old = de->name;
	int len = de->name_len[0];
	int i;
			
	for (i = 0; i < len; i++) {
		unsigned char c = old[i];
		if (!c)
			break;

		if (c >= 'A' && c <= 'Z')
			c |= 0x20;	/* lower case */

		/* Drop trailing '.;1' (ISO 9660:1988 7.5.1 requires period) */
		if (c == '.' && i == len - 3 && old[i + 1] == ';' && old[i + 2] == '1')
			break;

		/* Drop trailing ';1' */
		if (c == ';' && i == len - 2 && old[i + 1] == '1')
			break;

		/* Convert remaining ';' to '.' */
		/* Also '/' to '.' (broken Acorn-generated ISO9660 images) */
		if (c == ';' || c == '/')
			c = '.';

		new[i] = c;
	}
	return i;
}

/* Acorn extensions written by Matthew Wilcox <willy@bofh.ai> 1998 */
int get_acorn_filename(struct iso_directory_record * de,
			    char * retname, struct inode * inode)
{
	int std;
	unsigned char * chr;
	int retnamlen = isofs_name_translate(de, retname, inode);
	if (retnamlen == 0) return 0;
	std = sizeof(struct iso_directory_record) + de->name_len[0];
	if (std & 1) std++;
	if ((*((unsigned char *) de) - std) != 32) return retnamlen;
	chr = ((unsigned char *) de) + std;
	if (strncmp(chr, "ARCHIMEDES", 10)) return retnamlen;
	if ((*retname == '_') && ((chr[19] & 1) == 1)) *retname = '!';
	if (((de->flags[0] & 2) == 0) && (chr[13] == 0xff)
		&& ((chr[12] & 0xf0) == 0xf0))
	{
		retname[retnamlen] = ',';
		sprintf(retname+retnamlen+1, "%3.3x",
			((chr[12] & 0xf) << 8) | chr[11]);
		retnamlen += 4;
	}
	return retnamlen;
}

/*
 * This should _really_ be cleaned up some day..
 */
static int do_isofs_readdir(struct inode *inode, struct file *filp,
		void *dirent, filldir_t filldir,
		char * tmpname, struct iso_directory_record * tmpde)
{
	unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
	unsigned char bufbits = ISOFS_BUFFER_BITS(inode);
	unsigned long block, offset, block_saved, offset_saved;
	unsigned long inode_number = 0;	/* Quiet GCC */
	struct buffer_head *bh = NULL;
	int len;
	int map;
	int first_de = 1;
	char *p = NULL;		/* Quiet GCC */
	struct iso_directory_record *de;
	struct isofs_sb_info *sbi = ISOFS_SB(inode->i_sb);

	offset = filp->f_pos & (bufsize - 1);
	block = filp->f_pos >> bufbits;

	while (filp->f_pos < inode->i_size) {
		int de_len;

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

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

		de_len = *(unsigned char *) de;

		/* If the length byte is zero, we should move on to the next
		   CDROM sector.  If we are at the end of the directory, we
		   kick out of the while loop. */

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

		block_saved = block;
		offset_saved = offset;
		offset += 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(inode, block);
				if (!bh)
					return 0;
				memcpy((void *) tmpde + slop, bh->b_data, offset);
			}
			de = tmpde;
		}

		if (first_de) {
			isofs_normalize_block_and_offset(de,
							 &block_saved,
							 &offset_saved);
			inode_number = isofs_get_ino(block_saved,
						     offset_saved,
						     bufbits);
		}

		if (de->flags[-sbi->s_high_sierra] & 0x80) {
			first_de = 0;
			filp->f_pos += de_len;
			continue;
		}
		first_de = 1;

		/* Handle the case of the '.' directory */
		if (de->name_len[0] == 1 && de->name[0] == 0) {
			if (filldir(dirent, ".", 1, filp->f_pos, inode->i_ino, DT_DIR) < 0)
				break;
			filp->f_pos += de_len;
			continue;
		}

		len = 0;

		/* Handle the case of the '..' directory */
		if (de->name_len[0] == 1 && de->name[0] == 1) {
			inode_number = parent_ino(filp->f_dentry);
			if (filldir(dirent, "..", 2, filp->f_pos, inode_number, DT_DIR) < 0)
				break;
			filp->f_pos += de_len;
			continue;
		}

		/* Handle everything else.  Do name translation if there
		   is no Rock Ridge NM field. */

		/*
		 * Do not report hidden files if so instructed, or associated
		 * files unless instructed to do so
		 */
		if ((sbi->s_hide == 'y' &&
				(de->flags[-sbi->s_high_sierra] & 1)) ||
		      (sbi->s_showassoc =='n' &&
				(de->flags[-sbi->s_high_sierra] & 4))) {
			filp->f_pos += de_len;
			continue;
		}

		map = 1;
		if (sbi->s_rock) {
			len = get_rock_ridge_filename(de, tmpname, inode);
			if (len != 0) {		/* may be -1 */
				p = tmpname;
				map = 0;
			}
		}
		if (map) {
#ifdef CONFIG_JOLIET
			if (sbi->s_joliet_level) {
				len = get_joliet_filename(de, tmpname, inode);
				p = tmpname;
			} else
#endif
			if (sbi->s_mapping == 'a') {
				len = get_acorn_filename(de, tmpname, inode);
				p = tmpname;
			} else
			if (sbi->s_mapping == 'n') {
				len = isofs_name_translate(de, tmpname, inode);
				p = tmpname;
			} else {
				p = de->name;
				len = de->name_len[0];
			}
		}
		if (len > 0) {
			if (filldir(dirent, p, len, filp->f_pos, inode_number, DT_UNKNOWN) < 0)
				break;
		}
		filp->f_pos += de_len;

		continue;
	}
	if (bh) brelse(bh);
	return 0;
}

/*
 * Handle allocation of temporary space for name translation and
 * handling split directory entries.. The real work is done by
 * "do_isofs_readdir()".
 */
static int isofs_readdir(struct file *filp,
		void *dirent, filldir_t filldir)
{
	int result;
	char * tmpname;
	struct iso_directory_record * tmpde;
	struct inode *inode = filp->f_dentry->d_inode;


	tmpname = (char *)__get_free_page(GFP_KERNEL);
	if (tmpname == NULL)
		return -ENOMEM;

	lock_kernel();
	tmpde = (struct iso_directory_record *) (tmpname+1024);

	result = do_isofs_readdir(inode, filp, dirent, filldir, tmpname, tmpde);

	free_page((unsigned long) tmpname);
	unlock_kernel();
	return result;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/isofs/dir.c
	3	*
	4	* (C) 1992, 1993, 1994 Eric Youngdale Modified for ISO 9660 filesystem.
	5	*
	6	* (C) 1991 Linus Torvalds - minix filesystem
	7	*
	8	* Steve Beynon : Missing last directory entries fixed
	9	* (stephen@askone.demon.co.uk) : 21st June 1996
	10	*
	11	* isofs directory handling functions
	12	*/
1da177e4 LT	13	#include <linux/config.h>
1da177e4 LT	14	#include <linux/smp_lock.h>
94f2f715	15	#include "isofs.h"
1da177e4 LT	16
	17	static int isofs_readdir(struct file , void , filldir_t);
	18
	19	struct file_operations isofs_dir_operations =
	20	{
	21	.read = generic_read_dir,
	22	.readdir = isofs_readdir,
	23	};
	24
	25	/*
	26	* directories can handle most operations...
	27	*/
	28	struct inode_operations isofs_dir_inode_operations =
	29	{
	30	.lookup = isofs_lookup,
	31	};
	32
	33	int isofs_name_translate(struct iso_directory_record de, char new, struct inode *inode)
	34	{
	35	char * old = de->name;
	36	int len = de->name_len[0];
	37	int i;
	38
	39	for (i = 0; i < len; i++) {
	40	unsigned char c = old[i];
	41	if (!c)
	42	break;
	43
	44	if (c >= 'A' && c <= 'Z')
	45	c \|= 0x20; /* lower case */
	46
	47	/* Drop trailing '.;1' (ISO 9660:1988 7.5.1 requires period) */
	48	if (c == '.' && i == len - 3 && old[i + 1] == ';' && old[i + 2] == '1')
	49	break;
	50
	51	/* Drop trailing ';1' */
	52	if (c == ';' && i == len - 2 && old[i + 1] == '1')
	53	break;
	54
	55	/* Convert remaining ';' to '.' */
	56	/* Also '/' to '.' (broken Acorn-generated ISO9660 images) */
	57	if (c == ';' \|\| c == '/')
	58	c = '.';
	59
	60	new[i] = c;
	61	}
	62	return i;
	63	}
	64
	65	/* Acorn extensions written by Matthew Wilcox <willy@bofh.ai> 1998 */
	66	int get_acorn_filename(struct iso_directory_record * de,
	67	char * retname, struct inode * inode)
	68	{
	69	int std;
	70	unsigned char * chr;
	71	int retnamlen = isofs_name_translate(de, retname, inode);
	72	if (retnamlen == 0) return 0;
	73	std = sizeof(struct iso_directory_record) + de->name_len[0];
	74	if (std & 1) std++;
	75	if ((((unsigned char ) de) - std) != 32) return retnamlen;
	76	chr = ((unsigned char *) de) + std;
	77	if (strncmp(chr, "ARCHIMEDES", 10)) return retnamlen;
	78	if ((retname == '_') && ((chr[19] & 1) == 1)) retname = '!';
	79	if (((de->flags[0] & 2) == 0) && (chr[13] == 0xff)
80	&& ((chr[12] & 0xf0) == 0xf0))
81	{
82	retname[retnamlen] = ',';
83	sprintf(retname+retnamlen+1, "%3.3x",
84	((chr[12] & 0xf) << 8) \| chr[11]);
85	retnamlen += 4;
86	}
87	return retnamlen;
88	}
89
90	/*
91	* This should _really_ be cleaned up some day..
92	*/
93	static int do_isofs_readdir(struct inode inode, struct file filp,
94	void *dirent, filldir_t filldir,
95	char * tmpname, struct iso_directory_record * tmpde)
96	{
97	unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
98	unsigned char bufbits = ISOFS_BUFFER_BITS(inode);
99	unsigned long block, offset, block_saved, offset_saved;
100	unsigned long inode_number = 0; /* Quiet GCC */
101	struct buffer_head *bh = NULL;
102	int len;
103	int map;
104	int first_de = 1;
105	char p = NULL; / Quiet GCC */
106	struct iso_directory_record *de;
107	struct isofs_sb_info *sbi = ISOFS_SB(inode->i_sb);
108
109	offset = filp->f_pos & (bufsize - 1);
110	block = filp->f_pos >> bufbits;
111
112	while (filp->f_pos < inode->i_size) {
113	int de_len;
114
115	if (!bh) {
116	bh = isofs_bread(inode, block);
117	if (!bh)
118	return 0;
119	}
120
121	de = (struct iso_directory_record *) (bh->b_data + offset);
122
123	de_len = (unsigned char ) de;
124
125	/* If the length byte is zero, we should move on to the next
126	CDROM sector. If we are at the end of the directory, we
127	kick out of the while loop. */
128
129	if (de_len == 0) {
130	brelse(bh);
131	bh = NULL;
132	filp->f_pos = (filp->f_pos + ISOFS_BLOCK_SIZE) & ~(ISOFS_BLOCK_SIZE - 1);
133	block = filp->f_pos >> bufbits;
134	offset = 0;
135	continue;
136	}
137
138	block_saved = block;
139	offset_saved = offset;
140	offset += de_len;
141
142	/* Make sure we have a full directory entry */
143	if (offset >= bufsize) {
144	int slop = bufsize - offset + de_len;
145	memcpy(tmpde, de, slop);
146	offset &= bufsize - 1;
147	block++;
148	brelse(bh);
149	bh = NULL;
150	if (offset) {
151	bh = isofs_bread(inode, block);
152	if (!bh)
153	return 0;
154	memcpy((void *) tmpde + slop, bh->b_data, offset);
155	}
156	de = tmpde;
157	}
158
159	if (first_de) {
160	isofs_normalize_block_and_offset(de,
161	&block_saved,
162	&offset_saved);
163	inode_number = isofs_get_ino(block_saved,
164	offset_saved,
165	bufbits);
166	}
167
168	if (de->flags[-sbi->s_high_sierra] & 0x80) {
169	first_de = 0;
170	filp->f_pos += de_len;
171	continue;
172	}
173	first_de = 1;
174
175	/* Handle the case of the '.' directory */
176	if (de->name_len[0] == 1 && de->name[0] == 0) {
177	if (filldir(dirent, ".", 1, filp->f_pos, inode->i_ino, DT_DIR) < 0)
178	break;
179	filp->f_pos += de_len;
180	continue;
181	}
182
183	len = 0;
184
185	/* Handle the case of the '..' directory */
186	if (de->name_len[0] == 1 && de->name[0] == 1) {
187	inode_number = parent_ino(filp->f_dentry);
188	if (filldir(dirent, "..", 2, filp->f_pos, inode_number, DT_DIR) < 0)
189	break;
190	filp->f_pos += de_len;
191	continue;
192	}
193
194	/* Handle everything else. Do name translation if there
195	is no Rock Ridge NM field. */
9769f4eb JW	196
	197	/*
	198	* Do not report hidden files if so instructed, or associated
	199	* files unless instructed to do so
	200	*/
	201	if ((sbi->s_hide == 'y' &&
	202	(de->flags[-sbi->s_high_sierra] & 1)) \|\|
	203	(sbi->s_showassoc =='n' &&
	204	(de->flags[-sbi->s_high_sierra] & 4))) {
	205	filp->f_pos += de_len;
	206	continue;
1da177e4 LT	207	}
	208
	209	map = 1;
	210	if (sbi->s_rock) {
	211	len = get_rock_ridge_filename(de, tmpname, inode);
	212	if (len != 0) { /* may be -1 */
	213	p = tmpname;
	214	map = 0;
	215	}
	216	}
	217	if (map) {
	218	#ifdef CONFIG_JOLIET
	219	if (sbi->s_joliet_level) {
	220	len = get_joliet_filename(de, tmpname, inode);
	221	p = tmpname;
	222	} else
	223	#endif
	224	if (sbi->s_mapping == 'a') {
	225	len = get_acorn_filename(de, tmpname, inode);
	226	p = tmpname;
	227	} else
	228	if (sbi->s_mapping == 'n') {
	229	len = isofs_name_translate(de, tmpname, inode);
	230	p = tmpname;
	231	} else {
	232	p = de->name;
	233	len = de->name_len[0];
	234	}
	235	}
	236	if (len > 0) {
	237	if (filldir(dirent, p, len, filp->f_pos, inode_number, DT_UNKNOWN) < 0)
	238	break;
	239	}
	240	filp->f_pos += de_len;
	241
	242	continue;
	243	}
	244	if (bh) brelse(bh);
	245	return 0;
	246	}
	247
	248	/*
	249	* Handle allocation of temporary space for name translation and
	250	* handling split directory entries.. The real work is done by
	251	* "do_isofs_readdir()".
	252	*/
	253	static int isofs_readdir(struct file *filp,
	254	void *dirent, filldir_t filldir)
	255	{
	256	int result;
	257	char * tmpname;
	258	struct iso_directory_record * tmpde;
	259	struct inode *inode = filp->f_dentry->d_inode;
	260
	261
	262	tmpname = (char *)__get_free_page(GFP_KERNEL);
	263	if (tmpname == NULL)
	264	return -ENOMEM;
	265
	266	lock_kernel();
	267	tmpde = (struct iso_directory_record *) (tmpname+1024);
	268
	269	result = do_isofs_readdir(inode, filp, dirent, filldir, tmpname, tmpde);
	270
271	free_page((unsigned long) tmpname);
272	unlock_kernel();
273	return result;
274	}