/*
 * win32_io.c - A stdio-like disk I/O implementation for low-level disk access
 *              on Win32.  Can access an NTFS volume while it is mounted.
 *              Originated from the Linux-NTFS project.
 *
 * Copyright (c) 2003-2004 Lode Leroy
 * Copyright (c) 2003-2006 Anton Altaparmakov
 * Copyright (c) 2004-2005 Yuval Fledel
 * Copyright (c) 2012-2014 Jean-Pierre Andre
 *
 * This program/include file 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 2 of the License, or
 * (at your option) any later version.
 *
 * This program/include file 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 this program (in the main directory of the NTFS-3G
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "config.h"

#ifdef HAVE_WINDOWS_H
#define BOOL WINBOOL /* avoid conflicting definitions of BOOL */
#include <windows.h>
#undef BOOL
#endif

#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif

/*
 *              Definitions needed for <winioctl.h>
 */
#ifndef _ANONYMOUS_UNION
#define _ANONYMOUS_UNION
#define _ANONYMOUS_STRUCT
typedef unsigned long long DWORD64;
#endif

typedef struct {
        DWORD data1;     /* The first eight hexadecimal digits of the GUID. */
        WORD data2;     /* The first group of four hexadecimal digits. */
        WORD data3;     /* The second group of four hexadecimal digits. */ 
        char data4[8];    /* The first two bytes are the third group of four
                           hexadecimal digits. The remaining six bytes are the
                           final 12 hexadecimal digits. */
} GUID;

#include <winioctl.h>

#ifdef HAVE_STDIO_H
#include <stdio.h>
#endif
#ifdef HAVE_CTYPE_H
#include <ctype.h>
#endif
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#define stat stat64
#define st_blocks  st_rdev /* emulate st_blocks, missing in Windows */
#endif

/* Prevent volume.h from being be loaded, as it conflicts with winnt.h. */
#define _NTFS_VOLUME_H
struct ntfs_volume;
typedef struct ntfs_volume ntfs_volume;

#include "debug.h"
#include "types.h"
#include "device.h"
#include "misc.h"

#define cpu_to_le16(x) (x)
#define const_cpu_to_le16(x) (x)

#ifndef MAX_PATH
#define MAX_PATH 1024
#endif

#ifndef NTFS_BLOCK_SIZE
#define NTFS_BLOCK_SIZE         512
#define NTFS_BLOCK_SIZE_BITS    9
#endif

#ifndef INVALID_SET_FILE_POINTER
#define INVALID_SET_FILE_POINTER ((DWORD)-1)
#endif

#ifndef IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS
#define IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS 5636096
#endif

#ifndef IOCTL_DISK_GET_DRIVE_GEOMETRY
#define IOCTL_DISK_GET_DRIVE_GEOMETRY 0x70000
#endif

#ifndef IOCTL_GET_DISK_LENGTH_INFO
#define IOCTL_GET_DISK_LENGTH_INFO 0x7405c
#endif

#ifndef FSCTL_ALLOW_EXTENDED_DASD_IO
#define FSCTL_ALLOW_EXTENDED_DASD_IO 0x90083
#endif

/* Windows 2k+ imports. */
typedef HANDLE (WINAPI *LPFN_FINDFIRSTVOLUME)(LPTSTR, DWORD);
typedef BOOL (WINAPI *LPFN_FINDNEXTVOLUME)(HANDLE, LPTSTR, DWORD);
typedef BOOL (WINAPI *LPFN_FINDVOLUMECLOSE)(HANDLE);
typedef BOOL (WINAPI *LPFN_SETFILEPOINTEREX)(HANDLE, LARGE_INTEGER,
                PLARGE_INTEGER, DWORD);

static LPFN_FINDFIRSTVOLUME fnFindFirstVolume = NULL;
static LPFN_FINDNEXTVOLUME fnFindNextVolume = NULL;
static LPFN_FINDVOLUMECLOSE fnFindVolumeClose = NULL;
static LPFN_SETFILEPOINTEREX fnSetFilePointerEx = NULL;

#ifdef UNICODE
#define FNPOSTFIX "W"
#else
#define FNPOSTFIX "A"
#endif

enum { /* see http://msdn.microsoft.com/en-us/library/cc704588(v=prot.10).aspx */
   STATUS_UNKNOWN = -1,
   STATUS_SUCCESS =              0x00000000,
   STATUS_BUFFER_OVERFLOW =      0x80000005,
   STATUS_INVALID_HANDLE =       0xC0000008,
   STATUS_INVALID_PARAMETER =    0xC000000D,
   STATUS_INVALID_DEVICE_REQUEST = 0xC0000010,
   STATUS_END_OF_FILE =          0xC0000011,
   STATUS_CONFLICTING_ADDRESSES = 0xC0000018,
   STATUS_NO_MATCH =             0xC000001E,
   STATUS_ACCESS_DENIED =        0xC0000022,
   STATUS_BUFFER_TOO_SMALL =     0xC0000023,
   STATUS_OBJECT_TYPE_MISMATCH = 0xC0000024,
   STATUS_FILE_NOT_FOUND =       0xC0000028,
   STATUS_OBJECT_NAME_INVALID =  0xC0000033,
   STATUS_OBJECT_NAME_NOT_FOUND = 0xC0000034,
   STATUS_SHARING_VIOLATION =    0xC0000043,
   STATUS_INVALID_PARAMETER_1 =  0xC00000EF,
   STATUS_IO_DEVICE_ERROR =      0xC0000185,
   STATUS_GUARD_PAGE_VIOLATION = 0x80000001
 } ;

typedef u32 NTSTATUS; /* do not let the compiler choose the size */
#ifdef __x86_64__
typedef unsigned long long ULONG_PTR; /* an integer the same size as a pointer */
#else
typedef unsigned long ULONG_PTR; /* an integer the same size as a pointer */
#endif

HANDLE get_osfhandle(int); /* from msvcrt.dll */

/*
 *              A few needed definitions not included in <windows.h>
 */

typedef struct _IO_STATUS_BLOCK {
        union {
                NTSTATUS Status;
                PVOID    Pointer;
        };
        ULONG_PTR Information;
} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;

typedef struct _UNICODE_STRING {
        USHORT Length;
        USHORT MaximumLength;
#ifdef __x86_64__
        u32    padding;
#endif
        PWSTR  Buffer;
} UNICODE_STRING, *PUNICODE_STRING;

typedef struct _OBJECT_ATTRIBUTES {
        ULONG           Length;
#ifdef __x86_64__
        u32             padding1;
        HANDLE          RootDirectory;
        PUNICODE_STRING ObjectName;
        ULONG           Attributes;
        u32             padding2;
#else
        HANDLE          RootDirectory;
        PUNICODE_STRING ObjectName;
        ULONG           Attributes;
#endif
        PVOID           SecurityDescriptor;
        PVOID           SecurityQualityOfService;
}  OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;

#define FILE_OPEN 1
#define FILE_CREATE 2
#define FILE_OVERWRITE 4
#define FILE_SYNCHRONOUS_IO_ALERT    0x10
#define FILE_SYNCHRONOUS_IO_NONALERT 0x20
#define OBJ_CASE_INSENSITIVE 0x40

typedef void (WINAPI *PIO_APC_ROUTINE)(void*, PIO_STATUS_BLOCK, ULONG);

extern WINAPI NTSTATUS NtOpenFile(
        PHANDLE FileHandle,
        ACCESS_MASK DesiredAccess,
        POBJECT_ATTRIBUTES ObjectAttributes,
        PIO_STATUS_BLOCK IoStatusBlock,
        ULONG ShareAccess,
        ULONG OpenOptions
);

extern WINAPI NTSTATUS NtReadFile(
        HANDLE FileHandle,
        HANDLE Event,
        PIO_APC_ROUTINE ApcRoutine,
        PVOID ApcContext,
        PIO_STATUS_BLOCK IoStatusBlock,
        PVOID Buffer,
        ULONG Length,
        PLARGE_INTEGER ByteOffset,
        PULONG Key
);

extern WINAPI NTSTATUS NtWriteFile(
        HANDLE FileHandle,
        HANDLE Event,
        PIO_APC_ROUTINE ApcRoutine,
        PVOID ApcContext,
        PIO_STATUS_BLOCK IoStatusBlock,
        LPCVOID Buffer,
        ULONG Length,
        PLARGE_INTEGER ByteOffset,
        PULONG Key
);

extern NTSTATUS WINAPI NtClose(
        HANDLE Handle
);

extern NTSTATUS WINAPI NtDeviceIoControlFile(
        HANDLE FileHandle,
        HANDLE Event,
        PIO_APC_ROUTINE ApcRoutine,
        PVOID ApcContext,
        PIO_STATUS_BLOCK IoStatusBlock,
        ULONG IoControlCode,
        PVOID InputBuffer,
        ULONG InputBufferLength,
        PVOID OutputBuffer,
        ULONG OutputBufferLength
);

extern NTSTATUS WINAPI NtFsControlFile(
        HANDLE FileHandle,
        HANDLE Event,
        PIO_APC_ROUTINE ApcRoutine,
        PVOID ApcContext,
        PIO_STATUS_BLOCK IoStatusBlock,
        ULONG FsControlCode,
        PVOID InputBuffer,
        ULONG InputBufferLength,
        PVOID OutputBuffer,
        ULONG OutputBufferLength
);

