/* (C) 2003 XDA Developers  itsme@xs4all.nl
 *
 * $Header$
 */
#include  <windows.h>
#include  <Pwinuser.h>
#include "ceioctl.h"
#include "debug.h"
#include <string>

#include "stringutils.h"

//#define PASSWORD "ager_voy"
#define PASSWORD "aYaLaMiH"

#ifndef min
inline int min(int a, int b) { return a<b ? a : b; }
#endif

std::string FLStatus_string(FLStatus status);
std::string FLCapability_string(FLCapability cap);
#ifdef FLEnvVars 
std::string FLEnvVars_string(FLEnvVars var);
#endif

// ------ from blockdev.h
#define FL_NOT_DOC    0 // - Not DiskOnChip
#define FL_DOC        1 // - DiskOnChip 2000
#define FL_MDOC       2 // - MDOC8-based devices
#define FL_MDOCP_16   4 // - MDOCP16-based devices (interleave-1)
#define FL_MDOCP      5 // - MDOCP32-based devices (interleave-2)
#define FL_DOC_OREN   6 // - OREN-based devices
#define FL_MDOC512_G3 7 // - MDOC512(G3)-based devices
#define FL_MDOC256_P3 8 // - MDOC256(P3)

// --------- to string translations
std::string Protection_string(byte protection)
{
    StringList list;
    if (protection&PROTECTABLE          ) list.push_back("PROTECTABLE");
    if (protection&READ_PROTECTED       ) list.push_back("READ_PROTECTED");
    if (protection&WRITE_PROTECTED      ) list.push_back("WRITE_PROTECTED");
    if (protection&LOCK_ENABLED         ) list.push_back("LOCK_ENABLED");
    if (protection&LOCK_ASSERTED        ) list.push_back("LOCK_ASSERTED");
    if (protection&KEY_INSERTED         ) list.push_back("KEY_INSERTED");
    if (protection&CHANGEABLE_PROTECTION) list.push_back("CHANGEABLE_PROTECTION");
    if (protection&OTW_PROTECTED        ) list.push_back("OTW_PROTECTED");
    if (protection&STICKY_LOCK_ASSERTED ) list.push_back("STICKY_LOCK_ASSERTED");

    const int knownbits=PROTECTABLE|READ_PROTECTED|WRITE_PROTECTED|LOCK_ENABLED|LOCK_ASSERTED|KEY_INSERTED|CHANGEABLE_PROTECTION|OTW_PROTECTED|STICKY_LOCK_ASSERTED;
    if (protection&~knownbits) list.push_back(stringformat("prot_%x", protection&~knownbits));

    return JoinStringList(list, ",");
}
std::string DOCType_string(char type)
{
switch(type) {
    case FL_NOT_DOC   : return "Not DiskOnChip";
    case FL_DOC       : return "DiskOnChip 2000";
    case FL_MDOC      : return "MDOC8-based devices";
    case FL_MDOCP_16  : return "MDOCP16-based devices (interleave-1)";
    case FL_MDOCP     : return "MDOCP32-based devices (interleave-2)";
    case FL_DOC_OREN  : return "OREN-based devices";
    case FL_MDOC512_G3: return "MDOC512(G3)-based devices";
    case FL_MDOC256_P3: return "MDOC256(P3)";
default: return stringformat("DOCType_%d", type);
}
}

