X-Git-Url: https://git.sven.stormbind.net/?p=sven%2Fexfat-utils.git;a=blobdiff_plain;f=libexfat%2Fio.c;h=514383ca4bedb64bf12ed4a28c6e4bbf3c87d6f6;hp=25988f0a97ac84910e44abe993ef0984e10f36b4;hb=2fa6c5654e0a345af10df5227b77d9f468759f20;hpb=dbe4348df2ba88986e13163ef13d09fb7247589d

diff --git a/libexfat/io.c b/libexfat/io.c
index 25988f0..514383c 100644
--- a/libexfat/io.c
+++ b/libexfat/io.c
@@ -2,11 +2,12 @@
 	io.c (02.09.09)
 	exFAT file system implementation library.
 
-	Copyright (C) 2009, 2010  Andrew Nayenko
+	Free exFAT implementation.
+	Copyright (C) 2010-2017  Andrew Nayenko
 
-	This program is free software: you can redistribute it and/or modify
+	This program is free software; you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
+	the Free Software Foundation, either version 2 of the License, or
 	(at your option) any later version.
 
 	This program is distributed in the hope that it will be useful,
@@ -14,66 +15,268 @@
 	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 	GNU General Public License for more details.
 
-	You should have received a copy of the GNU General Public License
-	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+	You should have received a copy of the GNU General Public License along
+	with this program; if not, write to the Free Software Foundation, Inc.,
+	51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
 #include "exfat.h"
 #include <inttypes.h>
 #include <sys/types.h>
-#include <sys/uio.h>
 #include <sys/stat.h>
 #include <fcntl.h>
-#define __USE_UNIX98 /* for pread() in Linux */
 #include <unistd.h>
-
-#if _FILE_OFFSET_BITS != 64
-	#error You should define _FILE_OFFSET_BITS=64
+#include <string.h>
+#include <errno.h>
+#if defined(__APPLE__)
+#include <sys/disk.h>
+#elif defined(__OpenBSD__)
+#include <sys/param.h>
+#include <sys/disklabel.h>
+#include <sys/dkio.h>
+#include <sys/ioctl.h>
 #endif
+#include <sys/mount.h>
 