/**
 * struct win32_fd -
 */
typedef struct {
        HANDLE handle;
        s64 pos;                /* Logical current position on the volume. */
        s64 part_start;
        s64 part_length;
        int part_hidden_sectors;
        s64 geo_size, geo_cylinders;
        s32 geo_sector_size;
        s64 volume_size;
        DWORD geo_sectors, geo_heads;
        HANDLE vol_handle;
        BOOL ntdll;
} win32_fd;

/**
 * ntfs_w32error_to_errno - convert a win32 error code to the unix one
 * @w32error:   the win32 error code
 *
 * Limited to a relatively small but useful number of codes.
 */
static int ntfs_w32error_to_errno(unsigned int w32error)
{
        ntfs_log_trace("Converting w32error 0x%x.\n",w32error);
        switch (w32error) {
                case ERROR_INVALID_FUNCTION:
                        return EBADRQC;
                case ERROR_FILE_NOT_FOUND:
                case ERROR_PATH_NOT_FOUND:
                case ERROR_INVALID_NAME:
                        return ENOENT;
                case ERROR_TOO_MANY_OPEN_FILES:
                        return EMFILE;
                case ERROR_ACCESS_DENIED:
                        return EACCES;
                case ERROR_INVALID_HANDLE:
                        return EBADF;
                case ERROR_NOT_ENOUGH_MEMORY:
                        return ENOMEM;
                case ERROR_OUTOFMEMORY:
                        return ENOSPC;
                case ERROR_INVALID_DRIVE:
                case ERROR_BAD_UNIT:
                        return ENODEV;
                case ERROR_WRITE_PROTECT:
                        return EROFS;
                case ERROR_NOT_READY:
                case ERROR_SHARING_VIOLATION:
                        return EBUSY;
                case ERROR_BAD_COMMAND:
                        return EINVAL;
                case ERROR_SEEK:
                case ERROR_NEGATIVE_SEEK:
                        return ESPIPE;
                case ERROR_NOT_SUPPORTED:
                        return EOPNOTSUPP;
                case ERROR_BAD_NETPATH:
                        return ENOSHARE;
                default:
                        /* generic message */
                        return ENOMSG;
        }
}

static int ntfs_ntstatus_to_errno(NTSTATUS status)
{
        ntfs_log_trace("Converting w32error 0x%x.\n",w32error);
        switch (status) {
                case STATUS_INVALID_HANDLE :
                case STATUS_INVALID_PARAMETER :
                case STATUS_OBJECT_NAME_INVALID :
                case STATUS_INVALID_DEVICE_REQUEST :
                        return (EINVAL);
                case STATUS_ACCESS_DENIED :
                        return (EACCES);
                case STATUS_IO_DEVICE_ERROR :
                case STATUS_END_OF_FILE :
                        return (EIO);
                case STATUS_SHARING_VIOLATION :
                        return (EBUSY);
                default:
                        /* generic message */
                        return ENOMSG;
        }
}

/**
 * libntfs_SetFilePointerEx - emulation for SetFilePointerEx()
 *
 * We use this to emulate SetFilePointerEx() when it is not present.  This can
 * happen since SetFilePointerEx() only exists in Win2k+.
 */
static BOOL WINAPI libntfs_SetFilePointerEx(HANDLE hFile,
                LARGE_INTEGER liDistanceToMove,
                PLARGE_INTEGER lpNewFilePointer, DWORD dwMoveMethod)
{
        liDistanceToMove.u.LowPart = SetFilePointer(hFile,
                        liDistanceToMove.u.LowPart,
                        &liDistanceToMove.u.HighPart, dwMoveMethod);
        SetLastError(NO_ERROR);
        if (liDistanceToMove.u.LowPart == INVALID_SET_FILE_POINTER &&
                        GetLastError() != NO_ERROR) {
                if (lpNewFilePointer)
                        lpNewFilePointer->QuadPart = -1;
                return FALSE;
        }
        if (lpNewFilePointer)
                lpNewFilePointer->QuadPart = liDistanceToMove.QuadPart;
        return TRUE;
}

/**
 * ntfs_device_win32_init_imports - initialize the function pointers
 *
 * The Find*Volume and SetFilePointerEx functions exist only on win2k+, as such
 * we cannot just staticly import them.
 *
 * This function initializes the imports if the functions do exist and in the
 * SetFilePointerEx case, we emulate the function ourselves if it is not
 * present.
 *
 * Note: The values are cached, do be afraid to run it more than once.
 */
static void ntfs_device_win32_init_imports(void)
{
        HMODULE kernel32 = GetModuleHandle("kernel32");
        if (!kernel32) {
                errno = ntfs_w32error_to_errno(GetLastError());
                ntfs_log_trace("kernel32.dll could not be imported.\n");
        }
        if (!fnSetFilePointerEx) {
                if (kernel32)
                        fnSetFilePointerEx = (LPFN_SETFILEPOINTEREX)
                                        GetProcAddress(kernel32,
                                        "SetFilePointerEx");
                /*
                 * If we did not get kernel32.dll or it is not Win2k+, emulate
                 * SetFilePointerEx().
                 */
                if (!fnSetFilePointerEx) {
                        ntfs_log_debug("SetFilePointerEx() not found in "
                                        "kernel32.dll: Enabling emulation.\n");
                        fnSetFilePointerEx = libntfs_SetFilePointerEx;
                }
        }
        /* Cannot do lookups if we could not get kernel32.dll... */
        if (!kernel32)
                return;
        if (!fnFindFirstVolume)
                fnFindFirstVolume = (LPFN_FINDFIRSTVOLUME)
                                GetProcAddress(kernel32, "FindFirstVolume"
                                FNPOSTFIX);
        if (!fnFindNextVolume)
                fnFindNextVolume = (LPFN_FINDNEXTVOLUME)
                                GetProcAddress(kernel32, "FindNextVolume"
                                FNPOSTFIX);
        if (!fnFindVolumeClose)
                fnFindVolumeClose = (LPFN_FINDVOLUMECLOSE)
                                GetProcAddress(kernel32, "FindVolumeClose");
}

/**
 * ntfs_device_unix_status_flags_to_win32 - convert unix->win32 open flags
 * @flags:      unix open status flags
 *
 * Supported flags are O_RDONLY, O_WRONLY and O_RDWR.
 */
static __inline__ int ntfs_device_unix_status_flags_to_win32(int flags)
{
        int win_mode;

        switch (flags & O_ACCMODE) {
        case O_RDONLY:
                win_mode = GENERIC_READ;
                break;
        case O_WRONLY:
                win_mode = GENERIC_WRITE;
                break;
        case O_RDWR:
                win_mode = GENERIC_READ | GENERIC_WRITE;
                break;
        default:
                /* error */
                ntfs_log_trace("Unknown status flags.\n");
                win_mode = 0;
        }
        return win_mode;
}


/**
 * ntfs_device_win32_simple_open_file - just open a file via win32 API
 * @filename:   name of the file to open
 * @handle:     pointer the a HANDLE in which to put the result
 * @flags:      unix open status flags
 * @locking:    will the function gain an exclusive lock on the file?
 *
 * Supported flags are O_RDONLY, O_WRONLY and O_RDWR.
 *
 * Return 0 if o.k.
 *       -1 if not, and errno set.  In this case handle is trashed.
 */
static int ntfs_device_win32_simple_open_file(const char *filename,
                HANDLE *handle, int flags, BOOL locking)
{
        *handle = CreateFile(filename,
                        ntfs_device_unix_status_flags_to_win32(flags),
                        locking ? 0 : (FILE_SHARE_WRITE | FILE_SHARE_READ),
                        NULL, (flags & O_CREAT ? OPEN_ALWAYS : OPEN_EXISTING),
                        0, NULL);
        if (*handle == INVALID_HANDLE_VALUE) {
                errno = ntfs_w32error_to_errno(GetLastError());
                ntfs_log_trace("CreateFile(%s) failed.\n", filename);
                return -1;
        }
        return 0;
}

/**
 * ntfs_device_win32_lock - lock the volume
 * @handle:     a win32 HANDLE for a volume to lock
 *
 * Locking a volume means no one can access its contents.
 * Exiting the process automatically unlocks the volume, except in old NT4s.
 *
 * Return 0 if o.k.
 *       -1 if not, and errno set.
 */
static int ntfs_device_win32_lock(HANDLE handle)
{
        DWORD i;

        if (!DeviceIoControl(handle, FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0, &i,
                        NULL)) {
                errno = ntfs_w32error_to_errno(GetLastError());
                ntfs_log_trace("Couldn't lock volume.\n");
                return -1;
        }
        ntfs_log_debug("Volume locked.\n");
        return 0;
}

/**
 * ntfs_device_win32_unlock - unlock the volume
 * @handle:     the win32 HANDLE which the volume was locked with
 *
 * Return 0 if o.k.
 *       -1 if not, and errno set.
 */