std::string FLStatus_string(FLStatus status)
{
switch(status) {
case flOK: return "flOK";
case flBadFunction: return "flBadFunction";
case flFileNotFound: return "flFileNotFound";
case flPathNotFound: return "flPathNotFound";
case flTooManyOpenFiles: return "flTooManyOpenFiles";
case flNoWriteAccess: return "flNoWriteAccess";
case flBadFileHandle: return "flBadFileHandle";
case flDriveNotAvailable: return "flDriveNotAvailable";
case flNonFATformat: return "flNonFATformat";
case flFormatNotSupported: return "flFormatNotSupported";
case flNoMoreFiles: return "flNoMoreFiles";
case flWriteProtect: return "flWriteProtect";
case flBadDriveHandle: return "flBadDriveHandle";
case flDriveNotReady: return "flDriveNotReady";
case flUnknownCmd: return "flUnknownCmd";
case flBadFormat: return "flBadFormat";
case flBadLength: return "flBadLength";
case flDataError: return "flDataError";
case flUnknownMedia: return "flUnknownMedia";
case flSectorNotFound: return "flSectorNotFound";
case flOutOfPaper: return "flOutOfPaper";
case flWriteFault: return "flWriteFault";
case flReadFault: return "flReadFault";
case flGeneralFailure: return "flGeneralFailure";
case flDiskChange: return "flDiskChange";
case flVppFailure: return "flVppFailure";
case flBadParameter: return "flBadParameter";
case flNoSpaceInVolume: return "flNoSpaceInVolume";
case flInvalidFATchain: return "flInvalidFATchain";
case flRootDirectoryFull: return "flRootDirectoryFull";
case flNotMounted: return "flNotMounted";
case flPathIsRootDirectory: return "flPathIsRootDirectory";
case flNotADirectory: return "flNotADirectory";
case flDirectoryNotEmpty: return "flDirectoryNotEmpty";
case flFileIsADirectory: return "flFileIsADirectory";
case flAdapterNotFound: return "flAdapterNotFound";
case flFormattingError: return "flFormattingError";
case flNotEnoughMemory: return "flNotEnoughMemory";
case flVolumeTooSmall: return "flVolumeTooSmall";
case flBufferingError: return "flBufferingError";
case flFileAlreadyExists: return "flFileAlreadyExists";
case flForceDismount: return "flForceDismount";
case flIncomplete: return "flIncomplete";
case flTimedOut: return "flTimedOut";
case flTooManyComponents: return "flTooManyComponents";
case flTooManyDrives: return "flTooManyDrives";
case flTooManyBinaryPartitions: return "flTooManyBinaryPartitions";
case flPartitionNotFound: return "flPartitionNotFound";
case flFeatureNotSupported: return "flFeatureNotSupported";
case flWrongVersion: return "flWrongVersion";
case flTooManyBadBlocks: return "flTooManyBadBlocks";
case flNotProtected: return "flNotProtected";
case flUnchangeableProtection: return "flUnchangeableProtection";
case flBadDownload: return "flBadDownload";
case flBadBBT: return "flBadBBT";
case flInterleaveError: return "flInterleaveError";
case flWrongKey: return "flWrongKey";
case flHWProtection: return "flHWProtection";
case flLeftForCompetability: return "flLeftForCompetability";
case flMultiDocContradiction: return "flMultiDocContradiction";
case flCanNotFold: return "flCanNotFold";
case flBadIPLBlock: return "flBadIPLBlock";
case flIOCommandBlocked: return "flIOCommandBlocked";
case flBadTransaction: return "flBadTransaction";
case flTooManyTransactions: return "flTooManyTransactions";
case flUnitIsNotErased: return "flUnitIsNotErased";
case flSequenceError: return "flSequenceError";
case flFIFOTimeOut: return "flFIFOTimeOut";
case flUnitIsBad: return "flUnitIsBad";
case flFlashIsVirgin: return "flFlashIsVirgin";
default: return stringformat("FLStatus_%d", status);
}
}

