/*
 * Copyright 2000, International Business Machines Corporation and others.
 * All Rights Reserved.
 * 
 * This software has been released under the terms of the IBM Public
 * License.  For details, see the LICENSE file in the top-level source
 * directory or online at http://www.openafs.org/dl/license10.html
 */

#include <afsconfig.h>
#include <afs/param.h>

RCSID("$Header: /cvs/openafs/src/usd/usd_nt.c,v 1.5 2001/08/08 00:04:14 shadow Exp $");

#include <windows.h>
#include <stdio.h>
#include <io.h>
#include <winioctl.h>
#include <sys/stat.h>
#include <crtdbg.h>

#include <afs/errmap_nt.h>
#include <afs/usd.h>


/* WinNT-specific implementation of user space device I/O for WinNT devices. */

/* This module uses the following usd_handle fields:
 * handle -- the Win32 (HANDLE) returned by CreateFile.
 * fullPathName -- allocated ptr (char *) to pathname used to open device.
 * openFlags -- unused
 * privateData -- Device size (afs_uint32) in 1Kb units.
 */

/* Module-specific constants */
#define TAPEOP_RETRYMAX  5

#define TRANSIENT_TAPE_ERROR(err) \
    ((err) == ERROR_BUS_RESET || (err) == ERROR_MEDIA_CHANGED)

/* Interface Functions */

static int usd_DeviceRead(
  usd_handle_t usd,
  char *buf,
  afs_uint32 nbytes,
  afs_uint32 *xferdP)
{
    HANDLE fd = usd->handle;
    DWORD bytesRead;

    if (xferdP == NULL)
	xferdP = &bytesRead;
    else
	*xferdP = 0;

    if (ReadFile(fd, buf, nbytes, xferdP, NULL)) {
	/* read was successful */
	return 0;
    } else {
	/* read failed */
	return nterr_nt2unix(GetLastError(), EIO);
    }
}
 
static int usd_DeviceWrite(
  usd_handle_t usd,
  char *buf,
  afs_uint32 nbytes,
  afs_uint32 *xferdP)
{
    HANDLE fd = usd->handle;
    DWORD bytesWritten;
    DWORD nterr;

    if (xferdP == NULL)
      xferdP = &bytesWritten;
    else
      *xferdP = 0;

    if (WriteFile(fd, buf, nbytes, xferdP, NULL)) {
      /* write was successful */
	return 0;
    } else {
      /* write failed */
      nterr = GetLastError();
      if (nterr == ERROR_END_OF_MEDIA){
	*xferdP = 0;
	return 0;  /* indicate end of tape condition */
      }
      else
	return nterr_nt2unix(nterr, EIO);
    }
}

/* usd_DeviceSeek --
 *
 * TODO -- Episode tries to determine the size of a disk device
 * empirically by binary searching for the last region it can successfully
 * read from the device.  It uses only USD_SEEK and USD_READ operations, so
 * this is portable as long as the underlying device driver fails
 * gracefully when an attempt is made to access past the end of the device.
 * Unfortunately this fails on WinNT when accessing a floppy disk.  Reads
 * from floppy disks at tremendous offsets blithely succeed.  Luckily, the
 * Win32 interface provides a way to determine the disk size.
 *
 * Add a check of the offset against the disk size to fix this problem. */
 
static int usd_DeviceSeek(
  usd_handle_t usd,
  afs_hyper_t reqOff,
  int whence,
  afs_hyper_t *curOffP)
{
    HANDLE fd = usd->handle;
    DWORD method, result;
    DWORD error;
    long loOffset, hiOffset;

    /* determine move method based on value of whence */

    if (whence == SEEK_SET) {
	method = FILE_BEGIN;
    } else if (whence == SEEK_CUR) {
	method = FILE_CURRENT;
    } else if (whence == SEEK_END) {
	method = FILE_END;
    } else {
	/* whence is invalid */
	return EINVAL;
    }
    _ASSERT(sizeof(DWORD) == 4);

    /* attempt seek */
    
    loOffset = hgetlo(reqOff);
    hiOffset = hgethi(reqOff);

    if (usd->privateData) {

      /* For disk devices that know their size, check the offset against the
       * limit provided by DeviceIoControl(). */
      
      DWORDLONG offset = ( (DWORDLONG)hgethi(reqOff)<<32 | 
			   (DWORDLONG)hgetlo(reqOff) ); 

      DWORDLONG k = (DWORDLONG)((afs_uint32)usd->privateData);
      
      /* _ASSERT(AFS_64BIT_ENV); */
      if (offset >= (k<<10))
	return EINVAL;
    }

    result = SetFilePointer(fd, loOffset, &hiOffset, method);
    if (result == 0xffffffff && (error = GetLastError()) != NO_ERROR)
	return nterr_nt2unix(error, EIO);
    if (curOffP)
	hset64(*curOffP, hiOffset, result);

    return 0;
}