static int ntfs_device_win32_unlock(HANDLE handle)
{
        DWORD i;

        if (!DeviceIoControl(handle, FSCTL_UNLOCK_VOLUME, NULL, 0, NULL, 0, &i,
                        NULL)) {
                errno = ntfs_w32error_to_errno(GetLastError());
                ntfs_log_trace("Couldn't unlock volume.\n");
                return -1;
        }
        ntfs_log_debug("Volume unlocked.\n");
        return 0;
}

static int ntfs_device_win32_setlock(HANDLE handle, ULONG code)
{
        IO_STATUS_BLOCK io_status;
        NTSTATUS res;

        io_status.Status = STATUS_SUCCESS;
        io_status.Information = 0;
        res = NtFsControlFile(handle,(HANDLE)NULL,
                                (PIO_APC_ROUTINE)NULL,(void*)NULL,
                                &io_status, code,
                                (char*)NULL,0,(char*)NULL,0);
        if (res != STATUS_SUCCESS)
                errno = ntfs_ntstatus_to_errno(res);
        return (res == STATUS_SUCCESS ? 0 : -1);
}

/**
 * ntfs_device_win32_dismount - dismount a volume
 * @handle:     a win32 HANDLE for a volume to dismount
 *
 * Dismounting means the system will refresh the volume in the first change it
 * gets.  Usefull after altering the file structures.
 * The volume must be locked by the current process while dismounting.
 * A side effect is that the volume is also unlocked, but you must not rely om
 * this.
 *
 * Return 0 if o.k.
 *       -1 if not, and errno set.
 */
static int ntfs_device_win32_dismount(HANDLE handle)
{
        DWORD i;

        if (!DeviceIoControl(handle, FSCTL_DISMOUNT_VOLUME, NULL, 0, NULL, 0,
                        &i, NULL)) {
                errno = ntfs_w32error_to_errno(GetLastError());
                ntfs_log_trace("Couldn't dismount volume.\n");
                return -1;
        }
        ntfs_log_debug("Volume dismounted.\n");
        return 0;
}

/**
 * ntfs_device_win32_getsize - get file size via win32 API
 * @handle:     pointer the file HANDLE obtained via open
 *
 * Only works on ordinary files.
 *
 * Return The file size if o.k.
 *       -1 if not, and errno set.
 */
static s64 ntfs_device_win32_getsize(HANDLE handle)
{
        LONG loword, hiword;

        SetLastError(NO_ERROR);
        hiword = 0;
        loword = SetFilePointer(handle, 0, &hiword, 2);
        if ((loword == INVALID_SET_FILE_POINTER)
            && (GetLastError() != NO_ERROR)) {
                errno = ntfs_w32error_to_errno(GetLastError());
                ntfs_log_trace("Couldn't get file size.\n");
                return -1;
        }
        return ((s64)hiword << 32) + (ULONG)loword;
}

/**
 * ntfs_device_win32_getdisklength - get disk size via win32 API
 * @handle:     pointer the file HANDLE obtained via open
 * @argp:       pointer to result buffer
 *
 * Only works on PhysicalDriveX type handles.
 *
 * Return The disk size if o.k.
 *       -1 if not, and errno set.
 */
static s64 ntfs_device_win32_getdisklength(HANDLE handle)
{
        GET_LENGTH_INFORMATION buf;
        DWORD i;

        if (!DeviceIoControl(handle, IOCTL_DISK_GET_LENGTH_INFO, NULL, 0, &buf,
                        sizeof(buf), &i, NULL)) {
                errno = ntfs_w32error_to_errno(GetLastError());
                ntfs_log_trace("Couldn't get disk length.\n");
                return -1;
        }
        ntfs_log_debug("Disk length: %lld.\n", buf.Length.QuadPart);
        return buf.Length.QuadPart;
}

/**
 * ntfs_device_win32_getntfssize - get NTFS volume size via win32 API
 * @handle:     pointer the file HANDLE obtained via open
 * @argp:       pointer to result buffer
 *
 * Only works on NTFS volume handles.
 * An annoying bug in windows is that an NTFS volume does not occupy the entire
 * partition, namely not the last sector (which holds the backup boot sector,
 * and normally not interesting).
 * Use this function to get the length of the accessible space through a given
 * volume handle.
 *
 * Return The volume size if o.k.
 *       -1 if not, and errno set.
 */
static s64 ntfs_device_win32_getntfssize(HANDLE handle)
{
        s64 rvl;
#ifdef FSCTL_GET_NTFS_VOLUME_DATA
        DWORD i;
        NTFS_VOLUME_DATA_BUFFER buf;

        if (!DeviceIoControl(handle, FSCTL_GET_NTFS_VOLUME_DATA, NULL, 0, &buf,
                        sizeof(buf), &i, NULL)) {
                errno = ntfs_w32error_to_errno(GetLastError());
                ntfs_log_trace("Couldn't get NTFS volume length.\n");
                return -1;
        }
        rvl = buf.NumberSectors.QuadPart * buf.BytesPerSector;
        ntfs_log_debug("NTFS volume length: 0x%llx.\n", (long long)rvl);
#else
        errno = EINVAL;
        rvl = -1;
#endif
        return rvl;
}

/**
 * ntfs_device_win32_getgeo - get CHS information of a drive
 * @handle:     an open handle to the PhysicalDevice
 * @fd:         a win_fd structure that will be filled
 *
 * Return 0 if o.k.
 *       -1 if not, and errno  set.
 *
 * In Windows NT+: fills size, sectors, and cylinders and sets heads to -1.
 * In Windows XP+: fills size, sectors, cylinders, and heads.
 *
 * Note: In pre XP, this requires write permission, even though nothing is
 * actually written.
 *
 * If fails, sets sectors, cylinders, heads, and size to -1.
 */
static int ntfs_device_win32_getgeo(HANDLE handle, win32_fd *fd)
{
        DWORD i;
        BOOL rvl;
        BYTE b[sizeof(DISK_GEOMETRY) + sizeof(DISK_PARTITION_INFO) +
                        sizeof(DISK_DETECTION_INFO) + 512];

        rvl = DeviceIoControl(handle, IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, NULL,
                        0, &b, sizeof(b), &i, NULL);
        if (rvl) {
                ntfs_log_debug("GET_DRIVE_GEOMETRY_EX detected.\n");
                DISK_DETECTION_INFO *ddi = (PDISK_DETECTION_INFO)
                                (((PBYTE)(&((PDISK_GEOMETRY_EX)b)->Data)) +
                                (((PDISK_PARTITION_INFO)
                                (&((PDISK_GEOMETRY_EX)b)->Data))->
                                SizeOfPartitionInfo));
                fd->geo_cylinders = ((DISK_GEOMETRY*)&b)->Cylinders.QuadPart;
                fd->geo_sectors = ((DISK_GEOMETRY*)&b)->SectorsPerTrack;
                fd->geo_size = ((DISK_GEOMETRY_EX*)&b)->DiskSize.QuadPart;
                fd->geo_sector_size = NTFS_BLOCK_SIZE;
                switch (ddi->DetectionType) {
                case DetectInt13:
                        fd->geo_cylinders = ddi->Int13.MaxCylinders;
                        fd->geo_sectors = ddi->Int13.SectorsPerTrack;
                        fd->geo_heads = ddi->Int13.MaxHeads;
                        return 0;
                case DetectExInt13:
                        fd->geo_cylinders = ddi->ExInt13.ExCylinders;
                        fd->geo_sectors = ddi->ExInt13.ExSectorsPerTrack;
                        fd->geo_heads = ddi->ExInt13.ExHeads;
                        return 0;
                case DetectNone:
                default:
                        break;
                }
        } else
                fd->geo_heads = -1;
        rvl = DeviceIoControl(handle, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
                        &b, sizeof(b), &i, NULL);
        if (rvl) {
                ntfs_log_debug("GET_DRIVE_GEOMETRY detected.\n");
                fd->geo_cylinders = ((DISK_GEOMETRY*)&b)->Cylinders.QuadPart;
                fd->geo_sectors = ((DISK_GEOMETRY*)&b)->SectorsPerTrack;
                fd->geo_size = fd->geo_cylinders * fd->geo_sectors *
                                ((DISK_GEOMETRY*)&b)->TracksPerCylinder *
                                ((DISK_GEOMETRY*)&b)->BytesPerSector;
                fd->geo_sector_size = ((DISK_GEOMETRY*)&b)->BytesPerSector;
                return 0;
        }
        errno = ntfs_w32error_to_errno(GetLastError());
        ntfs_log_trace("Couldn't retrieve disk geometry.\n");
        fd->geo_cylinders = -1;
        fd->geo_sectors = -1;
        fd->geo_size = -1;
        fd->geo_sector_size = NTFS_BLOCK_SIZE;
        return -1;
}