std::string FLCapability_string(FLCapability cap)
{
switch(cap) {
case CAPABILITY_NOT_SUPPORTED: return "CAPABILITY_NOT_SUPPORTED";
case CAPABILITY_SUPPORTED: return "CAPABILITY_SUPPORTED";
case SUPPORT_UNERASABLE_BBT: return "SUPPORT_UNERASABLE_BBT";
case SUPPORT_MULTIPLE_BDTL_PARTITIONS: return "SUPPORT_MULTIPLE_BDTL_PARTITIONS";
case SUPPORT_MULTIPLE_BINARY_PARTITIONS: return "SUPPORT_MULTIPLE_BINARY_PARTITIONS";
case SUPPORT_HW_PROTECTION: return "SUPPORT_HW_PROTECTION";
case SUPPORT_HW_LOCK_KEY: return "SUPPORT_HW_LOCK_KEY";
case SUPPORT_CUSTOMER_ID: return "SUPPORT_CUSTOMER_ID";
case SUPPORT_UNIQUE_ID: return "SUPPORT_UNIQUE_ID";
case SUPPORT_DEEP_POWER_DOWN_MODE: return "SUPPORT_DEEP_POWER_DOWN_MODE";
case SUPPORT_OTP_AREA: return "SUPPORT_OTP_AREA";
case SUPPORT_WRITE_IPL_ROUTINE: return "SUPPORT_WRITE_IPL_ROUTINE";

default: return stringformat("FLCapability_%d", cap);
}
}
#ifdef FLEnvVars 
std::string FLEnvVars_string(FLEnvVars var)
{
switch(var) {
case FL_ENV_VARS_PER_SYSTEM: return "FL_ENV_VARS_PER_SYSTEM";
case FL_IS_RAM_CHECK_ENABLED: return "FL_IS_RAM_CHECK_ENABLED";
case FL_NFTL_CACHE_ENABLED: return "FL_NFTL_CACHE_ENABLED";
case FL_DOC_8BIT_ACCESS: return "FL_DOC_8BIT_ACCESS";
case FL_MULTI_DOC_ENABLED: return "FL_MULTI_DOC_ENABLED";
case FL_SET_MAX_CHAIN: return "FL_SET_MAX_CHAIN";
case FL_MARK_DELETE_ON_FLASH: return "FL_MARK_DELETE_ON_FLASH";
case FL_MTL_POLICY: return "FL_MTL_POLICY";
case FL_SECTORS_VERIFIED_PER_FOLDING: return "FL_SECTORS_VERIFIED_PER_FOLDING";
case FL_SUSPEND_MODE: return "FL_SUSPEND_MODE";

case FL_ENV_VARS_PER_SOCKET: return "FL_ENV_VARS_PER_SOCKET";
case FL_VERIFY_WRITE_OTHER: return "FL_VERIFY_WRITE_OTHER";
case FL_MTD_BUS_ACCESS_TYPE: return "FL_MTD_BUS_ACCESS_TYPE";

case FL_ENV_VARS_PER_VOLUME: return "FL_ENV_VARS_PER_VOLUME";
case FL_SET_POLICY: return "FL_SET_POLICY";
case FL_VERIFY_WRITE_BDTL: return "FL_VERIFY_WRITE_BDTL";
case FL_VERIFY_WRITE_BINARY: return "FL_VERIFY_WRITE_BINARY";
default: return stringformat("FLEnvVars_%d", var);
}
}
#endif