static int usd_DeviceIoctl(usd_handle_t usd, int req, void *arg)
{
    HANDLE fd = usd->handle;
    DWORD result;
    DWORD hiPart;
    int code = 0;

    switch (req) {
    case USD_IOCTL_GETTYPE:
    {
	int mode;

	BY_HANDLE_FILE_INFORMATION info;
	DISK_GEOMETRY geom;
	DWORD nbytes;
	DWORD fileError = 0;
	DWORD diskError = 0;

	if (!GetFileInformationByHandle(fd, &info))
	    fileError = GetLastError();

	if (!DeviceIoControl(fd, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
			     &geom, sizeof(geom), &nbytes, NULL))
	    diskError = GetLastError();

	mode = 0;
	if ((fileError == ERROR_INVALID_PARAMETER ||
	     fileError == ERROR_INVALID_FUNCTION)
	    && diskError == 0) {
	    mode = S_IFCHR;		/* a disk device */
	    if ((afs_uint32)(usd->privateData) == 0) {

		/* Fill in the device size from disk geometry info.  Note
		 * that this is the whole disk, not just the partition, so
		 * it will serve only as an upper bound. */

		DWORDLONG size = geom.Cylinders.QuadPart;
		afs_uint32 k;
		size *= geom.TracksPerCylinder;
		size *= geom.SectorsPerTrack;
		size *= geom.BytesPerSector;
		if (size == 0)
		    return ENODEV;
		size >>= 10;	/* convert to Kilobytes */
		if (size >> 31) k = 0x7fffffff;
		else k = (afs_uint32) size;
		usd->privateData = (void *)k;
	    }
	}
	else if (diskError == ERROR_INVALID_PARAMETER && fileError == 0)
	    mode = S_IFREG;		/* a regular file */
	else {
	    /* check to see if device is a tape drive */
	    result = GetTapeStatus(fd);

	    if (result != ERROR_INVALID_FUNCTION &&
		result != ERROR_INVALID_PARAMETER) {
		/* looks like a tape drive */
		mode = S_IFCHR;
	    }
	}

	if (!mode)
	    return EINVAL;
	*(int *)arg = mode;
	return 0;
    }

    case USD_IOCTL_GETDEV:
	return EINVAL;
	*(dev_t *)arg = 0;
	break;

    case USD_IOCTL_GETFULLNAME:
	*(char **)arg = usd->fullPathName;
	break;

    case USD_IOCTL_GETSIZE:
	result = GetFileSize(fd, &hiPart);
	if (result == 0xffffffff && (code = GetLastError()) != NO_ERROR)
	    return nterr_nt2unix(code, EIO);
	hset64(*(afs_hyper_t *)arg, hiPart, result);
	return 0;

    case USD_IOCTL_SETSIZE:
	code = usd_DeviceSeek(usd, *(afs_hyper_t *)arg, SEEK_SET, NULL);
	if (!code) {
	    if (!SetEndOfFile(fd))
		code = nterr_nt2unix(GetLastError(), EIO);
	}
	return code;

    case USD_IOCTL_TAPEOPERATION:
    {
	TAPE_GET_MEDIA_PARAMETERS mediaParam;
	TAPE_GET_DRIVE_PARAMETERS driveParam;
	DWORD mediaParamSize = sizeof(TAPE_GET_MEDIA_PARAMETERS);
	DWORD driveParamSize = sizeof(TAPE_GET_DRIVE_PARAMETERS);
	DWORD reloffset, fmarkType;
	int retrycount;
	usd_tapeop_t *tapeOpp = (usd_tapeop_t *)arg;

	/* Execute specified tape command */

	switch (tapeOpp->tp_op) {
	case USDTAPE_WEOF:
	    /* Determine type of filemark supported by device */
	    result = GetTapeParameters(fd,
				       GET_TAPE_DRIVE_INFORMATION,
				       &driveParamSize,
				       &driveParam);

	    if (result == NO_ERROR) {
		/* drive must support either normal or long filemarks */
		if (driveParam.FeaturesHigh & TAPE_DRIVE_WRITE_FILEMARKS) {
		    fmarkType = TAPE_FILEMARKS;
		} else if (driveParam.FeaturesHigh &
			   TAPE_DRIVE_WRITE_LONG_FMKS) {
		    fmarkType = TAPE_LONG_FILEMARKS;
		} else {
		    result = ERROR_NOT_SUPPORTED;
		}
	    }

	    /* Write specified number of filemarks */
	    if (result == NO_ERROR) {
		result = WriteTapemark(fd,
				       fmarkType,
				       tapeOpp->tp_count, FALSE);
	    }
	    break;

	case USDTAPE_REW:
	    /* Rewind tape */
	    retrycount = 0;
	    do {
		/* absorb non-persistant errors, e.g. ERROR_MEDIA_CHANGED. */
		result = SetTapePosition(fd,
					 TAPE_REWIND,
					 0, 0, 0,
					 FALSE);
	    } while ((result != NO_ERROR) && (retrycount++ < TAPEOP_RETRYMAX));

	    break;

	case USDTAPE_FSF:
	case USDTAPE_BSF:
	    /* Space over specified number of file marks */
	    if (tapeOpp->tp_count < 0) {
		result = ERROR_INVALID_PARAMETER;
	    } else {
		if (tapeOpp->tp_op == USDTAPE_FSF) {
		    reloffset = tapeOpp->tp_count;
		} else {
		    reloffset = 0 - tapeOpp->tp_count;
		}

		result = SetTapePosition(fd,
					 TAPE_SPACE_FILEMARKS,
					 0,
					 reloffset,
					 0,
					 FALSE);
	    }
	    break;

	case USDTAPE_PREPARE:
	    /* Prepare tape drive for operation; do after open. */

	    retrycount = 0;
	    do {
		/* absorb non-persistant errors */
		if (retrycount > 0) {
		    Sleep(2 * 1000);
		}
		result = PrepareTape(fd, TAPE_LOCK, FALSE);
	    } while (TRANSIENT_TAPE_ERROR(result) &&
		     retrycount++ < TAPEOP_RETRYMAX);

	    if (result == NO_ERROR) {
		retrycount = 0;
		do {
		    /* absorb non-persistant errors */
		    if (retrycount > 0) {
			Sleep(2 * 1000);
		    }
		    result = GetTapeStatus(fd);
		} while (TRANSIENT_TAPE_ERROR(result) &&
			 retrycount++ < TAPEOP_RETRYMAX);
	    }

	    /* Querying media/drive info seems to clear bad tape state */
	    if (result == NO_ERROR) {
		result = GetTapeParameters(fd,
					   GET_TAPE_MEDIA_INFORMATION,
					   &mediaParamSize,
					   &mediaParam);
	    }

	    if (result == NO_ERROR) {
		result = GetTapeParameters(fd,
					   GET_TAPE_DRIVE_INFORMATION,
					   &driveParamSize,
					   &driveParam);
	    }
	    break;

	case USDTAPE_SHUTDOWN:
	    /* Decommission tape drive after operation; do before close. */
	    result = PrepareTape(fd, TAPE_UNLOCK, FALSE);
	    break;

	default:
	    /* Invalid command */
	    result = ERROR_INVALID_PARAMETER;
	    break;
	}

	if (result == NO_ERROR) {
	    return (0);
	} else {
	    return nterr_nt2unix(result, EIO);
	}
    }

    case USD_IOCTL_GETBLKSIZE:
	*((long *)arg) = (long)4096;
	return 0;

    default:
	return EINVAL;
    }
    return code;
}