static int ntfs_device_win32_getntgeo(HANDLE handle, win32_fd *fd)
{
        DISK_GEOMETRY geo;
        NTSTATUS st;
        IO_STATUS_BLOCK status;
        u64 bytes;
        int res;

        res = -1;
        fd->geo_cylinders = 0;
        fd->geo_sectors = 0;
        fd->geo_size = 1073741824;
        fd->geo_sectors = fd->geo_size >> 9;
        fd->geo_sector_size = NTFS_BLOCK_SIZE;

        st = NtDeviceIoControlFile(handle, (HANDLE)NULL,
                        (PIO_APC_ROUTINE)NULL, (void*)NULL,
                        &status, IOCTL_DISK_GET_DRIVE_GEOMETRY, (void*)NULL, 0,
                        (void*)&geo, sizeof(geo));
        if (st == STATUS_SUCCESS) {
                /* over-estimate the (rounded) number of cylinders */
                fd->geo_cylinders = geo.Cylinders.QuadPart + 1;
                fd->geo_sectors = fd->geo_cylinders
                                *geo.TracksPerCylinder*geo.SectorsPerTrack;
                fd->geo_size = fd->geo_sectors*geo.BytesPerSector;
                fd->geo_sector_size = geo.BytesPerSector;
                res = 0;
                        /* try to get the exact sector count */
                st = NtDeviceIoControlFile(handle, (HANDLE)NULL,
                                (PIO_APC_ROUTINE)NULL, (void*)NULL,
                                &status, IOCTL_GET_DISK_LENGTH_INFO,
                                (void*)NULL, 0,
                                (void*)&bytes, sizeof(bytes));
                if (st == STATUS_SUCCESS) {
                        fd->geo_size = bytes;
                        fd->geo_sectors = bytes/geo.BytesPerSector;
                }
        }
        return (res);
}

/**
 * ntfs_device_win32_open_file - open a file via win32 API
 * @filename:   name of the file to open
 * @fd:         pointer to win32 file device in which to put the result
 * @flags:      unix open status flags
 *
 * Return 0 if o.k.
 *       -1 if not, and errno set.
 */
static __inline__ int ntfs_device_win32_open_file(char *filename, win32_fd *fd,
                int flags)
{
        HANDLE handle;
        int mode;

        if (ntfs_device_win32_simple_open_file(filename, &handle, flags,
                        FALSE)) {
                /* open error */
                return -1;
        }
        mode = flags & O_ACCMODE;
        if ((mode == O_RDWR) || (mode == O_WRONLY)) {
                DWORD bytes;

                /* try making sparse (but ignore errors) */
                DeviceIoControl(handle, FSCTL_SET_SPARSE,
                                (void*)NULL, 0, (void*)NULL, 0,
                                &bytes, (LPOVERLAPPED)NULL);
        }
        /* fill fd */
        fd->handle = handle;
        fd->part_start = 0;
        fd->part_length = ntfs_device_win32_getsize(handle);
        fd->pos = 0;
        fd->part_hidden_sectors = -1;
        fd->geo_size = -1;      /* used as a marker that this is a file */
        fd->vol_handle = INVALID_HANDLE_VALUE;
        fd->geo_sector_size = 512;  /* will be adjusted from the boot sector */
        fd->ntdll = FALSE;
        return 0;
}

/**
 * ntfs_device_win32_open_drive - open a drive via win32 API
 * @drive_id:   drive to open
 * @fd:         pointer to win32 file device in which to put the result
 * @flags:      unix open status flags
 *
 * return 0 if o.k.
 *        -1 if not, and errno set.
 */
static __inline__ int ntfs_device_win32_open_drive(int drive_id, win32_fd *fd,
                int flags)
{
        HANDLE handle;
        int err;
        char filename[MAX_PATH];

        sprintf(filename, "\\\\.\\PhysicalDrive%d", drive_id);
        if ((err = ntfs_device_win32_simple_open_file(filename, &handle, flags,
                        TRUE))) {
                /* open error */
                return err;
        }
        /* store the drive geometry */
        ntfs_device_win32_getgeo(handle, fd);
        /* Just to be sure */
        if (fd->geo_size == -1)
                fd->geo_size = ntfs_device_win32_getdisklength(handle);
        /* fill fd */
        fd->ntdll = FALSE;
        fd->handle = handle;
        fd->part_start = 0;
        fd->part_length = fd->geo_size;
        fd->pos = 0;
        fd->part_hidden_sectors = -1;
        fd->vol_handle = INVALID_HANDLE_VALUE;
        return 0;
}

/**
 * ntfs_device_win32_open_lowlevel - open a drive via low level win32 API
 * @drive_id:   drive to open
 * @fd:         pointer to win32 file device in which to put the result
 * @flags:      unix open status flags
 *
 * return 0 if o.k.
 *        -1 if not, and errno set.
 */
static __inline__ int ntfs_device_win32_open_lowlevel(int drive_id,
                win32_fd *fd, int flags)
{
        HANDLE handle;
        NTSTATUS st;
        ACCESS_MASK access;
        ULONG share;
        OBJECT_ATTRIBUTES attr;
        IO_STATUS_BLOCK io_status;
        UNICODE_STRING unicode_name;
        ntfschar unicode_buffer[7];
        int mode;
        static const ntfschar unicode_init[] = {
                const_cpu_to_le16('\\'), const_cpu_to_le16('?'),
                const_cpu_to_le16('?'), const_cpu_to_le16('\\'),
                const_cpu_to_le16(' '), const_cpu_to_le16(':'),
                const_cpu_to_le16(0)
        };

        memcpy(unicode_buffer, unicode_init, sizeof(unicode_buffer));
        unicode_buffer[4] = cpu_to_le16(drive_id + 'A');
        unicode_name.Buffer = unicode_buffer;
        unicode_name.Length = 6*sizeof(ntfschar);
        unicode_name.MaximumLength = 6*sizeof(ntfschar);

        attr.Length = sizeof(OBJECT_ATTRIBUTES);
        attr.RootDirectory = (HANDLE*)NULL;
        attr.ObjectName = &unicode_name;
        attr.Attributes = OBJ_CASE_INSENSITIVE;
        attr.SecurityDescriptor = (void*)NULL;
        attr.SecurityQualityOfService = (void*)NULL;

        io_status.Status = 0;
        io_status.Information = 0;
        mode = flags & O_ACCMODE;
        share = (mode == O_RDWR ?
                        0 : FILE_SHARE_READ | FILE_SHARE_WRITE);
        access = (mode == O_RDWR ?
                         FILE_READ_DATA | FILE_WRITE_DATA | SYNCHRONIZE
                        : FILE_READ_DATA | SYNCHRONIZE);

        st = NtOpenFile(&handle, access,
                        &attr, &io_status,
                        share,
                        FILE_SYNCHRONOUS_IO_ALERT);
        if (st != STATUS_SUCCESS) {
                errno = ntfs_ntstatus_to_errno(st);
                return (-1);
        }
        ntfs_device_win32_setlock(handle,FSCTL_LOCK_VOLUME);
        /* store the drive geometry */
        ntfs_device_win32_getntgeo(handle, fd);
        fd->ntdll = TRUE;
        /* allow accessing the full partition */
        st = NtFsControlFile(handle, (HANDLE)NULL,
                        (PIO_APC_ROUTINE)NULL,
                        (PVOID)NULL, &io_status,
                        FSCTL_ALLOW_EXTENDED_DASD_IO,
                        NULL, 0, NULL, 0);
        if (st != STATUS_SUCCESS) {
                errno = ntfs_ntstatus_to_errno(st);
                NtClose(handle);
                return (-1);
        }
        /* fill fd */
        fd->handle = handle;
        fd->part_start = 0;
        fd->part_length = fd->geo_size;
        fd->pos = 0;
        fd->part_hidden_sectors = -1;
        fd->vol_handle = INVALID_HANDLE_VALUE;
        return 0;
}

/**
 * ntfs_device_win32_open_volume_for_partition - find and open a volume
 *
 * Windows NT/2k/XP handles volumes instead of partitions.
 * This function gets the partition details and return an open volume handle.
 * That volume is the one whose only physical location on disk is the described
 * partition.
 *
 * The function required Windows 2k/XP, otherwise it fails (gracefully).
 *
 * Return success: a valid open volume handle.
 *        fail   : INVALID_HANDLE_VALUE
 */
