kde-extraapps/partitionmanager/lib/fatlabel/plain_io.c

/*  Copyright 1995-2007,2009 Alain Knaff.
 *  Copyright 2010 Volker Lanz (vl@fidra.de)
 *  This file is part of mtools.
 *
 *  Mtools 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
 *  (at your option) any later version.
 *
 *  Mtools is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  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 Mtools.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Io to a plain file or device
 *
 * written by:
 *
 * Alain L. Knaff
 * alain@knaff.lu
 *
 */

#include "stream.h"
#include "mtools.h"
#include "msdos.h"
#include "plain_io.h"
#include "partition.h"
#include "llong.h"
#include "force_io.h"
#include "devices.h"

#include <sys/file.h>
#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>

struct SimpleFile_t
{
	struct Class_t *Class;
	int refs;
	struct Stream_t *Next;
	struct Stream_t *Buffer;
	struct stat64 statbuf;
	int fd;
	off_t offset;
	off_t lastwhere;
	int seekable;
	int privileged;
	int scsi_sector_size;
	void *extra_data; /* extra system dependant information for scsi */
	int swap; /* do the word swapping */
};

static int lock_dev(int fd, int mode)
{
	if (flock(fd, (mode ? LOCK_EX : LOCK_SH) | LOCK_NB) < 0)
		return errno == EINVAL || errno ==  EOPNOTSUPP ? 0 : 1;

	return 0;
}

typedef int (*iofn) (int, char *, int);

static void swap_buffer(char *buf, size_t len)
{
	unsigned int i;

	for (i = 0; i<len; i+=2)
	{
		char temp = buf[i];
		buf[i] = buf[i+1];
		buf[i+1] = temp;
	}
}

static int file_io(struct Stream_t *Stream, char *buf, off_t where, int len, iofn io)
{
	DeclareThis(struct SimpleFile_t);

	where += This->offset;

	if (This->seekable && where != This->lastwhere )
	{
		if(mt_lseek( This->fd, where, SEEK_SET) < 0 )
		{
			perror("seek");
			This->lastwhere = (off_t) -1;
			return -1;
		}
	}

	int ret = io(This->fd, buf, len);

	if (ret == -1 )
	{
		perror("plain_io");
		This->lastwhere = (off_t) -1;
		return -1;
	}

	This->lastwhere = where + ret;

	return ret;
}

static int file_read(struct Stream_t *Stream, char *buf, off_t where, size_t len)
{
	DeclareThis(struct SimpleFile_t);

	int result = file_io(Stream, buf, where, len, (iofn) read);

	if (This->swap)
		swap_buffer(buf, len);

	return result;
}

static int file_write(struct Stream_t *Stream, char *buf, off_t where, size_t len)
{
	DeclareThis(struct SimpleFile_t);

	if (!This->swap)
		return file_io(Stream, buf, where, len, (iofn) write);
	else
	{
		char* swapping = malloc(len);

		memcpy(swapping, buf, len);
		swap_buffer(swapping, len);

		int result = file_io(Stream, swapping, where, len, (iofn) write);

		free(swapping);
		return result;
	}
}

static int file_flush(struct Stream_t UNUSED(*Stream))
{
	return 0;
}

static int file_free(struct Stream_t *Stream)
{
	DeclareThis(struct SimpleFile_t);
	return (This->fd > 2) ? close(This->fd) : 0;
}

static int file_geom(struct Stream_t *Stream, struct device *dev, struct device *orig_dev, int media, union bootsector *boot)
{
	DeclareThis(struct SimpleFile_t);

	dev->ssize = 2; /* allow for init_geom to change it */
	dev->use_2m = 0x80; /* disable 2m mode to begin */

	if(media == 0xf0 || media >= 0x100)
	{
		dev->heads = WORD(nheads);
		dev->sectors = WORD(nsect);

		size_t tot_sectors = DWORD(bigsect);

		if (WORD(psect))
			tot_sectors = WORD(psect);

		int sect_per_track = dev->heads * dev->sectors;

		if(sect_per_track == 0)
		{
			/* add some fake values if sect_per_track is
			 * zero. Indeed, some atari disks lack the
			 * geometry values (i.e. have zeroes in their
			 * place). In order to avoid division by zero
			 * errors later on, plug 1 everywhere
			 */
			dev->heads = 1;
			dev->sectors = 1;
			sect_per_track = 1;
		}

		tot_sectors += sect_per_track - 1; /* round size up */
		dev->tracks = tot_sectors / sect_per_track;
	}
	else
	{
		fprintf(stderr,"Unknown media type\n");
		return -1; // TODO: make sure this is interpreted as invalid return code
	}

	int sectors = dev->sectors;
	dev->sectors = dev->sectors * WORD(secsiz) / 512;

	int ret = init_geom(This->fd,dev, orig_dev, &This->statbuf);
	dev->sectors = sectors;

	return ret;
}


static int file_data(struct Stream_t *Stream, time_t *date, size_t *size,
		     int *type, int *address)
{
	DeclareThis(struct SimpleFile_t);

	if(date)
		*date = This->statbuf.st_mtime;

	if(size)
		*size = This->statbuf.st_size;

	if(type)
		*type = S_ISDIR(This->statbuf.st_mode);

	if(address)
		*address = 0;

	return 0;
}