static int usd_DeviceClose(usd_handle_t usd)
{
    HANDLE fd = usd->handle;
    int code;

    if (CloseHandle(fd))
	code = 0;
    else
	code = nterr_nt2unix(GetLastError(), EIO);

    if (usd->fullPathName)
	free(usd->fullPathName); 
    free(usd);

    return code;
}

/*
 * usd_DeviceOpen() -- open WinNT device (or regular file)
 * 
 * PARAMETERS -- 
 *     oflag -- Various combinations of USD_OPEN_XXX defined in usd.h.
 *     pmode -- ignored; file's security descriptor set to default on create.
 *     usdP -- if NULL device is immediately closed after being opened.
 *         Otherwise, *usdP is set to the user space device handle.
 *
 * RETURN CODES -- On error a unix-style errno value is *returned*.  Else zero.
 */

static int usd_DeviceOpen(
  const char *path,
  int oflag,
  int pmode,
  usd_handle_t *usdP)
{
    HANDLE devhandle;
    DWORD access, share, create, attr;
    usd_handle_t usd;
    int mode;				/* type of opened object */
    int code;

    if (usdP)
	*usdP = NULL;

    /* set access as specified in oflag */

    if (oflag & USD_OPEN_SYNC)
	attr = FILE_FLAG_WRITE_THROUGH;
    else
	attr = 0;

    /* should we always set:
     *     FILE_FLAG_NO_BUFFERING? 
     *	   FILE_FLAG_RANDOM_ACCESS?
     */

    access = GENERIC_READ;
    if (oflag & USD_OPEN_RDWR)
	access |= GENERIC_WRITE;

    /* set create as specified in oflag */

    if (oflag & USD_OPEN_CREATE) {
	/* must be opening a file; allow it to be created */
	create = OPEN_ALWAYS;
    } else {
	create = OPEN_EXISTING;
    }


    if (oflag & (USD_OPEN_RLOCK|USD_OPEN_WLOCK)) {

	/* make sure both lock bits aren't set */
	_ASSERT(~oflag & (USD_OPEN_RLOCK|USD_OPEN_WLOCK));

	share = ((oflag & USD_OPEN_RLOCK) ? FILE_SHARE_READ : 0/*no sharing*/);

    } else {
	share = FILE_SHARE_READ+FILE_SHARE_WRITE;
    }

    /* attempt to open the device/file */

    devhandle = CreateFile(path, access, share, NULL, create, attr, NULL);

    if (devhandle == INVALID_HANDLE_VALUE)
	return nterr_nt2unix(GetLastError(), EIO);

    usd = (usd_handle_t) malloc(sizeof(*usd));
    memset(usd, 0, sizeof(*usd));

    
    _ASSERT(sizeof(devhandle) <= sizeof(usd->handle));
    usd->handle = (void *)devhandle;

    usd->read = usd_DeviceRead;
    usd->write = usd_DeviceWrite;
    usd->seek = usd_DeviceSeek;
    usd->ioctl = usd_DeviceIoctl;
    usd->close = usd_DeviceClose;

    usd->fullPathName = (char *) malloc(strlen(path)+1);
    strcpy(usd->fullPathName, path);
    usd->openFlags = oflag;

    /* For devices, this is the first real reference, so many errors show up
     * here.  Also this call also sets the size (stored in usd->privateData)
     * based on the results of the call to DeviceIoControl(). */
    code = USD_IOCTL(usd, USD_IOCTL_GETTYPE, &mode);


    /* If we're trying to obtain a write lock on a real disk, then the
     * aggregate must not be attached by the kernel.  If so, unlock it
     * and fail. 
     * WARNING: The code to check for the above has been removed when this
     * file was ported from DFS src. It should be put back if
     * this library is used to access hard disks 
     */

    if (code == 0 && usdP)
	*usdP = usd;
    else
	usd_DeviceClose(usd);
    return code;
}