static HANDLE ntfs_device_win32_open_volume_for_partition(unsigned int drive_id,
                s64 part_offset, s64 part_length, int flags)
{
        HANDLE vol_find_handle;
        TCHAR vol_name[MAX_PATH];

        /* Make sure all the required imports exist. */
        if (!fnFindFirstVolume || !fnFindNextVolume || !fnFindVolumeClose) {
                ntfs_log_trace("Required dll imports not found.\n");
                return INVALID_HANDLE_VALUE;
        }
        /* Start iterating through volumes. */
        ntfs_log_trace("Entering with drive_id=%d, part_offset=%lld, "
                        "path_length=%lld, flags=%d.\n", drive_id,
                        (unsigned long long)part_offset,
                        (unsigned long long)part_length, flags);
        vol_find_handle = fnFindFirstVolume(vol_name, MAX_PATH);
        /* If a valid handle could not be aquired, reply with "don't know". */
        if (vol_find_handle == INVALID_HANDLE_VALUE) {
                ntfs_log_trace("FindFirstVolume failed.\n");
                return INVALID_HANDLE_VALUE;
        }
        do {
                int vol_name_length;
                HANDLE handle;

                /* remove trailing '/' from vol_name */
#ifdef UNICODE
                vol_name_length = wcslen(vol_name);
#else
                vol_name_length = strlen(vol_name);
#endif
                if (vol_name_length>0)
                        vol_name[vol_name_length-1]=0;

                ntfs_log_debug("Processing %s.\n", vol_name);
                /* open the file */
                handle = CreateFile(vol_name,
                                ntfs_device_unix_status_flags_to_win32(flags),
                                FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                                OPEN_EXISTING, 0, NULL);
                if (handle != INVALID_HANDLE_VALUE) {
                        DWORD bytesReturned;
#define EXTENTS_SIZE sizeof(VOLUME_DISK_EXTENTS) + 9 * sizeof(DISK_EXTENT)
                        char extents[EXTENTS_SIZE];

                        /* Check physical locations. */
                        if (DeviceIoControl(handle,
                                        IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
                                        NULL, 0, extents, EXTENTS_SIZE,
                                        &bytesReturned, NULL)) {
                                if (((VOLUME_DISK_EXTENTS *)extents)->
                                                NumberOfDiskExtents == 1) {
                                        DISK_EXTENT *extent = &((
                                                        VOLUME_DISK_EXTENTS *)
                                                        extents)->Extents[0];
                                        if ((extent->DiskNumber==drive_id) &&
                                                        (extent->StartingOffset.
                                                        QuadPart==part_offset)
                                                        && (extent->
                                                        ExtentLength.QuadPart
                                                        == part_length)) {
                                                /*
                                                 * Eureka! (Archimedes, 287 BC,
                                                 * "I have found it!")
                                                 */
                                                fnFindVolumeClose(
                                                        vol_find_handle);
                                                return handle;
                                        }
                                }
                        }
                } else
                        ntfs_log_trace("getExtents() Failed.\n");
        } while (fnFindNextVolume(vol_find_handle, vol_name, MAX_PATH));
        /* End of iteration through volumes. */
        ntfs_log_trace("Closing, volume was not found.\n");
        fnFindVolumeClose(vol_find_handle);
        return INVALID_HANDLE_VALUE;
}

/**
 * ntfs_device_win32_find_partition - locates partition details by id.
 * @handle:             HANDLE to the PhysicalDrive
 * @partition_id:       the partition number to locate
 * @part_offset:        pointer to where to put the offset to the partition
 * @part_length:        pointer to where to put the length of the partition
 * @hidden_sectors:     pointer to where to put the hidden sectors
 *
 * This function requires an open PhysicalDrive handle and a partition_id.
 * If a partition with the required id is found on the supplied device,
 * the partition attributes are returned back.
 *
 * Returns: TRUE  if found, and sets the output parameters.
 *          FALSE if not and errno is set to the error code.
 */
static BOOL ntfs_device_win32_find_partition(HANDLE handle, DWORD partition_id,
                s64 *part_offset, s64 *part_length, int *hidden_sectors)
{
        DRIVE_LAYOUT_INFORMATION *drive_layout;
        unsigned int err, buf_size, part_count;
        DWORD i;

        /*
         * There is no way to know the required buffer, so if the ioctl fails,
         * try doubling the buffer size each time until the ioctl succeeds.
         */
        part_count = 8;
        do {
                buf_size = sizeof(DRIVE_LAYOUT_INFORMATION) +
                                part_count * sizeof(PARTITION_INFORMATION);
                drive_layout = (DRIVE_LAYOUT_INFORMATION*)ntfs_malloc(buf_size);
                if (!drive_layout) {
                        errno = ENOMEM;
                        return FALSE;
                }
                if (DeviceIoControl(handle, IOCTL_DISK_GET_DRIVE_LAYOUT, NULL,
                                0, (BYTE*)drive_layout, buf_size, &i, NULL))
                        break;
                err = GetLastError();
                free(drive_layout);
                if (err != ERROR_INSUFFICIENT_BUFFER) {
                        ntfs_log_trace("GetDriveLayout failed.\n");
                        errno = ntfs_w32error_to_errno(err);
                        return FALSE;
                }
                ntfs_log_debug("More than %u partitions.\n", part_count);
                part_count <<= 1;
                if (part_count > 512) {
                        ntfs_log_trace("GetDriveLayout failed: More than 512 "
                                        "partitions?\n");
                        errno = ENOBUFS;
                        return FALSE;
                }
        } while (1);
        for (i = 0; i < drive_layout->PartitionCount; i++) {
                if (drive_layout->PartitionEntry[i].PartitionNumber ==
                                partition_id) {
                        *part_offset = drive_layout->PartitionEntry[i].
                                        StartingOffset.QuadPart;
                        *part_length = drive_layout->PartitionEntry[i].
                                        PartitionLength.QuadPart;
                        *hidden_sectors = drive_layout->PartitionEntry[i].
                                        HiddenSectors;
                        free(drive_layout);
                        return TRUE;
                }
        }
        free(drive_layout);
        errno = ENOENT;
        return FALSE;
}

/**
 * ntfs_device_win32_open_partition - open a partition via win32 API
 * @drive_id:           drive to open
 * @partition_id:       partition to open
 * @fd:                 win32 file device to return
 * @flags:              unix open status flags
 *
 * Return  0 if o.k.
 *        -1 if not, and errno set.
 *
 * When fails, fd contents may have not been preserved.
 */
static int ntfs_device_win32_open_partition(int drive_id,
                unsigned int partition_id, win32_fd *fd, int flags)
{
        s64 part_start, part_length;
        HANDLE handle;
        int err, hidden_sectors;
        char drive_name[MAX_PATH];

        sprintf(drive_name, "\\\\.\\PhysicalDrive%d", drive_id);
        /* Open the entire device without locking, ask questions later */
        if ((err = ntfs_device_win32_simple_open_file(drive_name, &handle,
                        flags, FALSE))) {
                /* error */
                return err;
        }
        if (ntfs_device_win32_find_partition(handle, partition_id, &part_start,
                        &part_length, &hidden_sectors)) {
                s64 tmp;
                HANDLE vol_handle = ntfs_device_win32_open_volume_for_partition(
                        drive_id, part_start, part_length, flags);
                /* Store the drive geometry. */
                ntfs_device_win32_getgeo(handle, fd);
                fd->handle = handle;
                fd->pos = 0;
                fd->part_start = part_start;
                fd->part_length = part_length;
                fd->part_hidden_sectors = hidden_sectors;
                fd->geo_sector_size = 512;
                fd->ntdll = FALSE;
                tmp = ntfs_device_win32_getntfssize(vol_handle);
                if (tmp > 0)
                        fd->geo_size = tmp;
                else
                        fd->geo_size = fd->part_length;
                if (vol_handle != INVALID_HANDLE_VALUE) {
                        if (((flags & O_RDWR) == O_RDWR) &&
                                        ntfs_device_win32_lock(vol_handle)) {
                                CloseHandle(vol_handle);
                                CloseHandle(handle);
                                return -1;
                        }
                        fd->vol_handle = vol_handle;
                } else {
                        if ((flags & O_RDWR) == O_RDWR) {
                                /* Access if read-write, no volume found. */
                                ntfs_log_trace("Partitions containing Spanned/"
                                                "Mirrored volumes are not "
                                                "supported in R/W status "
                                                "yet.\n");
                                CloseHandle(handle);
                                errno = EOPNOTSUPP;
                                return -1;
                        }
                        fd->vol_handle = INVALID_HANDLE_VALUE;
                }
                return 0;
        } else {
                ntfs_log_debug("Partition %u not found on drive %d.\n",
                                partition_id, drive_id);
                CloseHandle(handle);
                errno = ENODEV;
                return -1;
        }
}

/**
 * ntfs_device_win32_open - open a device
 * @dev:        a pointer to the NTFS_DEVICE to open
 * @flags:      unix open status flags
 *
 * @dev->d_name must hold the device name, the rest is ignored.
 * Supported flags are O_RDONLY, O_WRONLY and O_RDWR.
 *
 * If name is in format "(hd[0-9],[0-9])" then open a partition.
 * If name is in format "(hd[0-9])" then open a volume.
 * Otherwise open a file.
 */
static int ntfs_device_win32_open(struct ntfs_device *dev, int flags)
{
        int drive_id = 0, numparams;
        unsigned int part = 0;
        char drive_char;
        win32_fd fd;
        int err;

        if (NDevOpen(dev)) {
                errno = EBUSY;
                return -1;
        }
        ntfs_device_win32_init_imports();
        numparams = sscanf(dev->d_name, "/dev/hd%c%u", &drive_char, &part);
        if (!numparams
            && (dev->d_name[1] == ':')
            && (dev->d_name[2] == '\0')) {
                drive_char = dev->d_name[0];
                numparams = 3;
                drive_id = toupper(drive_char) - 'A';
        }
        switch (numparams) {
        case 0:
                ntfs_log_debug("win32_open(%s) -> file.\n", dev->d_name);
                err = ntfs_device_win32_open_file(dev->d_name, &fd, flags);
                break;
        case 1:
                ntfs_log_debug("win32_open(%s) -> drive %d.\n", dev->d_name,
                                drive_id);
                err = ntfs_device_win32_open_drive(drive_id, &fd, flags);
                break;
        case 2:
                ntfs_log_debug("win32_open(%s) -> drive %d, part %u.\n",
                                dev->d_name, drive_id, part);
                err = ntfs_device_win32_open_partition(drive_id, part, &fd,
                                flags);
                break;
        case 3:
                ntfs_log_debug("win32_open(%s) -> drive %c:\n",
                                dev->d_name, drive_char);
                err = ntfs_device_win32_open_lowlevel(drive_id, &fd,
                                flags);
                break;
        default:
                ntfs_log_debug("win32_open(%s) -> unknwon file format.\n",
                                dev->d_name);
                err = -1;
        }
        if (err)
                return err;
        ntfs_log_debug("win32_open(%s) -> %p, offset 0x%llx.\n", dev->d_name,
                        dev, fd.part_start);
        /* Setup our read-only flag. */
        if ((flags & O_RDWR) != O_RDWR)
                NDevSetReadOnly(dev);
        dev->d_private = (win32_fd*)ntfs_malloc(sizeof(win32_fd));
        memcpy(dev->d_private, &fd, sizeof(win32_fd));
        NDevSetOpen(dev);
        NDevClearDirty(dev);
        return 0;
}

