* Fixed missing B_FS_IS_READONLY flag in fs_rfsstat(). This fixes bug #4009.

* Fixed many occurences of incorrect operator order, ie. "!flags & FLAG" does not what you might think it does. * Added TODOs to functionally questionable code. I really don't think this file system should actually be used read-write. Deleting files seems to be completely broken. * Fixed mixup of B_MOUNT_READ_ONLY vs. B_FS_IS_READONLY in nspace::flags. * Fixed many, many style issues, that file really was a mess. * Honoured 80 characters per line limit. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@30996 a95241bf-73f2-0310-859d-f6bbb57e9c96
2009-06-08 08:53:53 +00:00
parent 34068836d3
commit 188f391487
2 changed files with 628 additions and 595 deletions
@@ -66,7 +66,7 @@ get_node_type(ntfs_inode* ni, int* _type)
 	if (!na)
 		return ENOENT;

-	if (!ni->flags & FILE_ATTR_HIDDEN) {
+	if (!(ni->flags & FILE_ATTR_HIDDEN)) {
 		if (na->data_size == 0)
 			*_type = S_IFIFO;
 	}
@@ -112,7 +112,7 @@ fs_identify_partition(int fd, partition_data *partition, void **_cookie)
 	}

 	// check boot signature
-	if (((buf[0x1fe] != 0x55) || (buf[0x1ff] != 0xaa)) && (buf[0x15] == 0xf8))
+	if ((buf[0x1fe] != 0x55 || buf[0x1ff] != 0xaa) && buf[0x15] == 0xf8)
 		return -1;

 	// check boot signature NTFS
@@ -122,6 +122,7 @@ fs_identify_partition(int fd, partition_data *partition, void **_cookie)
 	// get path for device
 	if (!ioctl(fd, B_GET_PATH_FOR_DEVICE, devpath))
 		return -1;
+
 	// try mount
 	ntVolume = utils_mount_volume(devpath, MS_RDONLY, true);
 	if (!ntVolume)
@@ -132,12 +133,11 @@ fs_identify_partition(int fd, partition_data *partition, void **_cookie)
 	if (!cookie)
 		return -1;

-	memcpy(&(cookie->boot),&boot,512);
+	memcpy(&cookie->boot, &boot, 512);

 	strcpy(cookie->label, "NTFS Volume");

-	if(ntVolume->vol_name)
-		if(strlen(ntVolume->vol_name)>0)
+	if (ntVolume->vol_name && ntVolume->vol_name[0] != '\0')
 		strcpy(cookie->label, ntVolume->vol_name);

 	ntfs_umount(ntVolume, true);
@@ -147,18 +147,21 @@ fs_identify_partition(int fd, partition_data *partition, void **_cookie)
 	return 0.8f;
 }

+
 status_t
 fs_scan_partition(int fd, partition_data *partition, void *_cookie)
 {
 	identify_cookie *cookie = (identify_cookie *)_cookie;
 	partition->status = B_PARTITION_VALID;
 	partition->flags |= B_PARTITION_FILE_SYSTEM;
-	partition->content_size = sle64_to_cpu(cookie->boot.number_of_sectors) * le16_to_cpu(cookie->boot.bpb.bytes_per_sector);
+	partition->content_size = sle64_to_cpu(cookie->boot.number_of_sectors)
+		* le16_to_cpu(cookie->boot.bpb.bytes_per_sector);
 	partition->block_size = le16_to_cpu(cookie->boot.bpb.bytes_per_sector);
 	partition->content_name = strdup(cookie->label);
 	return B_OK;
 }