HANDLE OpenDisk(char *dsk)
{
    TCHAR diskname[16];
    _sntprintf(diskname, 16, L"%hs", dsk);

    HANDLE hDsk= CreateFile( diskname,
            GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
            NULL, OPEN_EXISTING, 0, 0 );
    if (hDsk==NULL || hDsk==INVALID_HANDLE_VALUE)
    {
        return NULL;
    }
    return hDsk;
}
bool DskGetInfo(HANDLE hDsk)
{
    flDiskInfoOutput out; memset(&out, 0, sizeof(out));
    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_GET_INFO, NULL, 0, &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_GET_INFO");
        //return false;
    }

    debug("FL_IOCTL_GET_INFO: status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("sectors=%08lx  boot=%08lx  base=%08lx  flashtype=%04x phys=%08lx unit=%04x\n",
            out.info.logicalSectors, out.info.bootAreaSize, out.info.baseAddress,
            out.info.flashType, out.info.physicalSize, out.info.physicalUnitSize);
    debug("type=%hs  lifetime=%d  ver=%s  osakver=%s\n",
            DOCType_string(out.info.DOCType).c_str(), out.info.lifeTime, out.info.driverVer, out.info.OSAKVer);
    debug("cyl=%d head=%d sect=%d\n", out.info.cylinders, out.info.heads, out.info.sectors);

    return true;
}
bool DskUnProtect2(HANDLE hDsk, char *password)
{
    BYTE in[12];   memset(&in, 0, sizeof(in));
    flOutputStatusRecord out; memset(&out, 0, sizeof(out));

    in[0]= FL_UNPROTECT;
    memcpy(in+1, password, min(8, strlen(password)));

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_WRITE_PROTECT, &in, sizeof(in), &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_WRITE_PROTECT:FL_UNPROTECT2");
        //return false;
    }

    debug("FL_IOCTL_WRITE_PROTECT:FL_UNPROTECT:2 status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);

    return true;
}
bool DskUnProtect(HANDLE hDsk, char *password)
{
    flWriteProtectInput in;   memset(&in, 0, sizeof(in));
    flOutputStatusRecord out; memset(&out, 0, sizeof(out));

    in.password[0]=0;
    in.password[1]=0;
    in.type= FL_UNPROTECT;
    memcpy((char*)in.password, password, min(8, strlen(password)));

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_WRITE_PROTECT, &in, sizeof(in), &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_WRITE_PROTECT:FL_UNPROTECT");
        //return false;
    }

    debug("FL_IOCTL_WRITE_PROTECT:FL_UNPROTECT: status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);

    return true;
}
bool DskUnLock2(HANDLE hDsk, char *password)
{
    BYTE in[12];   memset(&in, 0, sizeof(in));
    flOutputStatusRecord out; memset(&out, 0, sizeof(out));

    in[0]= FL_UNLOCK;
    memcpy(in+1, password, min(8, strlen(password)));

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_WRITE_PROTECT, &in, sizeof(in), &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_WRITE_PROTECT:FL_UNLOCK2");
        //return false;
    }

    debug("FL_IOCTL_WRITE_PROTECT:FL_UNLOCK2: status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);

    return true;
}
bool DskUnLock(HANDLE hDsk, char *password)
{
    flWriteProtectInput in;   memset(&in, 0, sizeof(in));
    flOutputStatusRecord out; memset(&out, 0, sizeof(out));

    in.password[0]=0;
    in.password[1]=0;
    in.type= FL_UNLOCK;
    memcpy((char*)in.password, password, min(8, strlen(password)));

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_WRITE_PROTECT, &in, sizeof(in), &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_WRITE_PROTECT:FL_UNLOCK");
        //return false;
    }

    debug("FL_IOCTL_WRITE_PROTECT:FL_UNLOCK: status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);

    return true;
}
// this will only work on DSK1:
bool DskOtpInfo(HANDLE hDsk)
{
    flOtpInput in;            memset(&in, 0, sizeof(in));
    flOutputStatusRecord out; memset(&out, 0, sizeof(out));

    in.type= OTP_SIZE;
    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_OTP, &in, sizeof(in), &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_OTP");
        //return false;
    }

    debug("FL_IOCTL_OTP:OTP_SIZE status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("    length=%08lx  used=%08lx  locked=%d\n", in.length, in.usedSize, in.lockedFlag);

    return true;
}
// this will return flNoSpaceInVolume when the otp is empty.
bool DskOtpRead(HANDLE hDsk)
{
    flOtpInput in;            memset(&in, 0, sizeof(in));
    flOutputStatusRecord out; memset(&out, 0, sizeof(out));

    ByteVector buffer; buffer.resize(0x1800);

    in.type= OTP_READ;
    in.length= buffer.size();
    in.usedSize= 0;
    in.buffer= vectorptr(buffer);
    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_OTP, &in, sizeof(in),
                // vectorptr(buffer), buffer.size(),
                &out, sizeof(out),
                &nReturned, NULL)) {
        error("FL_IOCTL_OTP");
        //return false;
    }

    debug("FL_IOCTL_OTP:OTP_READ status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("    length=%08lx  used=%08lx  locked=%d\n", in.length, in.usedSize, in.lockedFlag);

    bighexdump(0, buffer);

    return true;
}
bool DskGetCustomerId(HANDLE hDsk)
{
    flCustomerIdOutput out; memset(&out, 0, sizeof(out));

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_CUSTOMER_ID, NULL, 0, &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_CUSTOMER_ID");
        //return false;
    }

    debug("FL_IOCTL_CUSTOMER_ID: status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("customerid %02x %02x %02x %02x\n", out.id[0], out.id[1], out.id[2], out.id[3]);

    return true;
}
bool DskGetUniqueId(HANDLE hDsk)
{
    flUniqueIdOutput out; memset(&out, 0, sizeof(out));

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_UNIQUE_ID, NULL, 0, &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_UNIQUE_ID");
        //return false;
    }

    debug("FL_IOCTL_UNIQUE_ID: status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("uniqueid %s\n", hexdump(out.id, 16).c_str());

    return true;
}
bool DskGetNrPartitions(HANDLE hDsk)
{
    flCountPartitionsOutput out; memset(&out, 0, sizeof(out));

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_NUMBER_OF_PARTITIONS, NULL, 0, &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_NUMBER_OF_PARTITIONS");
        //return false;
    }

    debug("FL_IOCTL_NUMBER_OF_PARTITIONS: status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("nr partitions: %d\n", out.noOfPartitions);

    return true;
}
bool DskGetCapability(HANDLE hDsk, FLCapability cap)
{
    flCapabilityInput in;   memset(&in, 0, sizeof(in));
    flCapabilityOutput out; memset(&out, 0, sizeof(out));

    in.capability= cap;

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_INQUIRE_CAPABILITIES, &in, sizeof(in), &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_INQUIRE_CAPABILITIES");
        //return false;
    }

    debug("FL_IOCTL_INQUIRE_CAPABILITIES: status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("capability(%hs): %hs\n", FLCapability_string(cap).c_str(), FLCapability_string(out.capability).c_str());

    return true;
}
bool GetCaps(HANDLE hDsk)
{
    int cap;
    for (cap= SUPPORT_UNERASABLE_BBT ; cap<=SUPPORT_WRITE_IPL_ROUTINE ; cap++)
        DskGetCapability(hDsk, (FLCapability)cap);

    return true;
}
bool GetBinaryHWProtection(HANDLE hDsk, int ptype)
{
    flProtectionInput in;   memset(&in, 0, sizeof(in));
    flProtectionOutput out; memset(&out, 0, sizeof(out));

    in.protectionType= ptype;
    memcpy(in.key, PASSWORD, 8);
    in.type= PROTECTION_GET_TYPE;

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_BINARY_HW_PROTECTION, &in, sizeof(in), &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_BINARY_HW_PROTECTION");
        //return false;
    }

    debug("FL_IOCTL_BINARY_HW_PROTECTION: status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("protectiontype: %hs\n", Protection_string(in.protectionType).c_str());

    return true;
}
bool GetPartitionHWProtection(HANDLE hDsk, int partition, int ptype)
{
    flBDKProtectionInput in; memset(&in, 0, sizeof(in));
    flProtectionOutput out;  memset(&out, 0, sizeof(out));

    in.partitionNumber= partition;
    in.protectionType= ptype;
    memcpy(in.key, PASSWORD, 8);
    in.type= PROTECTION_GET_TYPE;

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_BDTL_HW_PROTECTION, &in, sizeof(in), &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_BDTL_HW_PROTECTION");
        //return false;
    }

    debug("FL_IOCTL_BDTL_HW_PROTECTION: status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("in protectiontype: %hs\n", Protection_string(in.protectionType).c_str());
    debug("out protectiontype: %hs\n", Protection_string(out.protectionType).c_str());

    return true;
}
bool PartitionInsertKey(HANDLE hDsk)
{
    //flBDKProtectionInput in; memset(&in, 0, sizeof(in));
    BYTE in[10];

    in[0]= 0;
    memcpy(in+1, PASSWORD, 8);
    in[9]= PROTECTION_INSERT_KEY;

    flProtectionOutput out;  memset(&out, 0, sizeof(out));

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_BDTL_HW_PROTECTION, &in, sizeof(in), &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_BDTL_HW_PROTECTION");
        //return false;
    }

    debug("FL_IOCTL_BDTL_HW_PROTECTION:PROTECTION_INSERT_KEY status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("in protectiontype: %hs\n", Protection_string(in[0]).c_str());
    debug("out protectiontype: %hs\n", Protection_string(out.protectionType).c_str());

    return true;
}
bool PartitionChangeType(HANDLE hDsk)
{
    BYTE in[10];

    in[0]= PROTECTABLE;
    memcpy(in+1, PASSWORD, 8);
    in[9]= PROTECTION_CHANGE_TYPE;

    flProtectionOutput out;  memset(&out, 0, sizeof(out));

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_BDTL_HW_PROTECTION, &in, sizeof(in), &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_BDTL_HW_PROTECTION");
        //return false;
    }

    debug("FL_IOCTL_BDTL_HW_PROTECTION:PROTECTION_CHANGE_TYPE status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("in protectiontype: %hs\n", Protection_string(in[0]).c_str());
    debug("out protectiontype: %hs\n", Protection_string(out.protectionType).c_str());

    return true;
}
bool GetPartitionInfo(HANDLE hDsk, int partition)
{
    flBDKOperationInput in;   memset(&in, 0, sizeof(in));
    flOutputStatusRecord out; memset(&out, 0, sizeof(out));

    ByteVector buffer; buffer.resize(0x8000);

    in.partitionNumber= partition;
    in.bdkStruct.signOffset = 8;
    in.type= BDK_GET_INFO;
    in.bdkStruct.bdkBuffer= vectorptr(buffer);
    in.bdkStruct.length= buffer.size();

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_BDK_OPERATION, &in, sizeof(in), &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_BDK_OPERATION");
        //return false;
    }

    debug("FL_IOCTL_BDK_OPERATION:BDK_GET_INFO status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("oldsign=%hs\n", hexdump(in.bdkStruct.oldSign, BDK_SIGNATURE_NAME).c_str());
    debug("newsign=%hs\n", hexdump(in.bdkStruct.newSign, BDK_SIGNATURE_NAME).c_str());
    debug("   signoff=%d  start=%08lx len=%08lx  fl=%02x buf=%08lx\n",
        in.bdkStruct.signOffset, in.bdkStruct.startingBlock, in.bdkStruct.length,
        in.bdkStruct.flags, in.bdkStruct.bdkBuffer);

    return true;
}
bool ReadBDKSector(HANDLE hDsk, int partition, int sector)
{
    flBDKOperationInput in;   memset(&in, 0, sizeof(in));
    flOutputStatusRecord out; memset(&out, 0, sizeof(out));

    ByteVector buffer; buffer.resize(0x8000);

    in.partitionNumber= partition;
    in.type= BDK_READ;
    in.bdkStruct.startingBlock= sector;
    in.bdkStruct.length= buffer.size();
    //in.bdkStruct.bdkBuffer= vectorptr(buffer);

    DWORD nReturned=0;
    // vectorptr(buffer), buffer.size()
    // &out, sizeof(out)
    if (!DeviceIoControl(hDsk, FL_IOCTL_BDK_OPERATION, &in, sizeof(in), vectorptr(buffer), buffer.size(), &nReturned, NULL)) {
        error("FL_IOCTL_BDK_OPERATION -ret=%d", nReturned);
        //return false;
    }

    debug("FL_IOCTL_BDK_OPERATION:BDK_READ status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("oldsign=%hs\n", hexdump(in.bdkStruct.oldSign, BDK_SIGNATURE_NAME).c_str());
    debug("newsign=%hs\n", hexdump(in.bdkStruct.newSign, BDK_SIGNATURE_NAME).c_str());
    debug("   signoff=%d  start=%08lx len=%08lx  fl=%02x buf=%08lx\n",
        in.bdkStruct.signOffset, in.bdkStruct.startingBlock, in.bdkStruct.length,
        in.bdkStruct.flags, in.bdkStruct.bdkBuffer);

    bighexdump(0x8000*sector, buffer);
    return true;
}
bool WriteBDKSector(HANDLE hDsk, int partition, int sector, const ByteVector& data)
{
    flBDKOperationInput in;   memset(&in, 0, sizeof(in));
    flOutputStatusRecord out; memset(&out, 0, sizeof(out));

    ByteVector buffer(data);
    in.partitionNumber= partition;
    in.type= BDK_WRITE;
    in.bdkStruct.startingBlock= sector;
    in.bdkStruct.length= buffer.size();
    //in.bdkStruct.bdkBuffer= vectorptr(buffer);

    DWORD nReturned=0;
    // vectorptr(buffer), buffer.size()
    // &out, sizeof(out)
    if (!DeviceIoControl(hDsk, FL_IOCTL_BDK_OPERATION, &in, sizeof(in), vectorptr(buffer), buffer.size(), &nReturned, NULL)) {
        error("FL_IOCTL_BDK_OPERATION -ret=%d", nReturned);
        //return false;
    }

    debug("FL_IOCTL_BDK_OPERATION:BDK_WRITE status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("oldsign=%hs\n", hexdump(in.bdkStruct.oldSign, BDK_SIGNATURE_NAME).c_str());
    debug("newsign=%hs\n", hexdump(in.bdkStruct.newSign, BDK_SIGNATURE_NAME).c_str());
    debug("   signoff=%d  start=%08lx len=%08lx  fl=%02x buf=%08lx\n",
        in.bdkStruct.signOffset, in.bdkStruct.startingBlock, in.bdkStruct.length,
        in.bdkStruct.flags, in.bdkStruct.bdkBuffer);

    return true;
}
#ifdef FLEnvVars
bool DskGetVariable(HANDLE hDsk, int context, FLEnvVars var)
{
    flExtendedEnvVarsInput in;   memset(&in, 0, sizeof(in));
    flExtendedEnvVarsOutput out; memset(&out, 0, sizeof(out));

    in.varName= var;
    in.varValue= 0;
    in.flags= context;

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_EXTENDED_ENVIRONMENT_VARIABLES, &in, sizeof(in), &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_EXTENDED_ENVIRONMENT_VARIABLES");
        //return false;
    }

    debug("FL_IOCTL_EXTENDED_ENVIRONMENT_VARIABLES: status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("variable(%hs): %08lx\n",FLEnvVars_string(var).c_str(), out.prevValue);

    in.varName= var;
    in.varValue= out.prevValue;
    in.flags= context;

    nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_EXTENDED_ENVIRONMENT_VARIABLES, &in, sizeof(in), &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_EXTENDED_ENVIRONMENT_VARIABLES");
        //return false;
    }


    return true;
}
bool GetVariables(HANDLE hDsk)
{
    for (int i=0 ; i<2 ; i++)
        DskGetVariable(hDsk, FL_APPLY_TO_ALL, (FLEnvVars)i);
    return true;
}
#endif
// this can read sectors 0 .. 32763 for disk 1
bool GetSector(HANDLE hDsk, int sector)
{
    flReadWriteInput in;   memset(&in, 0, sizeof(in));
    flReadWriteOutput out; memset(&out, 0, sizeof(out));

    ByteVector buffer; buffer.resize(0x200);

    in.firstSector= sector;
    in.numberOfSectors= 1;
    //in.buf= vectorptr(buffer);

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_READ_SECTORS, &in, sizeof(in), vectorptr(buffer), buffer.size(), &nReturned, NULL)) {
        memcpy(&out, vectorptr(buffer), sizeof(out));
        error("FL_IOCTL_READ_SECTORS-ret=%d: %hs  nread=%d", nReturned, FLStatus_string(out.status).c_str(), out.numberOfSectors);
        //return false;
    }

    debug("FL_IOCTL_READ_SECTORS: READ status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("   nrread=%d\n", out.numberOfSectors);

    bighexdump(0, buffer);
    return true;

}
bool WriteSector(HANDLE hDsk, int sector, const ByteVector& data)
{
    flReadWriteInput in;   memset(&in, 0, sizeof(in));
    flReadWriteOutput out; memset(&out, 0, sizeof(out));

    ByteVector buffer(data);
    in.firstSector= sector;
    in.numberOfSectors= buffer.size()/512;
    //in.buf= vectorptr(buffer);

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_WRITE_SECTORS, &in, sizeof(in), vectorptr(buffer), buffer.size(), &nReturned, NULL)) {
        memcpy(&out, vectorptr(buffer), sizeof(out));
        error("FL_IOCTL_WRITE_SECTORS-ret=%d: %hs  nread=%d", nReturned, FLStatus_string(out.status).c_str(), out.numberOfSectors);
        //return false;
    }

    debug("FL_IOCTL_WRITE_SECTORS: WRITE status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);
    debug("   nrread=%d\n", out.numberOfSectors);

    return true;
}
bool FormatDisk(HANDLE hDsk)
{
    flFormatPhysicalInput in;   memset(&in, 0, sizeof(in));
    flOutputStatusRecord out; memset(&out, 0, sizeof(out));

    BDTLPartitionFormatParams   bdtl[2]; memset(&bdtl, 0, sizeof(bdtl));
    //BinaryPartitionFormatParams bin[1]; memset(&bin, 0, sizeof(bin));

    bdtl[0].length= 32768*512;
    bdtl[0].noOfSpareUnits= 2;
    bdtl[0].flags= TL_FORMAT_FAT;
    //bdtl[0].volumeId= {0x00, 0x00, 0x00,0x00};
    //bdtl[0].volumeLabel= NULL;
    bdtl[0].noOfFATcopies= 1;
    memcpy(bdtl[0].protectionKey, PASSWORD, 8);
    bdtl[0].protectionType= 0;

    bdtl[1].length= 0; // 29952*512;
    bdtl[1].noOfSpareUnits= 2;
    bdtl[1].flags= TL_FORMAT_FAT;
    //bdtl[1].volumeId= {0x00, 0x00, 0x00,0x00};
    //bdtl[1].volumeLabel= NULL;
    bdtl[0].noOfFATcopies= 1;
    //bdtl[1].protectionKey= {0, 0, 0, 0, 0, 0, 0, 0}
    bdtl[1].protectionType= 0;
/*
    bin[0].length= 0x80000;
    memcpy(bin[0].sign, "BIPO",4);
    bin[0].signOffset= 8;
    memcpy(bin[0].protectionKey, PASSWORD, 8);
    bin[0].protectionType= 0;
*/
    in.formatType= TL_LEAVE_BINARY_AREA;
    in.fp.percentUse= 98;
    in.fp.noOfBDTLPartitions= 2;
    in.fp.noOfBinaryPartitions= 1;
    in.fp.BDTLPartitionInfo= bdtl;
    in.fp.binaryPartitionInfo= NULL;
    in.fp.cascadedDeviceNo= 0;
    in.fp.noOfCascadedDevices= 0;
    in.fp.progressCallback= NULL;
    in.fp.vmAddressingLimit= 0x10000;  // - not for disk-on-chip
    in.fp.embeddedCISlength= 0;        // - not for disk-on-chip
    in.fp.embeddedCIS= 0;              // - not for disk-on-chip

    DWORD nReturned=0;
    if (!DeviceIoControl(hDsk, FL_IOCTL_FORMAT_PHYSICAL_DRIVE, &in, sizeof(in), &out, sizeof(out), &nReturned, NULL)) {
        error("FL_IOCTL_FORMAT_PHYSICAL_DRIVE-ret=%d", nReturned);
        //return false;
    }

    debug("FL_IOCTL_FORMAT_PHYSICAL_DRIVE: status: %hs  ret=%d\n", FLStatus_string(out.status).c_str(), nReturned);

    return true;
}