/**
 * ntfs_device_win32_seek - change current logical file position
 * @dev:        ntfs device obtained via ->open
 * @offset:     required offset from the whence anchor
 * @whence:     whence anchor specifying what @offset is relative to
 *
 * Return the new position on the volume on success and -1 on error with errno
 * set to the error code.
 *
 * @whence may be one of the following:
 *      SEEK_SET - Offset is relative to file start.
 *      SEEK_CUR - Offset is relative to current position.
 *      SEEK_END - Offset is relative to end of file.
 */
static s64 ntfs_device_win32_seek(struct ntfs_device *dev, s64 offset,
                int whence)
{
        s64 abs_ofs;
        win32_fd *fd = (win32_fd *)dev->d_private;

        ntfs_log_trace("seek offset = 0x%llx, whence = %d.\n", offset, whence);
        switch (whence) {
        case SEEK_SET:
                abs_ofs = offset;
                break;
        case SEEK_CUR:
                abs_ofs = fd->pos + offset;
                break;
        case SEEK_END:
                /* End of partition != end of disk. */
                if (fd->part_length == -1) {
                        ntfs_log_trace("Position relative to end of disk not "
                                        "implemented.\n");
                        errno = EOPNOTSUPP;
                        return -1;
                }
                abs_ofs = fd->part_length + offset;
                break;
        default:
                ntfs_log_trace("Wrong mode %d.\n", whence);
                errno = EINVAL;
                return -1;
        }
        if ((abs_ofs < 0)
            || (fd->ntdll && (abs_ofs > fd->part_length))) {
                ntfs_log_trace("Seeking outsize seekable area.\n");
                errno = EINVAL;
                return -1;
        }
        fd->pos = abs_ofs;
        return abs_ofs;
}

/**
 * ntfs_device_win32_pio - positioned low level i/o
 * @fd:         win32 device descriptor obtained via ->open
 * @pos:        at which position to do i/o from/to
 * @count:      how many bytes should be transfered
 * @b:          source/destination buffer
 * @write:      TRUE if write transfer and FALSE if read transfer
 *
 * On success returns the number of bytes transfered (can be < @count) and on
 * error returns -1 and errno set.  Transfer starts from position @pos on @fd.
 *
 * Notes:
 *      - @pos, @buf, and @count must be aligned to geo_sector_size
 *      - When dealing with volumes, a single call must not span both volume
 *        and disk extents.
 *      - Does not use/set @fd->pos.
 */
static s64 ntfs_device_win32_pio(win32_fd *fd, const s64 pos,
                const s64 count, void *rbuf, const void *wbuf)
{
        LARGE_INTEGER li;
        HANDLE handle;
        DWORD bt;
        BOOL res;
        s64 bytes;

        ntfs_log_trace("pos = 0x%llx, count = 0x%llx, direction = %s.\n",
                        (long long)pos, (long long)count, write ? "write" :
                        "read");
        li.QuadPart = pos;
        if (fd->vol_handle != INVALID_HANDLE_VALUE && pos < fd->geo_size) {
                ntfs_log_debug("Transfering via vol_handle.\n");
                handle = fd->vol_handle;
        } else {
                ntfs_log_debug("Transfering via handle.\n");
                handle = fd->handle;
                li.QuadPart += fd->part_start;
        }

        if (fd->ntdll) {
                IO_STATUS_BLOCK io_status;
                NTSTATUS res;
                LARGE_INTEGER offset;

                io_status.Status = STATUS_SUCCESS;
                io_status.Information = 0;
                offset.QuadPart = pos;
                if (wbuf) {
                        res = NtWriteFile(fd->handle,(HANDLE)NULL,
                                        (PIO_APC_ROUTINE)NULL,(void*)NULL,
                                        &io_status, wbuf, count,
                                        &offset, (PULONG)NULL);
                } else {
                        res = NtReadFile(fd->handle,(HANDLE)NULL,
                                        (PIO_APC_ROUTINE)NULL,(void*)NULL,
                                        &io_status, rbuf, count,
                                        &offset, (PULONG)NULL);
                }
                if (res == STATUS_SUCCESS) {
                        bytes = io_status.Information;
                } else {
                        bytes = -1;
                        errno = ntfs_ntstatus_to_errno(res);
                }
        } else {
                if (!fnSetFilePointerEx(handle, li, NULL, FILE_BEGIN)) {
                        errno = ntfs_w32error_to_errno(GetLastError());
                        ntfs_log_trace("SetFilePointer failed.\n");
                        return -1;
                }
                if (wbuf)
                        res = WriteFile(handle, wbuf, count, &bt, NULL);
                else
                        res = ReadFile(handle, rbuf, count, &bt, NULL);
                bytes = bt;
                if (!res) {
                        errno = ntfs_w32error_to_errno(GetLastError());
                        ntfs_log_trace("%sFile() failed.\n", write ?
                                                        "Write" : "Read");
                        return -1;
                }
                if (rbuf && !pos) {
                        /* get the sector size from the boot sector */
                        char *boot = (char*)rbuf;
                        fd->geo_sector_size = (boot[11] & 255)
                                                + ((boot[12] & 255) << 8);
                }
        }
        return bytes;
}

/**
 * ntfs_device_win32_pread_simple - positioned simple read
 * @fd:         win32 device descriptor obtained via ->open
 * @pos:        at which position to read from
 * @count:      how many bytes should be read
 * @b:          a pointer to where to put the contents
 *
 * On success returns the number of bytes read (can be < @count) and on error
 * returns -1 and errno set.  Read starts from position @pos.
 *
 * Notes:
 *      - @pos, @buf, and @count must be aligned to geo_sector_size.
 *      - When dealing with volumes, a single call must not span both volume
 *        and disk extents.
 *      - Does not use/set @fd->pos.
 */
static inline s64 ntfs_device_win32_pread_simple(win32_fd *fd, const s64 pos,
                const s64 count, void *b)
{
        return ntfs_device_win32_pio(fd, pos, count, b, (void*)NULL);
}

/**
 * ntfs_device_win32_read - read bytes from an ntfs device
 * @dev:        ntfs device obtained via ->open
 * @b:          pointer to where to put the contents
 * @count:      how many bytes should be read
 *
 * On success returns the number of bytes actually read (can be < @count).
 * On error returns -1 with errno set.
 */
static s64 ntfs_device_win32_read(struct ntfs_device *dev, void *b, s64 count)
{
        s64 old_pos, to_read, i, br = 0;
        win32_fd *fd = (win32_fd *)dev->d_private;
        BYTE *alignedbuffer;
        int old_ofs, ofs;

        old_pos = fd->pos;
        old_ofs = ofs = old_pos & (fd->geo_sector_size - 1);
        to_read = (ofs + count + fd->geo_sector_size - 1) &
                        ~(s64)(fd->geo_sector_size - 1);
        /* Impose maximum of 2GB to be on the safe side. */
        if (to_read > 0x80000000) {
                int delta = to_read - count;
                to_read = 0x80000000;
                count = to_read - delta;
        }
        ntfs_log_trace("fd = %p, b = %p, count = 0x%llx, pos = 0x%llx, "
                        "ofs = %i, to_read = 0x%llx.\n", fd, b,
                        (long long)count, (long long)old_pos, ofs,
                        (long long)to_read);
        if (!((unsigned long)b & (fd->geo_sector_size - 1)) && !old_ofs &&
                        !(count & (fd->geo_sector_size - 1)))
                alignedbuffer = b;
        else {
                alignedbuffer = (BYTE *)VirtualAlloc(NULL, to_read, MEM_COMMIT,
                                PAGE_READWRITE);
                if (!alignedbuffer) {
                        errno = ntfs_w32error_to_errno(GetLastError());
                        ntfs_log_trace("VirtualAlloc failed for read.\n");
                        return -1;
                }
        }
        if (fd->vol_handle != INVALID_HANDLE_VALUE && old_pos < fd->geo_size) {
                s64 vol_to_read = fd->geo_size - old_pos;
                if (count > vol_to_read) {
                        br = ntfs_device_win32_pread_simple(fd,
                                        old_pos & ~(s64)(fd->geo_sector_size - 1),
                                        ofs + vol_to_read, alignedbuffer);
                        if (br == -1)
                                goto read_error;
                        to_read -= br;
                        if (br < ofs) {
                                br = 0;
                                goto read_partial;
                        }
                        br -= ofs;
                        fd->pos += br;
                        ofs = fd->pos & (fd->geo_sector_size - 1);
                        if (br != vol_to_read)
                                goto read_partial;
                }
        }
        i = ntfs_device_win32_pread_simple(fd,
                        fd->pos & ~(s64)(fd->geo_sector_size - 1), to_read,
                        alignedbuffer + br);
        if (i == -1) {
                if (br)
                        goto read_partial;
                goto read_error;
        }
        if (i < ofs)
                goto read_partial;
        i -= ofs;
        br += i;
        if (br > count)
                br = count;
        fd->pos = old_pos + br;
read_partial:
        if (alignedbuffer != b) {
                memcpy((void*)b, alignedbuffer + old_ofs, br);
                VirtualFree(alignedbuffer, 0, MEM_RELEASE);
        }
        return br;
read_error:
        if (alignedbuffer != b)
                VirtualFree(alignedbuffer, 0, MEM_RELEASE);
        return -1;
}