-int exfat_open(const char* spec, int ro)
+struct exfat_dev
 {
 	int fd;
-	struct stat stbuf;
+	enum exfat_mode mode;
+	off_t size; /* in bytes */
+};
+
+static int open_ro(const char* spec)
+{
+	return open(spec, O_RDONLY);
+}
+
+static int open_rw(const char* spec)
+{
+	int fd = open(spec, O_RDWR);
+#ifdef __linux__
+	int ro = 0;
 
-	fd = open(spec, ro ? O_RDONLY : O_RDWR);
-	if (fd < 0)
+	/*
+	   This ioctl is needed because after "blockdev --setro" kernel still
+	   allows to open the device in read-write mode but fails writes.
+	*/
+	if (fd != -1 && ioctl(fd, BLKROGET, &ro) == 0 && ro)
 	{
-		exfat_error("failed to open `%s' in read-%s mode", spec,
-				ro ? "only" : "write");
+		close(fd);
+		errno = EROFS;
 		return -1;
 	}
-	if (fstat(fd, &stbuf) != 0)
+#endif
+	return fd;
+}
+
+struct exfat_dev* exfat_open(const char* spec, enum exfat_mode mode)
+{
+	struct exfat_dev* dev;
+	struct stat stbuf;
+
+	dev = malloc(sizeof(struct exfat_dev));
+	if (dev == NULL)
 	{
-		close(fd);
-		exfat_error("failed to fstat `%s'", spec);
-		return -1;
+		exfat_error("failed to allocate memory for device structure");
+		return NULL;
 	}
-	if (!S_ISBLK(stbuf.st_mode) && !S_ISREG(stbuf.st_mode))
+
+	switch (mode)
 	{
-		close(fd);
-		exfat_error("`%s' is neither a block device, nor a regular file",
-				spec);
-		return -1;
+	case EXFAT_MODE_RO:
+		dev->fd = open_ro(spec);
+		if (dev->fd == -1)
+		{
+			free(dev);
+			exfat_error("failed to open '%s' in read-only mode: %s", spec,
+					strerror(errno));
+			return NULL;
+		}
+		dev->mode = EXFAT_MODE_RO;
+		break;
+	case EXFAT_MODE_RW:
+		dev->fd = open_rw(spec);
+		if (dev->fd == -1)
+		{
+			free(dev);
+			exfat_error("failed to open '%s' in read-write mode: %s", spec,
+					strerror(errno));
+			return NULL;
+		}
+		dev->mode = EXFAT_MODE_RW;
+		break;
+	case EXFAT_MODE_ANY:
+		dev->fd = open_rw(spec);
+		if (dev->fd != -1)
+		{
+			dev->mode = EXFAT_MODE_RW;
+			break;
+		}
+		dev->fd = open_ro(spec);
+		if (dev->fd != -1)
+		{
+			dev->mode = EXFAT_MODE_RO;
+			exfat_warn("'%s' is write-protected, mounting read-only", spec);
+			break;
+		}
+		free(dev);
+		exfat_error("failed to open '%s': %s", spec, strerror(errno));
+		return NULL;
 	}
-	return fd;
+
+	if (fstat(dev->fd, &stbuf) != 0)
+	{
+		close(dev->fd);
+		free(dev);
+		exfat_error("failed to fstat '%s'", spec);
+		return NULL;
+	}
+	if (!S_ISBLK(stbuf.st_mode) &&
+		!S_ISCHR(stbuf.st_mode) &&
+		!S_ISREG(stbuf.st_mode))
+	{
+		close(dev->fd);
+		free(dev);
+		exfat_error("'%s' is neither a device, nor a regular file", spec);
+		return NULL;
+	}
+
+#if defined(__APPLE__)
+	if (!S_ISREG(stbuf.st_mode))
+	{
+		uint32_t block_size = 0;
+		uint64_t blocks = 0;
+
+		if (ioctl(dev->fd, DKIOCGETBLOCKSIZE, &block_size) != 0)
+		{
+			close(dev->fd);
+			free(dev);
+			exfat_error("failed to get block size");
+			return NULL;
+		}
+		if (ioctl(dev->fd, DKIOCGETBLOCKCOUNT, &blocks) != 0)
+		{
+			close(dev->fd);
+			free(dev);
+			exfat_error("failed to get blocks count");
+			return NULL;
+		}
+		dev->size = blocks * block_size;
+	}
+	else
+#elif defined(__OpenBSD__)
+	if (!S_ISREG(stbuf.st_mode))
+	{
+		struct disklabel lab;
+		struct partition* pp;
+		char* partition;
+
+		if (ioctl(dev->fd, DIOCGDINFO, &lab) == -1)
+		{
+			close(dev->fd);
+			free(dev);
+			exfat_error("failed to get disklabel");
+			return NULL;
+		}
+
+		/* Don't need to check that partition letter is valid as we won't get
+		   this far otherwise. */
+		partition = strchr(spec, '\0') - 1;
+		pp = &(lab.d_partitions[*partition - 'a']);
+		dev->size = DL_GETPSIZE(pp) * lab.d_secsize;
+
+		if (pp->p_fstype != FS_NTFS)
+			exfat_warn("partition type is not 0x07 (NTFS/exFAT); "
+					"you can fix this with fdisk(8)");
+	}
+	else
+#endif
+	{
+		/* works for Linux, FreeBSD, Solaris */
+		dev->size = exfat_seek(dev, 0, SEEK_END);
+		if (dev->size <= 0)
+		{
+			close(dev->fd);
+			free(dev);
+			exfat_error("failed to get size of '%s'", spec);
+			return NULL;
+		}
+		if (exfat_seek(dev, 0, SEEK_SET) == -1)
+		{
+			close(dev->fd);
+			free(dev);
+			exfat_error("failed to seek to the beginning of '%s'", spec);
+			return NULL;
+		}
+	}
+
+	return dev;
+}
+
+int exfat_close(struct exfat_dev* dev)
+{
+	int rc = 0;
+
+	if (close(dev->fd) != 0)
+	{
+		exfat_error("failed to close device: %s", strerror(errno));
+		rc = -EIO;
+	}
+	free(dev);
+	return rc;
+}
+
+int exfat_fsync(struct exfat_dev* dev)
+{
+	int rc = 0;
+
+	if (fsync(dev->fd) != 0)
+	{
+		exfat_error("fsync failed: %s", strerror(errno));
+		rc = -EIO;
+	}
+	return rc;
+}
+
+enum exfat_mode exfat_get_mode(const struct exfat_dev* dev)
+{
+	return dev->mode;
 }
 
-void exfat_read_raw(void* buffer, size_t size, off_t offset, int fd)
+off_t exfat_get_size(const struct exfat_dev* dev)
 {
-	if (pread(fd, buffer, size, offset) != size)
-		exfat_bug("failed to read %zu bytes from file at %"PRIu64, size,
-				(uint64_t) offset);
+	return dev->size;
 }
 
-void exfat_write_raw(const void* buffer, size_t size, off_t offset, int fd)
+off_t exfat_seek(struct exfat_dev* dev, off_t offset, int whence)
 {
-	if (pwrite(fd, buffer, size, offset) != size)
-		exfat_bug("failed to write %zu bytes to file at %"PRIu64, size,
-				(uint64_t) offset);
+	return lseek(dev->fd, offset, whence);
 }
 