bool testdisk(char *dsk)
{
    debug("testing disk %s\n", dsk);

    HANDLE hDsk= OpenDisk(dsk);
    if (hDsk==NULL) {
        error("Open");
        return false;
    }
    DskGetInfo(hDsk);

    //DskUnLock2(hDsk, PASSWORD);
    //DskUnProtect2(hDsk, PASSWORD);
    DskOtpInfo(hDsk);
    DskOtpRead(hDsk);

    DskGetCustomerId(hDsk);
    DskGetUniqueId(hDsk);
    DskGetNrPartitions(hDsk);

    GetCaps(hDsk);
    GetPartitionInfo(hDsk, 1);

/*
    debug("............ FORMATTING ...............\n");
    FormatDisk(hDsk);
    debug("............ DONE       ...............\n");

    DskGetInfo(hDsk);

    DskUnLock(hDsk, PASSWORD);
    DskUnProtect(hDsk, PASSWORD);
    DskOtpInfo(hDsk);
    //DskOtpRead(hDsk);

    DskGetCustomerId(hDsk);
    DskGetUniqueId(hDsk);
    DskGetNrPartitions(hDsk);

    GetCaps(hDsk);
    GetPartitionInfo(hDsk, 1);
*/


    debug("....... checking binary\n");
    for (int ptype=1 ; ptype<256 ; ptype<<=1)
        GetBinaryHWProtection(hDsk, ptype);

    for (int part=0 ; part<4 ; part++) {
        debug("........checking partition=%d\n", part);
        for (int ptype=1 ; ptype<256 ; ptype<<=1)
            GetPartitionHWProtection(hDsk, part, ptype);
    }
    debug("-----------------------------------------------------------------------------\n");

    int sector;
    for (sector=0 ; sector<16 ; sector++) {
        debug("-------------reading BDK part=%d sect=%d\n", 0, sector);
        ReadBDKSector(hDsk, 0, sector);
    }


    //PartitionInsertKey(hDsk);
    //PartitionChangeType(hDsk);

    sector= 0;
    debug("------------- reading sector %d from disk %s\n", sector, dsk);
    GetSector(hDsk, sector);
    //ByteVector newbuf; newbuf.resize(512);
    //memset(vectorptr(newbuf), 123, newbuf.size());

    //WriteSector(hDsk, sector, newbuf);

    sector++;
    GetSector(hDsk, sector);

    //GetVariables(hDsk);

    CloseHandle(hDsk);

    return true;
}

int WINAPI WinMain( HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPTSTR    lpCmdLine,
                   int       nCmdShow)
{
    DebugSetLogfile("tsttffs.log");

    debug("\n\n\n");
    testdisk("DSK1:");
    testdisk("DSK2:");
    testdisk("\\storage");
    testdisk("\\BINFS");

    return 0;
}