+
 void
 fs_free_identify_partition_cookie(partition_data *partition, void *_cookie)
 {
@@ -168,13 +171,14 @@ fs_free_identify_partition_cookie(partition_data *partition, void *_cookie)


 status_t
-fs_mount(fs_volume *_vol, const char *device, ulong flags, const char *args, ino_t *_rootID)
+fs_mount(fs_volume *_vol, const char *device, ulong flags, const char *args,
+	ino_t *_rootID)
 {
 	nspace *ns;
 	vnode *newNode = NULL;
 	char lockname[32];
 	void *handle;
-	unsigned long mnt_flags = 0;
+	unsigned long mountFlags = 0;
 	status_t result = B_NO_ERROR;

 	ERRPRINT("fs_mount - ENTER\n");
@@ -188,30 +192,33 @@ fs_mount(fs_volume *_vol, const char *device, ulong flags, const char *args, ino
 	*ns = (nspace) {
 		.state = NF_FreeClustersOutdate | NF_FreeMFTOutdate,
 		.show_sys_files = false,
-		.ro = false
+		.ro = false,
+		.flags = 0
 	};

-	ns->flags = flags;
-
 	strcpy(ns->devicePath,device);

 	sprintf(lockname, "ntfs_lock %lx", ns->id);
 	recursive_lock_init_etc(&(ns->vlock), lockname, MUTEX_FLAG_CLONE_NAME);

 	handle = load_driver_settings("ntfs");
-	ns->show_sys_files = ! (strcasecmp(get_driver_parameter(handle, "hide_sys_files", "true", "true"), "true") == 0);
-	ns->ro = strcasecmp(get_driver_parameter(handle, "read_only", "false", "false"), "false") != 0;
-	ns->noatime = strcasecmp(get_driver_parameter(handle, "no_atime", "true", "true"), "true") == 0;
+	ns->show_sys_files = ! (strcasecmp(get_driver_parameter(handle,
+		"hide_sys_files", "true", "true"), "true") == 0);
+	ns->ro = strcasecmp(get_driver_parameter(handle, "read_only", "false",
+		"false"), "false") != 0;
+	ns->noatime = strcasecmp(get_driver_parameter(handle, "no_atime", "true",
+		"true"), "true") == 0;
 	unload_driver_settings(handle);

-	if (ns->ro || ns->flags & B_MOUNT_READ_ONLY) {
-		mnt_flags |= MS_RDONLY;
-		ns->flags |= B_MOUNT_READ_ONLY;
+	if (ns->ro || (flags & B_MOUNT_READ_ONLY) != 0) {
+		mountFlags |= MS_RDONLY;
+		ns->flags |= B_FS_IS_READONLY;
 	}
 //	if (ns->noatime)
 //		mnt_flags |= MS_NOATIME;

-	ns->ntvol=utils_mount_volume(device,mnt_flags,true);
+	// TODO: this does not take read-only volumes into account!
+	ns->ntvol = utils_mount_volume(device, mountFlags, true);
 	if (ns->ntvol != NULL)
 		result = B_NO_ERROR;
 	else
@@ -227,7 +234,6 @@ fs_mount(fs_volume *_vol, const char *device, ulong flags, const char *args, ino
 		if (newNode == NULL)
 			result = ENOMEM;
 		else {
-
 			newNode->vnid = *_rootID;
 			newNode->parent_vnid = -1;

@@ -237,8 +243,7 @@ fs_mount(fs_volume *_vol, const char *device, ulong flags, const char *args, ino
 				free(ns);
 				result = EINVAL;
 				goto exit;
-			}
-			else {
+			} else {
 				result = B_NO_ERROR;
 				ntfs_mark_free_space_outdated(ns);
 				ntfs_calc_free_space(ns);
@@ -247,12 +252,12 @@ fs_mount(fs_volume *_vol, const char *device, ulong flags, const char *args, ino
 	}

 exit:
-
 	ERRPRINT("fs_mount - EXIT, result code is %s\n", strerror(result));

 	return result;
 }

+
 status_t
 fs_unmount(fs_volume *_vol)
 {
@@ -272,6 +277,7 @@ fs_unmount(fs_volume *_vol)
 	return result;
 }

+
 status_t
 fs_rfsstat(fs_volume *_vol, struct fs_info *fss)
 {
@@ -286,7 +292,8 @@ fs_rfsstat( fs_volume *_vol, struct fs_info * fss )

 	fss->dev = ns->id;
 	fss->root = FILE_root;
-	fss->flags = B_FS_IS_PERSISTENT|B_FS_HAS_MIME|B_FS_HAS_ATTR;
+	fss->flags = B_FS_IS_PERSISTENT | B_FS_HAS_MIME | B_FS_HAS_ATTR | ns->flags;
+
 	fss->block_size = ns->ntvol->cluster_size;
 	fss->io_size = 65536;
 	fss->total_blocks = ns->ntvol->nr_clusters;
@@ -294,9 +301,10 @@ fs_rfsstat( fs_volume *_vol, struct fs_info * fss )
 	strncpy(fss->device_name, ns->devicePath, sizeof(fss->device_name));
 	strncpy(fss->volume_name, ns->ntvol->vol_name, sizeof(fss->volume_name));

-	for (i = strlen(fss->volume_name)-1; i >=0 ; i--)
+	for (i = strlen(fss->volume_name) - 1; i >=0 ; i--) {
 		if (fss->volume_name[i] != ' ')
 			break;
+	}
 	if (i < 0)
 		strcpy(fss->volume_name, "NTFS Untitled");
 	else
@@ -331,12 +339,12 @@ fs_wfsstat( fs_volume *_vol, const struct fs_info * fss, uint32 mask)
 	}

 exit:
-
 	UNLOCK_VOL(ns);

 	return result;
 }

+
 status_t
 fs_walk(fs_volume *_vol, fs_vnode *_dir, const char *file, ino_t *vnid)
 {
@@ -398,7 +406,6 @@ fs_walk(fs_volume *_vol, fs_vnode *_dir, const char *file, ino_t *vnid)
 	}

 exit:
-
 	ERRPRINT("fs_walk - EXIT, result is %s\n", strerror(result));

 	UNLOCK_VOL(ns);
@@ -406,8 +413,10 @@ exit:
 	return result;
 }

+
 status_t
-fs_get_vnode_name(fs_volume *_vol, fs_vnode *_vnode, char *buffer, size_t bufferSize)
+fs_get_vnode_name(fs_volume *_vol, fs_vnode *_vnode, char *buffer,
+	size_t bufferSize)
 {
 	nspace *ns = (nspace*)_vol->private_volume;
 	vnode *node = (vnode*)_vnode->private_node;
@@ -429,13 +438,13 @@ fs_get_vnode_name(fs_volume *_vol, fs_vnode *_vnode, char *buffer, size_t buffer
 		result = EINVAL;
 		goto exit;
 	}
+
 	name = strrchr(path, '/');
 	name++;

 	strlcpy(buffer, name, bufferSize);

 exit:
-
 	if (ni)
 		ntfs_inode_close(ni);

@@ -446,7 +455,8 @@ exit:


 status_t
-fs_read_vnode(fs_volume *_vol, ino_t vnid, fs_vnode *_node, int *_type, uint32 *_flags, bool reenter)
+fs_read_vnode(fs_volume *_vol, ino_t vnid, fs_vnode *_node, int *_type,
+	uint32 *_flags, bool reenter)
 {
 	nspace *ns = (nspace*)_vol->private_volume;
 	vnode *newNode = NULL;
@@ -492,11 +502,10 @@ fs_read_vnode(fs_volume *_vol, ino_t vnid, fs_vnode *_node, int *_type, uint32 *
 		}

 		_node->private_node = newNode;
-	}
-	else
+	} else
 		result = ENOMEM;
-exit:

+exit:
 	if (ni != NULL)
 		ntfs_inode_close(ni);

@@ -511,6 +520,7 @@ exit:
 	return result;
 }

+
 status_t
 fs_write_vnode(fs_volume *_vol, fs_vnode *_node, bool reenter)
 {
@@ -523,7 +533,6 @@ fs_write_vnode( fs_volume *_vol, fs_vnode *_node, bool reenter )

 	ERRPRINT("fs_write_vnode - ENTER (%Ld)\n", node->vnid);

-	if (node)
 	free(node);

 	ERRPRINT("fs_write_vnode - EXIT\n");
@@ -534,6 +543,7 @@ fs_write_vnode( fs_volume *_vol, fs_vnode *_node, bool reenter )
 	return result;
 }

+
 status_t
 fs_remove_vnode(fs_volume *_vol, fs_vnode *_node, bool reenter)
 {
@@ -541,12 +551,12 @@ fs_remove_vnode( fs_volume *_vol, fs_vnode *_node, bool reenter )
 	vnode *node = (vnode*)_node->private_node;
 	status_t result = B_NO_ERROR;

+	// TODO: this does not look right! The space if the node must be freed *here*
 	if (!reenter)
 		LOCK_VOL(ns);

 	ERRPRINT("fs_remove_vnode - ENTER (%Ld)\n", node->vnid);

-	if(node)
 	free(node);

 	ERRPRINT("fs_remove_vnode - EXIT, result is %s\n", strerror(result));
@@ -557,6 +567,7 @@ fs_remove_vnode( fs_volume *_vol, fs_vnode *_node, bool reenter )
 	return result;
 }

+
 status_t
 fs_rstat(fs_volume *_vol, fs_vnode *_node, struct stat *stbuf)
 {
@@ -608,12 +619,14 @@ fs_rstat( fs_volume *_vol, fs_vnode *_node, struct stat *stbuf )

 		stbuf->st_size = na->data_size;

-		if (!ni->flags & FILE_ATTR_HIDDEN) {
+		if (!(ni->flags & FILE_ATTR_HIDDEN)) {
 			if (na->data_size == 0)
 			stbuf->st_mode = S_IFIFO;
 		}

-		if (na->data_size <= sizeof(INTX_FILE_TYPES) + sizeof(ntfschar) * MAX_PATH && na->data_size >sizeof(INTX_FILE_TYPES)) {
+		if (na->data_size <= sizeof(INTX_FILE_TYPES)
+				+ sizeof(ntfschar) * MAX_PATH
+			&& na->data_size >sizeof(INTX_FILE_TYPES)) {
 			INTX_FILE *intx_file;

 			intx_file = ntfs_malloc(na->data_size);
@@ -622,7 +635,8 @@ fs_rstat( fs_volume *_vol, fs_vnode *_node, struct stat *stbuf )
 				ntfs_attr_close(na);
 				goto exit;
 			}
-			if (ntfs_attr_pread(na, 0, na->data_size,intx_file) != na->data_size) {
+			if (ntfs_attr_pread(na, 0, na->data_size,intx_file)
+					!= na->data_size) {
 				result = EINVAL;
 				free(intx_file);
 				ntfs_attr_close(na);
@@ -647,7 +661,6 @@ fs_rstat( fs_volume *_vol, fs_vnode *_node, struct stat *stbuf )
 	stbuf->st_mtime = ni->last_data_change_time;

 exit:
-
 	if (ni)
 		ntfs_inode_close(ni);

@@ -656,9 +669,9 @@ exit:
 	UNLOCK_VOL(ns);

 	return result;
-
 }

+
 status_t
 fs_wstat(fs_volume *_vol, fs_vnode *_node, const struct stat *st, uint32 mask)
 {
@@ -678,13 +691,11 @@ fs_wstat( fs_volume *_vol, fs_vnode *_node, const struct stat *st, uint32 mask )
 	}

 	if (mask & B_STAT_SIZE) {
-
 		ERRPRINT("fs_wstat: setting file size to %Lx\n", st->st_size);

 		if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
 			result = EISDIR;
 		} else {
-
 			ntfs_attr *na = ntfs_attr_open(ni, AT_DATA, NULL, 0);
 			if (!na) {
 				result = EINVAL;
@@ -701,7 +712,6 @@ fs_wstat( fs_volume *_vol, fs_vnode *_node, const struct stat *st, uint32 mask )
 	}

 	if (mask & B_STAT_MODIFICATION_TIME) {
-
 		ERRPRINT("fs_wstat: setting modification time\n");

 		ni->last_access_time = st->st_atime;
@@ -712,7 +722,6 @@ fs_wstat( fs_volume *_vol, fs_vnode *_node, const struct stat *st, uint32 mask )
 	}

 exit:
-
 	if (ni)
 		ntfs_inode_close(ni);

@@ -767,7 +776,6 @@ fs_fsync(fs_volume *_vol, fs_vnode *_node)
 	ntfs_inode_sync(ni);

 exit:
-
 	if (ni)
 		ntfs_inode_close(ni);

@@ -778,6 +786,7 @@ exit:
 	return result;
 }

+
 status_t
 fs_open(fs_volume *_vol, fs_vnode *_node, int omode, void **_cookie)
 {
@@ -814,16 +823,13 @@ fs_open(fs_volume *_vol, fs_vnode *_node, int omode, void **_cookie)

 	cookie = (filecookie*)ntfs_calloc(sizeof(filecookie));

-	if ( cookie != NULL )
-	{
+	if (cookie != NULL) {
 		cookie->omode = omode;
 		*_cookie = (void*)cookie;
-	}
-	else
+	} else
 		result = ENOMEM;

 exit:
-
 	if (na)
 		ntfs_attr_close(na);

@@ -839,7 +845,8 @@ exit:


 status_t
-fs_create(fs_volume *_vol, fs_vnode *_dir, const char *name, int omode, int perms, void **_cookie, ino_t *_vnid)
+fs_create(fs_volume *_vol, fs_vnode *_dir, const char *name, int omode,
+	int perms, void **_cookie, ino_t *_vnid)
 {
 	nspace *ns = (nspace*)_vol->private_volume;
 	vnode *dir = (vnode*)_dir->private_node;
@@ -850,7 +857,7 @@ fs_create(fs_volume *_vol, fs_vnode *_dir, const char *name, int omode, int perm
 	ntfs_inode *bi = NULL;
 	ntfschar *uname = NULL;
 	status_t result = B_NO_ERROR;
-	int 		uname_len;
+	int unameLength;

 	if (ns->flags & B_FS_IS_READONLY) {
 		ERRPRINT("ntfs is read-only\n");
@@ -866,7 +873,8 @@ fs_create(fs_volume *_vol, fs_vnode *_dir, const char *name, int omode, int perm
 		goto exit;
 	}

-	if (name == NULL || *name == '\0' || strchr(name, '/') || strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
+	if (name == NULL || *name == '\0' || strchr(name, '/')
+		|| strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
 		result =  EINVAL;
 		goto exit;
 	}
@@ -877,13 +885,13 @@ fs_create(fs_volume *_vol, fs_vnode *_dir, const char *name, int omode, int perm
 		goto exit;
 	}

-	if ( !bi->mrec->flags & MFT_RECORD_IS_DIRECTORY ) {
+	if (!(bi->mrec->flags & MFT_RECORD_IS_DIRECTORY)) {
 		result = EINVAL;
 		goto exit;
 	}

-	uname_len = ntfs_mbstoucs(name, &uname);
-	if (uname_len < 0) {
+	unameLength = ntfs_mbstoucs(name, &uname);
+	if (unameLength < 0) {
 		result = EINVAL;
 		goto exit;
 	}
@@ -898,7 +906,8 @@ fs_create(fs_volume *_vol, fs_vnode *_dir, const char *name, int omode, int perm
 	}

 	ni = ntfs_pathname_to_inode(ns->ntvol, bi, name);
-	if(ni)	{  //file exist
+	if (ni) {
+		// file exists
 		*_vnid	= MREF(ni->mft_no);
 		if (omode & O_TRUNC) {
 			na = ntfs_attr_open(ni, AT_DATA, NULL, 0);
@@ -909,8 +918,7 @@ fs_create(fs_volume *_vol, fs_vnode *_dir, const char *name, int omode, int perm
 				result = errno;
 		}
 	} else {
-		ni = ntfs_create(bi, uname, uname_len, S_IFREG);
-
+		ni = ntfs_create(bi, uname, unameLength, S_IFREG);
 		if (ni)	{
 			*_vnid = MREF(ni->mft_no);

@@ -931,7 +939,6 @@ fs_create(fs_volume *_vol, fs_vnode *_dir, const char *name, int omode, int perm
 			ntfs_mark_free_space_outdated(ns);

 			notify_entry_created(ns->id, MREF(bi->mft_no), name, *_vnid);
-
 		} else
 			result = errno;
 	}
@@ -939,7 +946,6 @@ fs_create(fs_volume *_vol, fs_vnode *_dir, const char *name, int omode, int perm
 	free(uname);

 exit:
-
 	if (result >= B_OK) {
 		*_cookie = cookie;
 	} else
@@ -959,12 +965,13 @@ exit:
 	return result;
 }

+
 status_t
-fs_read( fs_volume *_vol, fs_vnode *_dir, void *_cookie, off_t offset, void *buf, size_t *len )
+fs_read(fs_volume *_vol, fs_vnode *_dir, void *_cookie, off_t offset, void *buf,
+	size_t *len)
 {
 	nspace *ns = (nspace*)_vol->private_volume;
 	vnode *node = (vnode*)_dir->private_node;
-	//filecookie *cookie = (filecookie*)_cookie;  //temporary not used
 	ntfs_inode *ni = NULL;
 	ntfs_attr *na = NULL;
 	size_t  size = *len;
@@ -1003,6 +1010,7 @@ fs_read( fs_volume *_vol, fs_vnode *_dir, void *_cookie, off_t offset, void *buf
 	}
 	if (offset + size > na->data_size)
 		size = na->data_size - offset;
+
 	while (size) {
 		result = ntfs_attr_pread(na, offset, size, buf);
 		if (result < (s64)size)
@@ -1018,13 +1026,12 @@ fs_read( fs_volume *_vol, fs_vnode *_dir, void *_cookie, off_t offset, void *buf
 	}
 	result = total;
 	*len = result;
-exit:

+exit:
 	if (na)
 		ntfs_attr_close(na);

 exit2:
-
 	if (ni)
 		ntfs_inode_close(ni);

@@ -1037,7 +1044,8 @@ exit2:


 status_t
-fs_write( fs_volume *_vol, fs_vnode *_dir, void *_cookie, off_t offset, const void *buf, size_t *len )
+fs_write(fs_volume *_vol, fs_vnode *_dir, void *_cookie, off_t offset,
+	const void *buf, size_t *len)
 {
 	nspace *ns = (nspace*)_vol->private_volume;
 	vnode *node = (vnode*)_dir->private_node;
@@ -1114,15 +1122,16 @@ fs_write( fs_volume *_vol, fs_vnode *_dir, void *_cookie, off_t offset, const vo
 	*len = total;
 	ERRPRINT(("fs_write - OK\n"));
 	result = B_NO_ERROR;
+
 exit:
 	if (na)
 		ntfs_attr_close(na);
 exit2:
-
 	if (ni)
 		ntfs_inode_close(ni);

-	ERRPRINT("fs_write - EXIT, result is %s, writed %d bytes\n", strerror(result),(int)(*len));
+	ERRPRINT("fs_write - EXIT, result is %s, writed %d bytes\n",
+		strerror(result), (int)(*len));

 	UNLOCK_VOL(ns);

@@ -1139,18 +1148,19 @@ fs_close(fs_volume *_vol, fs_vnode *_node, void *cookie)
 	return B_NO_ERROR;
 }

+
 status_t
 fs_free_cookie(fs_volume *_vol, fs_vnode *_node, void *cookie)
 {
 	ERRPRINT("fs_free_cookie - ENTER\n");

-	if(cookie)
 	free(cookie);

 	ERRPRINT("fs_free_cookie - EXIT\n");
 	return B_NO_ERROR;
 }

+
 status_t
 fs_access(fs_volume *_vol, fs_vnode *_node, int mode)
 {
@@ -1160,15 +1170,16 @@ fs_access( fs_volume *_vol, fs_vnode *_node, int mode )
 	return B_NO_ERROR;
 }

+
 status_t
-fs_readlink(fs_volume *_vol, fs_vnode *_node, char *buff, size_t *buff_size)
+fs_readlink(fs_volume *_vol, fs_vnode *_node, char *buffer, size_t *bufferSize)
 {
 	nspace *ns = (nspace*)_vol->private_volume;
 	vnode *node = (vnode*)_node->private_node;
 	ntfs_attr *na = NULL;
-	INTX_FILE 	*intx_file = NULL;
+	INTX_FILE *intxFile = NULL;
 	ntfs_inode *ni = NULL;
-	char 		*buf = NULL;
+	char *tempBuffer = NULL;
 	status_t result = B_NO_ERROR;
 	int l = 0;

@@ -1176,7 +1187,7 @@ fs_readlink(fs_volume *_vol, fs_vnode *_node, char *buff, size_t *buff_size)

 	ERRPRINT("fs_readlink - ENTER\n");

-	if(ns==NULL || node==NULL || buff ==NULL || buff_size ==NULL) {
+	if (ns == NULL || node == NULL || buffer == NULL || bufferSize == NULL) {
 		result = EINVAL;
 		goto exit;
 	}
@@ -1201,48 +1212,50 @@ fs_readlink(fs_volume *_vol, fs_vnode *_node, char *buff, size_t *buff_size)
 		result = EINVAL;
 		goto exit;
 	}
-	if (na->data_size > sizeof(INTX_FILE_TYPES) +
-			sizeof(ntfschar) * MAX_PATH) {
+	if (na->data_size > sizeof(INTX_FILE_TYPES) + sizeof(ntfschar) * MAX_PATH) {
 		result = ENAMETOOLONG;
 		goto exit;
 	}
 	/* Receive file content. */
-	intx_file = ntfs_malloc(na->data_size);
-	if (!intx_file) {
+	intxFile = ntfs_malloc(na->data_size);
+	if (!intxFile) {
 		result = errno;
 		goto exit;
 	}
-	if (ntfs_attr_pread(na, 0, na->data_size, intx_file) != na->data_size) {
+	if (ntfs_attr_pread(na, 0, na->data_size, intxFile) != na->data_size) {
 		result = errno;
 		goto exit;
 	}
 	/* Sanity check. */
-	if (intx_file->magic != INTX_SYMBOLIC_LINK) {
+	if (intxFile->magic != INTX_SYMBOLIC_LINK) {
 		result = EINVAL;
 		goto exit;
 	}
 	/* Convert link from unicode to local encoding. */
-	l = ntfs_ucstombs(intx_file->target, (na->data_size - offsetof(INTX_FILE, target)) / sizeof(ntfschar), &buf, 0);
+	l = ntfs_ucstombs(intxFile->target,
+		(na->data_size - offsetof(INTX_FILE, target)) / sizeof(ntfschar),
+		&tempBuffer, 0);

 	if (l < 0) {
 		result = errno;
 		goto exit;
 	}
+	if (tempBuffer == NULL) {
+		result = B_NO_MEMORY;
+		goto exit;
+	}

-	ERRPRINT("fs_readlink - LINK:[%s]\n",buf);
+	ERRPRINT("fs_readlink - LINK:[%s]\n", buffer);

-	strcpy(buff,buf);
-	if(buf)
-		free(buf);
+	strlcpy(buffer, tempBuffer, *bufferSize);
+	free(tempBuffer);

-	*buff_size = l+1;
+	*bufferSize = l + 1;

 	result = B_NO_ERROR;

 exit:
-
-	if (intx_file)
-		free(intx_file);
+	free(intxFile);
 	if (na)
 		ntfs_attr_close(na);
 	if (ni)
@@ -1255,18 +1268,20 @@ exit:
 	return result;
 }

+
 status_t
-fs_create_symlink(fs_volume *_vol, fs_vnode *_dir, const char *name, const char *target, int mode)
+fs_create_symlink(fs_volume *_vol, fs_vnode *_dir, const char *name,
+	const char *target, int mode)
 {
 	nspace *ns = (nspace*)_vol->private_volume;
 	vnode *dir = (vnode*)_dir->private_node;
 	ntfs_inode *sym = NULL;
 	ntfs_inode *bi = NULL;
 	vnode *symnode = NULL;
-	ntfschar 	*uname = NULL,
-				*utarget = NULL;
-	int			uname_len,
-				utarget_len;
+	ntfschar *uname = NULL;
+	ntfschar *utarget = NULL;
+	int unameLength;
+	int utargetLength;
 	status_t result = B_NO_ERROR;
 	int fmode;

@@ -1285,19 +1300,19 @@ fs_create_symlink(fs_volume *_vol, fs_vnode *_dir, const char *name, const char
 		goto exit;
 	}

-	uname_len = ntfs_mbstoucs(name, &uname);
-	if (uname_len < 0) {
+	unameLength = ntfs_mbstoucs(name, &uname);
+	if (unameLength < 0) {
 		result = EINVAL;
 		goto exit;
 	}

-	utarget_len = ntfs_mbstoucs(target, &utarget);
-	if (utarget_len < 0) {
+	utargetLength = ntfs_mbstoucs(target, &utarget);
+	if (utargetLength < 0) {
 		result = EINVAL;
 		goto exit;
 	}

-	sym = ntfs_create_symlink(bi, uname, uname_len, utarget, utarget_len);
+	sym = ntfs_create_symlink(bi, uname, unameLength, utarget, utargetLength);
 	if (sym == NULL) {
 		result = EINVAL;
 		goto exit;
@@ -1320,16 +1335,18 @@ fs_create_symlink(fs_volume *_vol, fs_vnode *_dir, const char *name, const char
 		fmode = FS_FILE_MODE;
 	}

-	if ((result = publish_vnode(_vol, MREF(sym->mft_no), symnode,
-			&gNTFSVnodeOps, S_IFLNK | fmode, 0)) != 0)
-		ERRPRINT("fs_symlink - new_vnode failed for vnid %Ld: %s\n", MREF(sym->mft_no), strerror(result));
+	result = publish_vnode(_vol, MREF(sym->mft_no), symnode, &gNTFSVnodeOps,
+		S_IFLNK | fmode, 0);
+	if (result != 0) {
+		ERRPRINT("fs_symlink - new_vnode failed for vnid %Ld: %s\n",
+			MREF(sym->mft_no), strerror(result));
+	}

 	put_vnode(_vol, MREF(sym->mft_no));

 	notify_entry_created(ns->id, MREF( bi->mft_no ), name, MREF(sym->mft_no));

 exit:
-
 	if (sym)
 		ntfs_inode_close(sym);
 	if (bi)
@@ -1350,7 +1367,7 @@ fs_mkdir(fs_volume *_vol, fs_vnode *_dir, const char *name,	int perms)
 	vnode *dir = (vnode*)_dir->private_node;
 	vnode *newNode =NULL;
 	ntfschar *uname = NULL;
-	int 		uname_len;
+	int unameLength;
 	ntfs_inode *ni = NULL;
 	ntfs_inode *bi = NULL;
 	status_t result = B_NO_ERROR;
@@ -1375,19 +1392,18 @@ fs_mkdir(fs_volume *_vol, fs_vnode *_dir, const char *name,	int perms)
 		goto exit;
 	}

-	if (! bi->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
+	if (!(bi->mrec->flags & MFT_RECORD_IS_DIRECTORY)) {
 		result = EINVAL;
 		goto exit;
 	}

-	uname_len = ntfs_mbstoucs(name, &uname);
-	if (uname_len < 0) {
+	unameLength = ntfs_mbstoucs(name, &uname);
+	if (unameLength < 0) {
 		result = EINVAL;
 		goto exit;
 	}

-	ni = ntfs_create(bi, uname, uname_len, S_IFDIR);
-
+	ni = ntfs_create(bi, uname, unameLength, S_IFDIR);
 	if (ni)	{
 		ino_t vnid = MREF(ni->mft_no);

@@ -1410,12 +1426,10 @@ fs_mkdir(fs_volume *_vol, fs_vnode *_dir, const char *name,	int perms)
 		ntfs_mark_free_space_outdated(ns);

 		notify_entry_created(ns->id, MREF(bi->mft_no), name, vnid);
-	}
-	else
+	} else
 		result = errno;

 exit:
-
 	if (ni)
 		ntfs_inode_close(ni);
 	if (bi)
@@ -1428,8 +1442,10 @@ exit:
 	return result;
 }

+
 status_t
-fs_rename(fs_volume *_vol, fs_vnode *_odir, const char *oldname, fs_vnode *_ndir, const char *newname)
+fs_rename(fs_volume *_vol, fs_vnode *_odir, const char *oldname, fs_vnode *_ndir,
+	const char *newname)
 {
 	nspace *ns = (nspace*)_vol->private_volume;
 	vnode *odir = (vnode*)_odir->private_node;
@@ -1444,10 +1460,10 @@ fs_rename(fs_volume *_vol, fs_vnode *_odir, const char *oldname, fs_vnode *_ndir
 	ntfs_inode *ndi = NULL;
 	ntfs_inode *odi = NULL;

-	ntfschar 	*unewname = NULL,
-				*uoldname=NULL;
-	int			unewname_len,
-				uoldname_len;
+	ntfschar *unewname = NULL;
+	ntfschar *uoldname = NULL;
+	int unewnameLength;
+	int uoldnameLength;

 	status_t result = B_NO_ERROR;

@@ -1475,14 +1491,14 @@ fs_rename(fs_volume *_vol, fs_vnode *_odir, const char *oldname, fs_vnode *_ndir
 		goto exit;

 	// convert names from utf8 to unicode string
-	unewname_len = ntfs_mbstoucs(newname, &unewname);
-	if (unewname_len < 0) {
+	unewnameLength = ntfs_mbstoucs(newname, &unewname);
+	if (unewnameLength < 0) {
 		result = EINVAL;
 		goto exit;
 	}

-	uoldname_len = ntfs_mbstoucs(oldname, &uoldname);
-	if (uoldname_len < 0) {
+	uoldnameLength = ntfs_mbstoucs(oldname, &uoldname);
+	if (uoldnameLength < 0) {
 		result = EINVAL;
 		goto exit;
 	}
@@ -1494,7 +1510,7 @@ fs_rename(fs_volume *_vol, fs_vnode *_odir, const char *oldname, fs_vnode *_ndir
 		goto exit;
 	}

-	ovnid = MREF( ntfs_inode_lookup_by_name(odi, uoldname, uoldname_len) );
+	ovnid = MREF(ntfs_inode_lookup_by_name(odi, uoldname, uoldnameLength));
 	if (ovnid == (u64) -1) {
 		result = EINVAL;
 		goto exit;
@@ -1505,10 +1521,12 @@ fs_rename(fs_volume *_vol, fs_vnode *_odir, const char *oldname, fs_vnode *_ndir
 		goto exit;


-	if(odir != ndir) {	//moving
+	if (odir != ndir) {
+		// moving
 		ndi = ntfs_inode_open(ns->ntvol, ndir->vnid);
 		if (ndi != NULL) {
-				nvnid = MREF( ntfs_inode_lookup_by_name(ndi, unewname, unewname_len) );
+			nvnid = MREF(ntfs_inode_lookup_by_name(ndi, unewname,
+				unewnameLength));
 			if (nvnid != (u64) -1)
 				get_vnode(_vol, nvnid, (void**)&nnode);
 		}
@@ -1525,7 +1543,7 @@ fs_rename(fs_volume *_vol, fs_vnode *_odir, const char *oldname, fs_vnode *_ndir
 			goto exit;
 		}

-			if (ntfs_link(oi, ndi, unewname, unewname_len))  {
+		if (ntfs_link(oi, ndi, unewname, unewnameLength)) {
 			ntfs_inode_close(oi);
 			result = EINVAL;
 			goto exit;
@@ -1546,17 +1564,18 @@ fs_rename(fs_volume *_vol, fs_vnode *_odir, const char *oldname, fs_vnode *_ndir

 		onode->parent_vnid = MREF(ndi->mft_no);

-			notify_entry_moved(ns->id, MREF( odi->mft_no ), oldname, MREF( ndi->mft_no ), newname, onode->vnid );
-			notify_attribute_changed(ns->id, onode->vnid, "BEOS:TYPE", B_ATTR_CHANGED);
+		notify_entry_moved(ns->id, MREF(odi->mft_no), oldname, MREF(ndi->mft_no),
+			newname, onode->vnid);

-			ntfs_delete(oi, odi, uoldname, uoldname_len);
-			oi = odi = NULL; /* ntfs_delete() always closes ni and dir_ni */
+		ntfs_delete(oi, odi, uoldname, uoldnameLength);
+		oi = odi = NULL;
+			/* ntfs_delete() always closes ni and dir_ni */

 		put_vnode(_vol, onode->vnid);
+	} else {
+		// renaming

-	} else { //renaming
-
-			nvnid = MREF( ntfs_inode_lookup_by_name(odi, unewname, unewname_len) );
+		nvnid = MREF(ntfs_inode_lookup_by_name(odi, unewname, unewnameLength));
 		if (nvnid != (u64) -1)
 			get_vnode(_vol, nvnid, (void**)&nnode);

@@ -1572,7 +1591,7 @@ fs_rename(fs_volume *_vol, fs_vnode *_odir, const char *oldname, fs_vnode *_ndir
 			goto exit;
 		}

-			if (ntfs_link(oi, odi, unewname, unewname_len))  {
+		if (ntfs_link(oi, odi, unewname, unewnameLength))  {
 			ntfs_inode_close(oi);
 			result = EINVAL;
 			goto exit;
@@ -1591,18 +1610,18 @@ fs_rename(fs_volume *_vol, fs_vnode *_odir, const char *oldname, fs_vnode *_ndir
 			goto exit;
 		}

-			notify_entry_moved(ns->id, MREF( odi->mft_no ), oldname, MREF( odi->mft_no ), newname, onode->vnid );
-			notify_attribute_changed(ns->id, onode->vnid, "BEOS:TYPE", B_ATTR_CHANGED);
+		notify_entry_moved(ns->id, MREF(odi->mft_no), oldname, MREF(odi->mft_no),
+			newname, onode->vnid);
 		put_vnode(_vol, onode->vnid);

-			ntfs_delete(oi, odi, uoldname, uoldname_len);
-			oi = odi = NULL; /* ntfs_delete() always closes ni and dir_ni */
+		ntfs_delete(oi, odi, uoldname, uoldnameLength);
+		oi = odi = NULL;
+			/* ntfs_delete() always closes ni and dir_ni */
 	}

-
 exit:
-	if(unewname!=NULL)free(unewname);
-	if(uoldname!=NULL)free(uoldname);
+	free(unewname);
+	free(uoldname);

 	if (odi)
 		ntfs_inode_close(odi);
@@ -1614,10 +1633,10 @@ exit:
 	UNLOCK_VOL(ns);

 	return result;
-
 }

-status_t
+
+static status_t
 do_unlink(fs_volume *_vol, vnode *dir, const char *name, bool isdir)
 {
 	nspace *vol = (nspace*)_vol->private_volume;
@@ -1626,11 +1645,11 @@ do_unlink(fs_volume *_vol, vnode *dir, const char *name, bool	isdir)
 	ntfs_inode *ni = NULL;
 	ntfs_inode *bi = NULL;
 	ntfschar *uname = NULL;
-	int 		uname_len;
+	int unameLength;
 	status_t result = B_NO_ERROR;

-	uname_len = ntfs_mbstoucs(name, &uname);
-	if (uname_len < 0) {
+	unameLength = ntfs_mbstoucs(name, &uname);
+	if (unameLength < 0) {
 		result = EINVAL;
 		goto exit1;
 	}
@@ -1641,7 +1660,7 @@ do_unlink(fs_volume *_vol, vnode *dir, const char *name, bool	isdir)
 		goto exit1;
 	}

-	vnid = MREF( ntfs_inode_lookup_by_name(bi, uname, uname_len) );
+	vnid = MREF(ntfs_inode_lookup_by_name(bi, uname, unameLength));

 	if ( vnid == (u64) -1 || vnid == FILE_root)	{
 		result = EINVAL;
@@ -1650,8 +1669,7 @@ do_unlink(fs_volume *_vol, vnode *dir, const char *name, bool	isdir)

 	result = get_vnode(_vol, vnid, (void**)&node);

-	if(result != B_NO_ERROR || node==NULL)
-	{
+	if (result != B_NO_ERROR || node==NULL) {
 		result = ENOENT;
 		goto exit1;
 	}
@@ -1663,7 +1681,7 @@ do_unlink(fs_volume *_vol, vnode *dir, const char *name, bool	isdir)
 	}

 	if (isdir) {
-		if (!ni->mrec->flags & MFT_RECORD_IS_DIRECTORY) {
+		if (!(ni->mrec->flags & MFT_RECORD_IS_DIRECTORY)) {
 			result = ENOTDIR;
 			goto exit2;
 		}
@@ -1676,7 +1694,8 @@ do_unlink(fs_volume *_vol, vnode *dir, const char *name, bool	isdir)
 		goto exit2;
 	}

-	if(ntfs_delete(ni, bi, uname, uname_len))
+	// TODO: the file must not be deleted here, only unlinked!
+	if (ntfs_delete(ni, bi, uname, unameLength))
 	 	result = errno;

 	ni = bi = NULL;
@@ -1686,15 +1705,14 @@ do_unlink(fs_volume *_vol, vnode *dir, const char *name, bool	isdir)
 	notify_entry_removed(vol->id, dir->vnid, name, vnid);

 	result = remove_vnode(_vol, vnid);
+
 exit2:
 	put_vnode(_vol, vnid);
 exit1:
-	if(uname!=NULL)
 	free(uname);

 	if (ni)
 		ntfs_inode_close(ni);
-
 	if (bi)
 		ntfs_inode_close(bi);

@@ -1735,10 +1753,10 @@ fs_rmdir(fs_volume *_vol, fs_vnode *_dir, const char *name)

 	result = do_unlink(_vol, dir, name, true);

+	// TODO: space must not be freed here, but in fs_remove_vnode()!!!
 	ntfs_mark_free_space_outdated(ns);

 exit1:
-
 	ERRPRINT("fs_rmdir - EXIT, result is %s\n", strerror(result));

 	UNLOCK_VOL(ns);
@@ -1780,10 +1798,10 @@ fs_unlink(fs_volume *_vol, fs_vnode *_dir, const char *name)

 	result = do_unlink(_vol, dir, name, false);

+	// TODO: space must not be freed here, but in fs_remove_vnode()!!!
 	ntfs_mark_free_space_outdated(ns);

 exit:
-
 	ERRPRINT("fs_unlink - EXIT, result is %s\n", strerror(result));

 	UNLOCK_VOL(ns);
@@ -19,9 +19,8 @@
 * file COPYING); if not, write to the Free Software Foundation,Inc., 59 Temple
 * Place, Suite 330, Boston, MA 02111-1307 USA
 */
- 
-#ifndef _fs_FUNC_H_
-#define _fs_FUNC_H_ 
+#ifndef NTFS_FS_FUNC_H
+#define NTFS_FS_FUNC_H

 #include <stdlib.h>
 #include <unistd.h>
@@ -42,52 +41,68 @@
 #include "lock.h"
 #include "volume_util.h"

-#define FS_DIR_MODE		S_IFDIR | S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IWGRP | S_IWOTH
-#define FS_FILE_MODE	S_IFREG | S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IWGRP | S_IWOTH
-#define FS_SLNK_MODE	S_IFLNK | S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IWGRP | S_IWOTH
+#define FS_DIR_MODE		S_IFDIR | S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | \
+	S_IWGRP | S_IWOTH
+#define FS_FILE_MODE	S_IFREG | S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | \
+	S_IWGRP | S_IWOTH
+#define FS_SLNK_MODE	S_IFLNK | S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | \
+	S_IWGRP | S_IWOTH


 extern fs_vnode_ops gNTFSVnodeOps;
 extern fs_volume_ops gNTFSVolumeOps;


-float		fs_identify_partition(int fd, partition_data *partition, void **_cookie);
+float		fs_identify_partition(int fd, partition_data *partition,
+				void **_cookie);
 status_t	fs_scan_partition(int fd, partition_data *partition, void *_cookie);
-void		fs_free_identify_partition_cookie(partition_data *partition, void *_cookie);
+void		fs_free_identify_partition_cookie(partition_data *partition,
+				void *_cookie);

-status_t	fs_mount(fs_volume *_vol, const char *device, ulong flags, const char *args, ino_t *vnid);
-status_t	fs_create_symlink(fs_volume *volume, fs_vnode *dir, const char *name, const char *target, int mode);
-status_t   	fs_create(fs_volume *volume, fs_vnode *dir, const char *name, int omode, int perms, void **_cookie, ino_t *_vnid);
-status_t	fs_walk(fs_volume *_vol, fs_vnode *_dir, const char *file, ino_t *vnid);
-status_t	fs_get_vnode_name(fs_volume *volume, fs_vnode *vnode, char *buffer, size_t bufferSize);
+status_t	fs_mount(fs_volume *_vol, const char *device, ulong flags,
+				const char *args, ino_t *vnid);
+status_t	fs_create_symlink(fs_volume *volume, fs_vnode *dir, const char *name,
+				const char *target, int mode);
+status_t   	fs_create(fs_volume *volume, fs_vnode *dir, const char *name,
+				int omode, int perms, void **_cookie, ino_t *_vnid);
+status_t	fs_walk(fs_volume *_vol, fs_vnode *_dir, const char *file,
+				ino_t *vnid);
+status_t	fs_get_vnode_name(fs_volume *volume, fs_vnode *vnode, char *buffer,
+				size_t bufferSize);
 status_t	fs_unmount(fs_volume *_vol);
 status_t	fs_rfsstat(fs_volume *_vol, struct fs_info *);
 status_t  	fs_wfsstat(fs_volume *_vol, const struct fs_info *fss, uint32 mask);
 status_t 	fs_sync(fs_volume *_vol);
-status_t	fs_read_vnode(fs_volume *_vol, ino_t vnid, fs_vnode *_node, int *_type, uint32 *_flags, bool reenter);
+status_t	fs_read_vnode(fs_volume *_vol, ino_t vnid, fs_vnode *_node,
+				int *_type, uint32 *_flags, bool reenter);
 status_t	fs_write_vnode(fs_volume *volume, fs_vnode *vnode, bool reenter);
 status_t    fs_remove_vnode(fs_volume *volume, fs_vnode *vnode, bool reenter);
 status_t	fs_access(fs_volume *volume, fs_vnode *vnode, int mode);
 status_t	fs_rstat(fs_volume *volume, fs_vnode *vnode, struct stat *st);
-status_t	fs_wstat(fs_volume *volume, fs_vnode *vnode, const struct stat *st, uint32 mask);
-status_t	fs_open(fs_volume *volume, fs_vnode *vnode, int omode, void **cookie);
+status_t	fs_wstat(fs_volume *volume, fs_vnode *vnode, const struct stat *st,
+				uint32 mask);
+status_t	fs_open(fs_volume *volume, fs_vnode *vnode, int omode,
+				void **cookie);
 status_t	fs_close(fs_volume *volume, fs_vnode *vnode, void *cookie);
 status_t	fs_free_cookie(fs_volume *volume, fs_vnode *vnode, void *cookie);
-status_t	fs_read(fs_volume *volume, fs_vnode *vnode, void *cookie, off_t pos, void *buf, size_t *len);
-status_t	fs_write(fs_volume *volume, fs_vnode *vnode, void *cookie, off_t pos, const void *buf, size_t *len);
-status_t	fs_mkdir(fs_volume *volume, fs_vnode *parent, const char *name,	int perms);
+status_t	fs_read(fs_volume *volume, fs_vnode *vnode, void *cookie, off_t pos,
+				void *buf, size_t *len);
+status_t	fs_write(fs_volume *volume, fs_vnode *vnode, void *cookie, off_t pos,
+				const void *buf, size_t *len);
+status_t	fs_mkdir(fs_volume *volume, fs_vnode *parent, const char *name,
+				int perms);
 status_t 	fs_rmdir(fs_volume *volume, fs_vnode *parent, const char *name);
 status_t	fs_opendir(fs_volume *volume, fs_vnode *vnode, void** cookie);
-status_t  	fs_readdir(fs_volume *volume, fs_vnode *vnode, void *_cookie, struct dirent *buf, size_t bufsize, uint32 *num );
+status_t  	fs_readdir(fs_volume *volume, fs_vnode *vnode, void *_cookie,
+				struct dirent *buf, size_t bufsize, uint32 *num);
 status_t	fs_rewinddir(fs_volume *volume, fs_vnode *vnode, void *cookie);
 status_t	fs_closedir(fs_volume *volume, fs_vnode *vnode, void *cookie);
 status_t	fs_free_dircookie(fs_volume *volume, fs_vnode *vnode, void *cookie);
-status_t 	fs_readlink(fs_volume *volume, fs_vnode *link, char *buf, size_t *bufsize);
+status_t 	fs_readlink(fs_volume *volume, fs_vnode *link, char *buf,
+				size_t *bufsize);
 status_t 	fs_fsync(fs_volume *_vol, fs_vnode *_node);
-status_t    fs_rename(fs_volume *volume, fs_vnode *fromDir, const char *fromName, fs_vnode *toDir, const char *toName);
+status_t    fs_rename(fs_volume *volume, fs_vnode *fromDir, const char *fromName,
+				fs_vnode *toDir, const char *toName);
 status_t    fs_unlink(fs_volume *volume, fs_vnode *dir, const char *name);

-
-status_t 	do_unlink(fs_volume *volume, vnode *dir, const char *name, bool isdir);
-
-#endif
+#endif	// NTFS_FS_FUNC_H