static struct Class_t SimpleFileClass =
{
	file_read,
	file_write,
	file_flush,
	file_free,
	file_geom,
	file_data,
	0, /* pre_allocate */
	0
};


struct Stream_t *SimpleFileOpen(struct device *dev, struct device *orig_dev,
			const char *name, int mode, char *errmsg,
			int mode2, int locked, size_t *maxSize)
{
	struct SimpleFile_t *This;

	This = New(struct SimpleFile_t);

	if (!This)
	{
		fprintf(stderr, "%s %d: Allocation memory for simple file failed.\n", __FILE__, __LINE__);
		return 0;
	}

	This->scsi_sector_size = 512;
	This->seekable = 1;

	This->Class = &SimpleFileClass;
	if (!name || strcmp(name,"-") == 0)
	{
		This->fd = mode == O_RDONLY ? 0 : 1;
		This->seekable = 0;
		This->refs = 1;
		This->Next = 0;
		This->Buffer = 0;

		if (fstat64(This->fd, &This->statbuf) < 0)
		{
		    free(This);

		    if(errmsg)
				snprintf(errmsg,199,"Can't stat -: %s", strerror(errno));

		    return NULL;
		}

		return (struct Stream_t *) This;
	}

	if(dev)
		mode |= dev->mode;

    This->fd = open(name, mode | O_LARGEFILE, 0666);

	if (This->fd < 0)
	{
		free(This);

		if(errmsg)
			snprintf(errmsg, 199, "Can't open %s: %s", name, strerror(errno));

		return NULL;
	}

	if (fstat64(This->fd, &This->statbuf) < 0)
	{
		free(This);

		if(errmsg)
			snprintf(errmsg, 199,"Can't stat %s: %s", name, strerror(errno));

		return NULL;
	}

	/* lock the device on writes */
	if (locked && lock_dev(This->fd, mode == O_RDWR))
	{
		if(errmsg)
			snprintf(errmsg, 199, "plain floppy: device \"%s\" busy (%s):", dev ? dev->name : "unknown", strerror(errno));
		close(This->fd);
		free(This);

		return NULL;
	}

	/* set default parameters, if needed */
	if (dev)
	{
		if (dev->tracks && init_geom(This->fd, dev, orig_dev, &This->statbuf))
		{
			close(This->fd);
			free(This);

			if(errmsg)
				sprintf(errmsg,"init: set default params");

			return NULL;
		}

		This->offset = (off_t) dev->offset;
	}
	else
		This->offset = 0;

	This->refs = 1;
	This->Next = 0;
	This->Buffer = 0;

	if(maxSize)
	{
		*maxSize = max_off_t_seek;

		if(This->offset > 0 && (size_t) This->offset > *maxSize)
		{
			close(This->fd);
			free(This);

			if(errmsg)
				sprintf(errmsg,"init: Big disks not supported");

			return NULL;
		}

		*maxSize -= This->offset;
	}
	/* partitioned drive */

	This->swap = 0;

	if(!(mode2 & NO_OFFSET) && dev && dev->partition > 4)
	    fprintf(stderr, "Invalid partition %d (must be between 0 and 4), ignoring it\n", dev->partition);

	while(!(mode2 & NO_OFFSET) && dev && dev->partition && dev->partition <= 4)
	{
		unsigned char buf[2048];
		struct partition *partTable = (struct partition *)(buf+ 0x1ae);
		size_t partOff;

		/* read the first sector, or part of it */
		if (force_read((struct Stream_t *)This, (char*) buf, 0, 512) != 512)
			break;

		if( _WORD(buf + 510) != 0xaa55)
			break;

		partOff = BEGIN(partTable[dev->partition]);
		if (maxSize)
		{
			if (partOff > *maxSize >> 9)
			{
				close(This->fd);
				free(This);

				if(errmsg)
					sprintf(errmsg,"init: Big disks not supported");

				return NULL;
			}

			*maxSize -= (off_t) partOff << 9;
		}

		This->offset += (off_t) partOff << 9;
		if(!partTable[dev->partition].sys_ind)
		{
			if(errmsg)
				sprintf(errmsg, "init: non-existent partition");

			close(This->fd);
			free(This);

			return NULL;
		}

		if(!dev->tracks)
		{
			dev->heads = head(partTable[dev->partition].end) + 1;
			dev->sectors = sector(partTable[dev->partition].end);
			dev->tracks = cyl(partTable[dev->partition].end) - cyl(partTable[dev->partition].start) + 1;
		}

		dev->hidden = dev->sectors*head(partTable[dev->partition].start) + sector(partTable[dev->partition].start) - 1;
		break;
	}

	This->lastwhere = -This->offset;
	/* provoke a seek on those devices that don't start on a partition
	 * boundary */

	return (struct Stream_t *) This;
}

int SimpleFileClose(struct Stream_t* Stream)
{
	DeclareThis(struct SimpleFile_t);
	return close(This->fd);
}