/**
 * ntfs_device_win32_close - close an open ntfs deivce
 * @dev:        ntfs device obtained via ->open
 *
 * Return 0 if o.k.
 *       -1 if not, and errno set.  Note if error fd->vol_handle is trashed.
 */
static int ntfs_device_win32_close(struct ntfs_device *dev)
{
        win32_fd *fd = (win32_fd *)dev->d_private;
        BOOL rvl;

        ntfs_log_trace("Closing device %p.\n", dev);
        if (!NDevOpen(dev)) {
                errno = EBADF;
                return -1;
        }
        if (fd->vol_handle != INVALID_HANDLE_VALUE) {
                if (!NDevReadOnly(dev)) {
                        ntfs_device_win32_dismount(fd->vol_handle);
                        ntfs_device_win32_unlock(fd->vol_handle);
                }
                if (!CloseHandle(fd->vol_handle))
                        ntfs_log_trace("CloseHandle() failed for volume.\n");
        }
        if (fd->ntdll) {
                ntfs_device_win32_setlock(fd->handle,FSCTL_UNLOCK_VOLUME);
                rvl = NtClose(fd->handle) == STATUS_SUCCESS;
        } else
                rvl = CloseHandle(fd->handle);
        NDevClearOpen(dev);
        free(fd);
        if (!rvl) {
                errno = ntfs_w32error_to_errno(GetLastError());
                if (fd->ntdll)
                        ntfs_log_trace("NtClose() failed.\n");
                else
                        ntfs_log_trace("CloseHandle() failed.\n");
                return -1;
        }
        return 0;
}

/**
 * ntfs_device_win32_sync - flush write buffers to disk
 * @dev:        ntfs device obtained via ->open
 *
 * Return 0 if o.k.
 *       -1 if not, and errno set.
 *
 * Note: Volume syncing works differently in windows.
 *       Disk cannot be synced in windows.
 */
static int ntfs_device_win32_sync(struct ntfs_device *dev)
{
        int err = 0;
        BOOL to_clear = TRUE;

        if (!NDevReadOnly(dev) && NDevDirty(dev)) {
                win32_fd *fd = (win32_fd *)dev->d_private;

                if ((fd->vol_handle != INVALID_HANDLE_VALUE) &&
                                !FlushFileBuffers(fd->vol_handle)) {
                        to_clear = FALSE;
                        err = ntfs_w32error_to_errno(GetLastError());
                }
                if (!FlushFileBuffers(fd->handle)) {
                        to_clear = FALSE;
                        if (!err)
                                err = ntfs_w32error_to_errno(GetLastError());
                }
                if (!to_clear) {
                        ntfs_log_trace("Could not sync.\n");
                        errno = err;
                        return -1;
                }
                NDevClearDirty(dev);
        }
        return 0;
}

/**
 * ntfs_device_win32_pwrite_simple - positioned simple write
 * @fd:         win32 device descriptor obtained via ->open
 * @pos:        at which position to write to
 * @count:      how many bytes should be written
 * @b:          a pointer to the data to write
 *
 * On success returns the number of bytes written and on error returns -1 and
 * errno set.  Write starts from position @pos.
 *
 * Notes:
 *      - @pos, @buf, and @count must be aligned to geo_sector_size.
 *      - When dealing with volumes, a single call must not span both volume
 *        and disk extents.
 *      - Does not use/set @fd->pos.
 */
static inline s64 ntfs_device_win32_pwrite_simple(win32_fd *fd, const s64 pos,
                const s64 count, const void *b)
{
        return ntfs_device_win32_pio(fd, pos, count, (void*)NULL, b);
}

/**
 * ntfs_device_win32_write - write bytes to an ntfs device
 * @dev:        ntfs device obtained via ->open
 * @b:          pointer to the data to write
 * @count:      how many bytes should be written
 *
 * On success returns the number of bytes actually written.
 * On error returns -1 with errno set.
 */
static s64 ntfs_device_win32_write(struct ntfs_device *dev, const void *b,
                s64 count)
{
        s64 old_pos, to_write, i, bw = 0;
        win32_fd *fd = (win32_fd *)dev->d_private;
        const BYTE *alignedbuffer;
        BYTE *readbuffer;
        int old_ofs, ofs;

        old_pos = fd->pos;
        old_ofs = ofs = old_pos & (fd->geo_sector_size - 1);
        to_write = (ofs + count + fd->geo_sector_size - 1) &
                        ~(s64)(fd->geo_sector_size - 1);
        /* Impose maximum of 2GB to be on the safe side. */
        if (to_write > 0x80000000) {
                int delta = to_write - count;
                to_write = 0x80000000;
                count = to_write - delta;
        }
        ntfs_log_trace("fd = %p, b = %p, count = 0x%llx, pos = 0x%llx, "
                        "ofs = %i, to_write = 0x%llx.\n", fd, b,
                        (long long)count, (long long)old_pos, ofs,
                        (long long)to_write);
        if (NDevReadOnly(dev)) {
                ntfs_log_trace("Can't write on a R/O device.\n");
                errno = EROFS;
                return -1;
        }
        if (!count)
                return 0;
        NDevSetDirty(dev);
        readbuffer = (BYTE*)NULL;
        if (!((unsigned long)b & (fd->geo_sector_size - 1)) && !old_ofs &&
                        !(count & (fd->geo_sector_size - 1)))
                alignedbuffer = (const BYTE *)b;
        else {
                s64 end;

                readbuffer = (BYTE *)VirtualAlloc(NULL, to_write,
                                MEM_COMMIT, PAGE_READWRITE);
                if (!readbuffer) {
                        errno = ntfs_w32error_to_errno(GetLastError());
                        ntfs_log_trace("VirtualAlloc failed for write.\n");
                        return -1;
                }
                /* Read first sector if start of write not sector aligned. */
                if (ofs) {
                        i = ntfs_device_win32_pread_simple(fd,
                                        old_pos & ~(s64)(fd->geo_sector_size - 1),
                                        fd->geo_sector_size, readbuffer);
                        if (i != fd->geo_sector_size) {
                                if (i >= 0)
                                        errno = EIO;
                                goto write_error;
                        }
                }
                /*
                 * Read last sector if end of write not sector aligned and last
                 * sector is either not the same as the first sector or it is
                 * the same as the first sector but this has not been read in
                 * yet, i.e. the start of the write is sector aligned.
                 */
                end = old_pos + count;
                if ((end & (fd->geo_sector_size - 1)) &&
                                ((to_write > fd->geo_sector_size) || !ofs)) {
                        i = ntfs_device_win32_pread_simple(fd,
                                        end & ~(s64)(fd->geo_sector_size - 1),
                                        fd->geo_sector_size, readbuffer +
                                        to_write - fd->geo_sector_size);
                        if (i != fd->geo_sector_size) {
                                if (i >= 0)
                                        errno = EIO;
                                goto write_error;
                        }
                }
                /* Copy the data to be written into @readbuffer. */
                memcpy(readbuffer + ofs, b, count);
                alignedbuffer = readbuffer;
        }
        if (fd->vol_handle != INVALID_HANDLE_VALUE && old_pos < fd->geo_size) {
                s64 vol_to_write = fd->geo_size - old_pos;
                if (count > vol_to_write) {
                        bw = ntfs_device_win32_pwrite_simple(fd,
                                        old_pos & ~(s64)(fd->geo_sector_size - 1),
                                        ofs + vol_to_write, alignedbuffer);
                        if (bw == -1)
                                goto write_error;
                        to_write -= bw;
                        if (bw < ofs) {
                                bw = 0;
                                goto write_partial;
                        }
                        bw -= ofs;
                        fd->pos += bw;
                        ofs = fd->pos & (fd->geo_sector_size - 1);
                        if (bw != vol_to_write)
                                goto write_partial;
                }
        }
        i = ntfs_device_win32_pwrite_simple(fd,
                        fd->pos & ~(s64)(fd->geo_sector_size - 1), to_write,
                        alignedbuffer + bw);
        if (i == -1) {
                if (bw)
                        goto write_partial;
                goto write_error;
        }
        if (i < ofs)
                goto write_partial;
        i -= ofs;
        bw += i;
        if (bw > count)
                bw = count;
        fd->pos = old_pos + bw;
write_partial:
        if (readbuffer)
                VirtualFree(readbuffer, 0, MEM_RELEASE);
        return bw;
write_error:
        bw = -1;
        goto write_partial;
}