int usd_Open(const char *path, int oflag, int mode, usd_handle_t *usdP)
{
    return usd_DeviceOpen(path, oflag, mode, usdP);
}

static int usd_DeviceDummyClose(usd_handle_t usd)
{
    free(usd);
    return 0;
}

static int usd_DeviceStandardInput(usd_handle_t *usdP)
{
    usd_handle_t usd;

    if (usdP)
	*usdP = NULL;

    usd = (usd_handle_t) malloc(sizeof(*usd));
    memset(usd, 0, sizeof(*usd));
    usd->handle = (void *)0;
    usd->read = usd_DeviceRead;
    usd->write = usd_DeviceWrite;
    usd->seek = usd_DeviceSeek;
    usd->ioctl = usd_DeviceIoctl;
    usd->close = usd_DeviceDummyClose;
    usd->fullPathName = "STDIN";
    usd->openFlags = 0;

    return 0;
}

int usd_StandardInput(usd_handle_t *usdP)
{
    return usd_DeviceStandardInput(usdP);
}

static int usd_DeviceStandardOutput(
  usd_handle_t *usdP)
{
    usd_handle_t usd;

    if (usdP)
	*usdP = NULL;

    usd = (usd_handle_t) malloc(sizeof(*usd));
    memset(usd, 0, sizeof(*usd));
    usd->handle = (void *)1;
    usd->read = usd_DeviceRead;
    usd->write = usd_DeviceWrite;
    usd->seek = usd_DeviceSeek;
    usd->ioctl = usd_DeviceIoctl;
    usd->close = usd_DeviceDummyClose;
    usd->fullPathName = "STDOUT";
    usd->openFlags = 0;

    return 0;
}

int usd_StandardOutput(usd_handle_t *usdP)
{
    return usd_DeviceStandardOutput(usdP);
}