-ssize_t exfat_read(const struct exfat* ef, struct exfat_node* node,
+ssize_t exfat_read(struct exfat_dev* dev, void* buffer, size_t size)
+{
+	return read(dev->fd, buffer, size);
+}
+
+ssize_t exfat_write(struct exfat_dev* dev, const void* buffer, size_t size)
+{
+	return write(dev->fd, buffer, size);
+}
+
+ssize_t exfat_pread(struct exfat_dev* dev, void* buffer, size_t size,
+		off_t offset)
+{
+	return pread(dev->fd, buffer, size, offset);
+}
+
+ssize_t exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size,
+		off_t offset)
+{
+	return pwrite(dev->fd, buffer, size, offset);
+}
+
+ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node,
 		void* buffer, size_t size, off_t offset)
 {
 	cluster_t cluster;
@@ -88,8 +291,8 @@ ssize_t exfat_read(const struct exfat* ef, struct exfat_node* node,
 	cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
 	if (CLUSTER_INVALID(cluster))
 	{
-		exfat_error("got invalid cluster");
-		return -1;
+		exfat_error("invalid cluster 0x%x while reading", cluster);
+		return -EIO;
 	}
 
 	loffset = offset % CLUSTER_SIZE(*ef->sb);
@@ -98,31 +301,43 @@ ssize_t exfat_read(const struct exfat* ef, struct exfat_node* node,
 	{
 		if (CLUSTER_INVALID(cluster))
 		{
-			exfat_error("got invalid cluster");
-			return -1;
+			exfat_error("invalid cluster 0x%x while reading", cluster);
+			return -EIO;
 		}
 		lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
-		exfat_read_raw(bufp, lsize, exfat_c2o(ef, cluster) + loffset, ef->fd);
+		if (exfat_pread(ef->dev, bufp, lsize,
+					exfat_c2o(ef, cluster) + loffset) < 0)
+		{
+			exfat_error("failed to read cluster %#x", cluster);
+			return -EIO;
+		}
 		bufp += lsize;
 		loffset = 0;
 		remainder -= lsize;
 		cluster = exfat_next_cluster(ef, node, cluster);
 	}
-	if (!ef->ro && !ef->noatime)
+	if (!(node->attrib & EXFAT_ATTRIB_DIR) && !ef->ro && !ef->noatime)
 		exfat_update_atime(node);
-	return size - remainder;
+	return MIN(size, node->size - offset) - remainder;
 }
 
-ssize_t exfat_write(struct exfat* ef, struct exfat_node* node,
+ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node,
 		const void* buffer, size_t size, off_t offset)
 {
+	int rc;
 	cluster_t cluster;
 	const char* bufp = buffer;
 	off_t lsize, loffset, remainder;
 
-	if (offset + size > node->size)
+ 	if (offset > node->size)
 	{
-		int rc = exfat_truncate(ef, node, offset + size);
+		rc = exfat_truncate(ef, node, offset, true);
+		if (rc != 0)
+			return rc;
+	}
+  	if (offset + size > node->size)
+	{
+		rc = exfat_truncate(ef, node, offset + size, false);
 		if (rc != 0)
 			return rc;
 	}
@@ -132,8 +347,8 @@ ssize_t exfat_write(struct exfat* ef, struct exfat_node* node,
 	cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
 	if (CLUSTER_INVALID(cluster))
 	{
-		exfat_error("got invalid cluster");
-		return -1;
+		exfat_error("invalid cluster 0x%x while writing", cluster);
+		return -EIO;
 	}
 
 	loffset = offset % CLUSTER_SIZE(*ef->sb);
@@ -142,16 +357,24 @@ ssize_t exfat_write(struct exfat* ef, struct exfat_node* node,
 	{
 		if (CLUSTER_INVALID(cluster))
 		{
-			exfat_error("got invalid cluster");
-			return -1;
+			exfat_error("invalid cluster 0x%x while writing", cluster);
+			return -EIO;
 		}
 		lsize = MIN(CLUSTER_SIZE(*ef->sb) - loffset, remainder);
-		exfat_write_raw(bufp, lsize, exfat_c2o(ef, cluster) + loffset, ef->fd);
+		if (exfat_pwrite(ef->dev, bufp, lsize,
+				exfat_c2o(ef, cluster) + loffset) < 0)
+		{
+			exfat_error("failed to write cluster %#x", cluster);
+			return -EIO;
+		}
 		bufp += lsize;
 		loffset = 0;
 		remainder -= lsize;
 		cluster = exfat_next_cluster(ef, node, cluster);
 	}
-	exfat_update_mtime(node);
+	if (!(node->attrib & EXFAT_ATTRIB_DIR))
+		/* directory's mtime should be updated by the caller only when it
+		   creates or removes something in this directory */
+		exfat_update_mtime(node);
 	return size - remainder;
 }