/**
 * ntfs_device_win32_stat - get a unix-like stat structure for an ntfs device
 * @dev:        ntfs device obtained via ->open
 * @buf:        pointer to the stat structure to fill
 *
 * Note: Only st_mode, st_size, and st_blocks are filled.
 *
 * Return 0 if o.k.
 *       -1 if not and errno set. in this case handle is trashed.
 */
static int ntfs_device_win32_stat(struct ntfs_device *dev, struct stat *buf)
{
        win32_fd *fd = (win32_fd *)dev->d_private;
        mode_t st_mode;

        if ((dev->d_name[1] == ':') && (dev->d_name[2] == '\0'))
                st_mode = S_IFBLK;
        else
                switch (GetFileType(fd->handle)) {
                case FILE_TYPE_CHAR:
                        st_mode = S_IFCHR;
                        break;
                case FILE_TYPE_DISK:
                        st_mode = S_IFREG;
                        break;
                case FILE_TYPE_PIPE:
                        st_mode = S_IFIFO;
                        break;
                default:
                        st_mode = 0;
                }
        memset(buf, 0, sizeof(struct stat));
        buf->st_mode = st_mode;
        buf->st_size = fd->part_length;
        if (buf->st_size != -1)
                buf->st_blocks = buf->st_size >> 9;
        else
                buf->st_size = 0;
        return 0;
}

#ifdef HDIO_GETGEO
/**
 * ntfs_win32_hdio_getgeo - get drive geometry
 * @dev:        ntfs device obtained via ->open
 * @argp:       pointer to where to put the output
 *
 * Note: Works on windows NT/2k/XP only.
 *
 * Return 0 if o.k.
 *       -1 if not, and errno set.  Note if error fd->handle is trashed.
 */
static __inline__ int ntfs_win32_hdio_getgeo(struct ntfs_device *dev,
                struct hd_geometry *argp)
{
        win32_fd *fd = (win32_fd *)dev->d_private;

        argp->heads = fd->geo_heads;
        argp->sectors = fd->geo_sectors;
        argp->cylinders = fd->geo_cylinders;
        argp->start = fd->part_hidden_sectors;
        return 0;
}
#endif

/**
 * ntfs_win32_blksszget - get block device sector size
 * @dev:        ntfs device obtained via ->open
 * @argp:       pointer to where to put the output
 *
 * Note: Works on windows NT/2k/XP only.
 *
 * Return 0 if o.k.
 *       -1 if not, and errno set.  Note if error fd->handle is trashed.
 */
static __inline__ int ntfs_win32_blksszget(struct ntfs_device *dev,int *argp)
{
        win32_fd *fd = (win32_fd *)dev->d_private;
        DWORD bytesReturned;
        DISK_GEOMETRY dg;

        if (DeviceIoControl(fd->handle, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
                        &dg, sizeof(DISK_GEOMETRY), &bytesReturned, NULL)) {
                /* success */
                *argp = dg.BytesPerSector;
                return 0;
        }
        errno = ntfs_w32error_to_errno(GetLastError());
        ntfs_log_trace("GET_DRIVE_GEOMETRY failed.\n");
        return -1;
}

static int ntfs_device_win32_ioctl(struct ntfs_device *dev,
                unsigned long request, void *argp)
{
#if defined(BLKGETSIZE) | defined(BLKGETSIZE64)
        win32_fd *fd = (win32_fd *)dev->d_private;
#endif

        ntfs_log_trace("win32_ioctl(0x%lx) called.\n", request);
        switch (request) {
#if defined(BLKGETSIZE)
        case BLKGETSIZE:
                ntfs_log_debug("BLKGETSIZE detected.\n");
                if (fd->part_length >= 0) {
                        *(int *)argp = (int)(fd->part_length / 512);
                        return 0;
                }
                errno = EOPNOTSUPP;
                return -1;
#endif
#if defined(BLKGETSIZE64)
        case BLKGETSIZE64:
                ntfs_log_debug("BLKGETSIZE64 detected.\n");
                if (fd->part_length >= 0) {
                        *(s64 *)argp = fd->part_length;
                        return 0;
                }
                errno = EOPNOTSUPP;
                return -1;
#endif
#ifdef HDIO_GETGEO
        case HDIO_GETGEO:
                ntfs_log_debug("HDIO_GETGEO detected.\n");
                return ntfs_win32_hdio_getgeo(dev, (struct hd_geometry *)argp);
#endif
#ifdef BLKSSZGET
        case BLKSSZGET:
                ntfs_log_debug("BLKSSZGET detected.\n");
                if (fd && !fd->ntdll) {
                        *(int*)argp = fd->geo_sector_size;
                        return (0);
                } else
                        return ntfs_win32_blksszget(dev, (int *)argp);
#endif
#ifdef BLKBSZSET
        case BLKBSZSET:
                ntfs_log_debug("BLKBSZSET detected.\n");
                /* Nothing to do on Windows. */
                return 0;
#endif
        default:
                ntfs_log_debug("unimplemented ioctl 0x%lx.\n", request);
                errno = EOPNOTSUPP;
                return -1;
        }
}

static s64 ntfs_device_win32_pread(struct ntfs_device *dev, void *b,
                s64 count, s64 offset)
{
        s64 got;
        win32_fd *fd;

                /* read the fast way if sector aligned */
        fd = (win32_fd*)dev->d_private;
        if (!((count | offset) & (fd->geo_sector_size - 1))) {
                got = ntfs_device_win32_pio(fd, offset, count, b, (void*)NULL);
        } else {
                if (ntfs_device_win32_seek(dev, offset, 0) == -1)
                        got = 0;
                else
                        got = ntfs_device_win32_read(dev, b, count);
        }

        return (got);
}

static s64 ntfs_device_win32_pwrite(struct ntfs_device *dev, const void *b,
                s64 count, s64 offset)
{
        s64 put;
        win32_fd *fd;

                /* write the fast way if sector aligned */
        fd = (win32_fd*)dev->d_private;
        if (!((count | offset) & (fd->geo_sector_size - 1))) {
                put = ntfs_device_win32_pio(fd, offset, count, (void*)NULL, b);
        } else {
                if (ntfs_device_win32_seek(dev, offset, 0) == -1)
                        put = 0;
                else
                        put = ntfs_device_win32_write(dev, b, count);
        }
        return (put);
}

struct ntfs_device_operations ntfs_device_win32_io_ops = {
        .open           = ntfs_device_win32_open,
        .close          = ntfs_device_win32_close,
        .seek           = ntfs_device_win32_seek,
        .read           = ntfs_device_win32_read,
        .write          = ntfs_device_win32_write,
        .pread          = ntfs_device_win32_pread,
        .pwrite         = ntfs_device_win32_pwrite,
        .sync           = ntfs_device_win32_sync,
        .stat           = ntfs_device_win32_stat,
        .ioctl          = ntfs_device_win32_ioctl
};

/*
 *                      Mark an open file as sparse
 *
 *      This is only called by ntfsclone when cloning a volume to a file.
 *      The argument is the target file, not a volume.
 *
 *      Returns 0 if successful.
 */

int ntfs_win32_set_sparse(int fd)
{
        BOOL ok;
        HANDLE handle;
        DWORD bytes;   

        handle = get_osfhandle(fd);
        if (handle == INVALID_HANDLE_VALUE)
                ok = FALSE;
        else
                ok = DeviceIoControl(handle, FSCTL_SET_SPARSE,
                                (void*)NULL, 0, (void*)NULL, 0,
                                &bytes, (LPOVERLAPPED)NULL);
        return (!ok);
}

/*
 *                      Resize an open file
 *
 *      This is only called by ntfsclone when cloning a volume to a file.
 *      The argument must designate a file, not a volume.
 *
 *      Returns 0 if successful.
 */

static int win32_ftruncate(HANDLE handle, s64 size)
{
        BOOL ok;
        LONG hsize, lsize;
        LONG ohsize, olsize;

        if (handle == INVALID_HANDLE_VALUE)
                ok = FALSE;
        else {
                SetLastError(NO_ERROR);
                        /* save original position */
                ohsize = 0;
                olsize = SetFilePointer(handle, 0, &ohsize, 1);
                hsize = size >> 32;
                lsize = size & 0xffffffff;
                ok = (SetFilePointer(handle, lsize, &hsize, 0) == (DWORD)lsize)
                    && (GetLastError() == NO_ERROR)
                    && SetEndOfFile(handle);
                        /* restore original position, even if above failed */
                SetFilePointer(handle, olsize, &ohsize, 0);
                if (GetLastError() != NO_ERROR)
                        ok = FALSE;
        }
        if (!ok)
                errno = EINVAL;
        return (ok ? 0 : -1);
}

int ntfs_device_win32_ftruncate(struct ntfs_device *dev, s64 size)
{
        win32_fd *fd;
        int ret;

        ret = -1;
        fd = (win32_fd*)dev->d_private;
        if (fd && !fd->ntdll)
                ret = win32_ftruncate(fd->handle, size);
        return (ret);
}

int ntfs_win32_ftruncate(int fd, s64 size)
{
        int ret;
        HANDLE handle;

        handle = get_osfhandle(fd);
        ret = win32_ftruncate(handle, size);
        return (ret);
}