windows-server-2003/multimedia/wmdm_sr1/common/serialnumber/serialid.cpp

//-----------------------------------------------------------------------------
//
// File:   serialid.cpp
//
// Microsoft Digital Rights Management
// Copyright (C) Microsoft Corporation, 1998 - 1999, All Rights Reserved
//
// Description:
//
//-----------------------------------------------------------------------------
#include <windows.h>
#include <stddef.h>

#include "drmerr.h"
#include "aspi32.h"
#include "serialid.h"
#include "spti.h"
//#include "KBDevice.h"
#include <crtdbg.h>

HRESULT __stdcall UtilStartStopService(bool fStartService);


// #define WRITE_TO_LOG_FILE

#if defined(DBG) || defined(WRITE_TO_LOG_FILE)
#include <stdio.h>
#endif

void DebugMsg(const char* pszFormat, ...)
{
#if defined(DBG) || defined(WRITE_TO_LOG_FILE)
    char buf[1024];
    sprintf(buf, "[Serial Number Library](%lu): ", GetCurrentThreadId());
        va_list arglist;
        va_start(arglist, pszFormat);
    vsprintf(&buf[strlen(buf)], pszFormat, arglist);
        va_end(arglist);
    strcat(buf, "\n");

#if defined(DBG)
    OutputDebugString(buf);
#endif

#if defined(WRITE_TO_LOG_FILE)
    FILE* fp = fopen("c:\\WmdmService.txt", "a");
    if (fp)
    {
        fprintf(fp, buf);
        fclose(fp);
    }
#endif

#endif
}

#ifdef USE_IOREADY
    #ifndef __Using_iomegaReady_Lib__
        #define __Using_iomegaReady_Lib__
    #endif
    #include "ioReadyMin.h"
#endif

#define WCS_PMID_SOFT L"media.id"


BOOL IsWinNT()
{
    OSVERSIONINFO osvi;
    BOOL bRet=FALSE;

    ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

    if ( ! GetVersionEx ( (OSVERSIONINFO *) &osvi) )
        return FALSE;

    switch ( osvi.dwPlatformId )
    {
    case VER_PLATFORM_WIN32_NT:
        bRet=TRUE;
        break;

    case VER_PLATFORM_WIN32_WINDOWS:
        bRet=FALSE;
        break;

    case VER_PLATFORM_WIN32s:
        bRet=FALSE;
        break;
    }

    return bRet; 
}

BOOL IsAdministrator(DWORD& dwLastError)
{
    dwLastError = ERROR_SUCCESS;
    if ( IsWinNT() )
    {
/*		typedef SC_HANDLE (*T_POSCM)(LPCTSTR,LPCTSTR,DWORD);

        T_POSCM p_OpenSCM=NULL;

        p_OpenSCM = (T_POSCM)GetProcAddress(GetModuleHandle("advapi32.dll"), "OpenSCManagerA");
        
        if( !p_OpenSCM )
        {
            return FALSE;
        }
*/
        SC_HANDLE hSCM = OpenSCManagerA(NULL, // local machine
                                        NULL, // ServicesActive database
                                        SC_MANAGER_ALL_ACCESS); // full access
        if ( !hSCM )
        {
            dwLastError = GetLastError();
            if (dwLastError == ERROR_ACCESS_DENIED)
            {
                dwLastError = ERROR_SUCCESS;
            }
            return FALSE;
        }
        else
        {
            CloseServiceHandle(hSCM);
            return TRUE;
        }
    }
    else // On Win9x, everybody is admin
    {
        return TRUE;
    }
}

UINT __stdcall UtilGetDriveType(LPSTR szDL)
{
    return GetDriveTypeA(szDL);
}

BOOL IsIomegaDrive(DWORD dwDriveNum)
{
    BOOL bRet=FALSE;

#ifdef USE_IOREADY
    if (dwDriveNum >= 26)
    {
        return bRet;
    }

    ioReady::Drive *pDrive = NULL;
    pDrive = new ioReady::Drive((int) dwDriveNum);
    if ( pDrive )
    {
        if ( pDrive->isIomegaDrive() )
            bRet=TRUE;
        delete pDrive;
    }
#endif 
    DebugMsg("IsIomegaDrive returning %u", bRet);

    return bRet;
}


BOOL GetIomegaDiskSerialNumber(DWORD dwDriveNum, PWMDMID pSN)
{
    BOOL bRet=FALSE;

#ifdef USE_IOREADY
    if (dwDriveNum >= 26)
    {
        return bRet;
    }

    ioReady::Drive *pDrive = NULL;
    char *pszSerial = NULL;
    pDrive = new ioReady::Drive((int) dwDriveNum);
    if ( pDrive )
    {
        if ( pDrive->isIomegaDrive() )
        {
            ioReady::Disk &refDisk = pDrive->getDisk();
            pszSerial = (char *)refDisk.getMediaSerialNumber();
            if ( pszSerial[0] )
            {
                ZeroMemory(pSN->pID, WMDMID_LENGTH);
                if (ioReady::ct_nSerialNumberLength <= sizeof(pSN->pID))
                {
                    CopyMemory(pSN->pID, pszSerial, ioReady::ct_nSerialNumberLength);
                    pSN->SerialNumberLength = ioReady::ct_nSerialNumberLength;
                    pSN->dwVendorID = MDSP_PMID_IOMEGA;
                    bRet = TRUE;
                }
            }
        }
    }
    delete pDrive;
#endif
    return bRet;
}

HRESULT __stdcall UtilGetManufacturer(LPWSTR pDeviceName, LPWSTR *ppwszName, UINT nMaxChars)
{
    HRESULT hr=S_OK;

    CARg(pDeviceName);
    CARg(ppwszName);

    CPRg(nMaxChars>16); // ensure enough buffer size

    DWORD dwDriveNum;

    // We use only the first char of pDeviceName and expect it to 
    // be a drive letter. The rest of pDeviceName is not validated.
    // Perhaps it should, but we don't want to break our clients.
    if (pDeviceName[0] >= L'A' && pDeviceName[0] <= L'Z')
    {
        dwDriveNum = pDeviceName[0] - L'A';
    }
    else if (pDeviceName[0] >= L'a' && pDeviceName[0] <= L'z')
    {
        dwDriveNum = pDeviceName[0] - L'a';
    }
    else
    {
        hr = E_INVALIDARG;
        goto Error;
    }


    if ( IsIomegaDrive(dwDriveNum) )
        wcscpy(*ppwszName, L"Iomega");
    else
    {
        wcscpy(*ppwszName, L"Unknown");
        WMDMID snData;
        snData.cbSize = sizeof(WMDMID);
        if ( S_OK==UtilGetSerialNumber(pDeviceName, &snData, FALSE) )
        {
            switch ( snData.dwVendorID )
            {
            case 1:
                wcscpy(*ppwszName, L"SanDisk");
                break;
            case 2:
                wcscpy(*ppwszName, L"Iomega");
                break;
            }
        }
    }
    Error:
    return hr;
}

#include <winioctl.h>

// This is defined in the Whistler platform SDK.
#ifndef IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER
    #define IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER  CTL_CODE( \
        IOCTL_STORAGE_BASE, 0x304, METHOD_BUFFERED, FILE_ANY_ACCESS ) 
#endif

HRESULT GetMSNWithNtIoctl(LPCWSTR wcsDevice, PWMDMID pSN)
{
    HRESULT hr=S_OK;
    HANDLE  hDevice = INVALID_HANDLE_VALUE;
    BOOL    bResult;
    MEDIA_SERIAL_NUMBER_DATA  MSNGetSize;  
    MEDIA_SERIAL_NUMBER_DATA* pMSN = NULL;  // Buffer to hold the serial number
    DWORD   dwBufferSize;                   // Size of pMSNNt buffer
    ULONG       i;
    DWORD   dwRet = 0;                      // Bytes returned

    CARg(pSN);

    DebugMsg("Entering GetMSNWithNtIoctl");

    hDevice = CreateFileW(  wcsDevice, 
                            GENERIC_READ, 
                            FILE_SHARE_READ|FILE_SHARE_WRITE, 
                            NULL,
                            OPEN_EXISTING, 
                            FILE_ATTRIBUTE_NORMAL | 
                            SECURITY_SQOS_PRESENT | SECURITY_ANONYMOUS, 
                            NULL);
    CWRg(hDevice != INVALID_HANDLE_VALUE);

    DebugMsg("GetMSNWithNtIoctl: CreateFile ok");
    
    // Get size of buffer we need to allocate
    bResult = DeviceIoControl(  hDevice, 
                                IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER, 
                                NULL, 
                                0, 
                                (LPVOID)&MSNGetSize, 
                                sizeof(MEDIA_SERIAL_NUMBER_DATA), 
                                &dwRet, 
                                NULL);

    // Handle expected buffer overrun error 
    if ( !bResult )
    {
        hr = HRESULT_FROM_WIN32(GetLastError());

        // Error 'more data is available' is an expected error code
        if ( hr == HRESULT_FROM_WIN32(ERROR_MORE_DATA) )
        {
            hr = S_OK;
        }
        else goto Error;
    }

    DebugMsg("GetMSNWithNtIoctl: DeviceIoControl1 ok");

    if (dwRet < RTL_SIZEOF_THROUGH_FIELD(MEDIA_SERIAL_NUMBER_DATA, SerialNumberLength))
    {
        DebugMsg("GetMSNWithNtIoctl: DeviceIoControl1 dwRet bad: %u, expected >= %u", 
                 dwRet, RTL_SIZEOF_THROUGH_FIELD(MEDIA_SERIAL_NUMBER_DATA, SerialNumberLength));
        hr = E_INVALIDARG;
        goto Error;
    }

    // No serial number?
    if ( MSNGetSize.SerialNumberLength == 0 )
    {
        DebugMsg("GetMSNWithNtIoctl: DeviceIoControl1: MSNGetSize.SerialNumberLength == 0");
        hr = E_FAIL;
        goto Error;
    }
    // The WMDMID structure we are using can only handle 128 bytes long serial numbers
    if ( MSNGetSize.SerialNumberLength  > WMDMID_LENGTH )
    {
        DebugMsg("GetMSNWithNtIoctl: DeviceIoControl1: MSNGetSize.SerialNumberLength > WMDMID_LENGTH");
        hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
        goto Error;
    }

    // Allocate buffer and call to get the serial number
    dwBufferSize = sizeof(MEDIA_SERIAL_NUMBER_DATA) + MSNGetSize.SerialNumberLength;
    pMSN = (MEDIA_SERIAL_NUMBER_DATA*) new BYTE[dwBufferSize];
    if ( pMSN == NULL )
    {
        DebugMsg("GetMSNWithNtIoctl: Out of memory allocating %u bytes", dwBufferSize);
        hr = E_OUTOFMEMORY;
        goto Error;
    }
    bResult = DeviceIoControl(  hDevice, 
                                IOCTL_STORAGE_GET_MEDIA_SERIAL_NUMBER, 
                                NULL, 
                                0, 
                                (LPVOID)pMSN, 
                                dwBufferSize, 
                                &dwRet, 
                                NULL);
    if ( !bResult )
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        DebugMsg("GetMSNWithNtIoctl: DeviceIoControl2 failed, hr = 0x%x", hr);
        goto Error;
    }
    if (dwRet < FIELD_OFFSET(MEDIA_SERIAL_NUMBER_DATA, SerialNumberData) + pMSN->SerialNumberLength)
    {
        hr = E_INVALIDARG;
        DebugMsg("GetMSNWithNtIoctl: DeviceIoControl1: MSNGetSize.SerialNumberLength == 0");
        goto Error;
    }
    if (pMSN->SerialNumberLength > sizeof(pSN->pID))
    {
        hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
        DebugMsg("GetMSNWithNtIoctl: DeviceIoControl2: MSNGetSize.SerialNumberLength > WMDMID_LENGTH");
        goto Error;
    }

    // Copy serial number to out structure
    memcpy( pSN->pID, pMSN->SerialNumberData, pMSN->SerialNumberLength );
    pSN->SerialNumberLength = pMSN->SerialNumberLength;

    // Check result
    pSN->dwVendorID = MDSP_PMID_SANDISK;
    if ( pSN->SerialNumberLength > 24 )
    {
        char szVID[4];
        for ( i=0; i<3; i++ )
        {
            szVID[i]=(pSN->pID[18+i]);
        }
        szVID[i]=0;

        LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
                                        SORT_DEFAULT);

        // if ( !lstrcmpiA(szVID, "ZIP") || 
        //      !lstrcmpiA(szVID, "JAZ") ||
        //      !lstrcmpiA(szVID, "CLI") )
        if (CompareStringA(lcid, NORM_IGNORECASE, szVID, -1, "ZIP", -1) == CSTR_EQUAL ||
            CompareStringA(lcid, NORM_IGNORECASE, szVID, -1, "JAZ", -1) == CSTR_EQUAL ||
            CompareStringA(lcid, NORM_IGNORECASE, szVID, -1, "CLI", -1) == CSTR_EQUAL)
        {
            pSN->dwVendorID = MDSP_PMID_IOMEGA;
        }
    }


    if ( (pSN->dwVendorID==MDSP_PMID_IOMEGA) && (pSN->SerialNumberLength>19) )
    {
        pSN->SerialNumberLength = 19;
        pSN->pID[18] = 0;
    }
    DebugMsg("GetMSNWithNtIoctl ok, pSN->SerialNumberLength = %u", pSN->SerialNumberLength);

    Error:
    if ( hDevice != INVALID_HANDLE_VALUE )   CloseHandle(hDevice);
    if ( pMSN )      delete [] pMSN;
    return hr;
}


HRESULT GetMSNWith9xIoctl(char chDriveLetter, PWMDMID pSN, DWORD dwCode, DWORD dwIOCTL )
{
    HRESULT hr=S_OK;
    HANDLE  hDevice=INVALID_HANDLE_VALUE;
    BOOL    bResult;
    MEDIA_SERIAL_NUMBER_DATA  MSNGetSize;  
    MEDIA_SERIAL_NUMBER_DATA* pMSN = NULL;  // Buffer to hold the serial number
    ULONG  uBufferSize;                     // Size of pMSN
    DWORD   dwRet = 0;                      // Bytes returned

//    _ASSERT( dwCode == 0x440D || 
//             dwCode == 0x4404 );
//    _ASSERT( (dwIOCTL == (0x0800 | 0x75)) || 
//             (dwIOCTL == WIN9X_IOCTL_GET_MEDIA_SERIAL_NUMBER) );
    CARg(pSN);

    hDevice = CreateFile("\\\\.\\VWIN32",0,0,NULL,OPEN_EXISTING,FILE_FLAG_DELETE_ON_CLOSE,0);

    CFRg(hDevice != INVALID_HANDLE_VALUE);  

    DIOC_REGISTERS  reg;
    DWORD       cb;
    WORD        drv;

    drv = (chDriveLetter >= 'a' ) ? (chDriveLetter-'a') : (chDriveLetter-'A');

    // Call first to get serial number size
    {
        MSNGetSize.SerialNumberLength = 0;
        reg.reg_EAX = dwCode;       //create the ioctl
        reg.reg_EBX = drv;
        reg.reg_EBX++;
        reg.reg_ECX = dwIOCTL;  // BUGBUG, needs definition of 0x75

        //
        // ISSUE: The following code will not work on 64-bit systems.
        //        The conditional is only to get the code to compiler.
        //

#if defined(_WIN64)
        reg.reg_EDX = (DWORD)(DWORD_PTR)&MSNGetSize;
#else
        reg.reg_EDX = (DWORD)&MSNGetSize;
#endif
        reg.reg_Flags = 0x0001;

        bResult = DeviceIoControl(  hDevice, 
                                    VWIN32_DIOC_DOS_IOCTL,
                                    &reg,
                                    sizeof(DIOC_REGISTERS),
                                    &reg,
                                    sizeof(DIOC_REGISTERS),
                                    &cb,
                                    NULL );

        // Check for errors
        if ( bResult && !(reg.reg_Flags&0x0001) )
        {
            if ( (MSNGetSize.Result != ERROR_SUCCESS) && 
                 (MSNGetSize.Result != ERROR_MORE_DATA ) )
            {
                hr = HRESULT_FROM_WIN32(MSNGetSize.Result);
                goto Error;
            }
        }

        // No serial number?
        if ( MSNGetSize.SerialNumberLength == 0 )
        {
            hr = E_FAIL;
            goto Error;
        }

        // Max serial number size is 128 byte right now
        if ( MSNGetSize.SerialNumberLength > WMDMID_LENGTH )
        {
            hr = E_FAIL;
            goto Error;
        }

        // Allocate buffer to get serial number
        uBufferSize = MSNGetSize.SerialNumberLength + sizeof(MEDIA_SERIAL_NUMBER_DATA);
        pMSN = (MEDIA_SERIAL_NUMBER_DATA*) new BYTE[uBufferSize];
        if ( pMSN == NULL )
        {
            hr = E_OUTOFMEMORY;
            goto Error;
        }
    }


    // Call again to accually get the serial number
    {
        pMSN->SerialNumberLength = uBufferSize;
        reg.reg_EAX = dwCode;       //create the ioctl
        reg.reg_EBX = drv;
        reg.reg_EBX++;
        reg.reg_ECX = dwIOCTL; // BUGBUG, needs definition of 0x75

        //
        // ISSUE: The following code will not work on 64-bit systems.
        //        The conditional is only to get the code to compiler.
        //

#if defined(_WIN64)
        reg.reg_EDX = (DWORD)0;
#else
        reg.reg_EDX = (DWORD)pMSN;
#endif
        reg.reg_Flags = 0x0001;

        bResult = DeviceIoControl(  hDevice, 
                                    VWIN32_DIOC_DOS_IOCTL,
                                    &reg,
                                    sizeof(DIOC_REGISTERS),
                                    &reg,
                                    sizeof(DIOC_REGISTERS),
                                    &cb,
                                    NULL );

        // Check for errors
        if ( bResult && !(reg.reg_Flags&0x0001) )
        {
            if ( (pMSN->Result != ERROR_SUCCESS) )
            {
                hr = HRESULT_FROM_WIN32(pMSN->Result);
                goto Error;
            }
        }
    }

    // Copy serial number to out structure 
    // and 'figure out' vendor
    {
        memcpy( pSN->pID, pMSN->SerialNumberData, pMSN->SerialNumberLength );
        pSN->SerialNumberLength = pMSN->SerialNumberLength;

        pSN->dwVendorID = MDSP_PMID_SANDISK;
        if ( pSN->SerialNumberLength > 24 )
        {
            char   szVID[4];
            ULONG   i;

            for ( i=0; i<3; i++ )
            {
                szVID[i]=(pSN->pID[18+i]);
            }
            szVID[i]=0;
            LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
                                            SORT_DEFAULT);

            // if ( !lstrcmpiA(szVID, "ZIP") || 
            //      !lstrcmpiA(szVID, "JAZ") ||
            //      !lstrcmpiA(szVID, "CLI") )
            if (CompareStringA(lcid, NORM_IGNORECASE, szVID, -1, "ZIP", -1) == CSTR_EQUAL ||
                CompareStringA(lcid, NORM_IGNORECASE, szVID, -1, "JAZ", -1) == CSTR_EQUAL ||
                CompareStringA(lcid, NORM_IGNORECASE, szVID, -1, "CLI", -1) == CSTR_EQUAL)
            {
                pSN->dwVendorID = MDSP_PMID_IOMEGA;
            }
        }

        if ( (pSN->dwVendorID==MDSP_PMID_IOMEGA) && (pSN->SerialNumberLength>19) )
        {
            pSN->SerialNumberLength = 19;
            pSN->pID[18] = 0;
        }
    }

    Error:
    if ( hDevice != INVALID_HANDLE_VALUE )   CloseHandle(hDevice);
    if ( pMSN )      delete [] pMSN;
    return hr;
}

HRESULT GetDeviceSNwithNTScsiPassThrough(LPCWSTR wszDevice, PWMDMID pSN)
{
    HRESULT hr=S_OK;
    HANDLE  fileHandle=INVALID_HANDLE_VALUE;
    UCHAR   buffer[2048];
    BOOL    status;
    ULONG   returned, length, i, bufOffset;
    SCSI_PASS_THROUGH_WITH_BUFFERS sptwb;
    PSCSI_ADAPTER_BUS_INFO  adapterInfo;
    PSCSI_INQUIRY_DATA inquiryData;

    DebugMsg("Entering GetDeviceSNwithNTScsiPassThrough");

    ZeroMemory(pSN, sizeof(WMDMID));
    fileHandle = CreateFileW(wszDevice,
                             GENERIC_WRITE | GENERIC_READ,
                             FILE_SHARE_READ | FILE_SHARE_WRITE,
                             NULL,
                             OPEN_EXISTING,
                             SECURITY_SQOS_PRESENT | SECURITY_ANONYMOUS,
                             NULL);

    CWRg(fileHandle != INVALID_HANDLE_VALUE);

    DebugMsg("GetDeviceSNwithNTScsiPassThrough: CreateFile ok");

    status = DeviceIoControl(fileHandle,
                             IOCTL_SCSI_GET_INQUIRY_DATA,
                             NULL,
                             0,
                             buffer,
                             sizeof(buffer),
                             &returned,
                             FALSE);
    // CWRg(status);
    // We use IOCTL_SCSI_GET_INQUIRY_DATA to get the disk's SCSI address, if 
    // this fails, it is not on a SCSI bus so the SCSI address will be all zeros
    if ( status )
    {
        DebugMsg("GetDeviceSNwithNTScsiPassThrough: DeviceIoControl1 ok");

        if (returned < sizeof(SCSI_ADAPTER_BUS_INFO))
        {
            DebugMsg("GetDeviceSNwithNTScsiPassThrough: DeviceIoControl1 returned = %u < sizeof(SCSI_ADAPTER_BUS_INFO) = %u",
                     returned, sizeof(SCSI_ADAPTER_BUS_INFO));
            hr = E_INVALIDARG;
            goto Error;
        }
        adapterInfo = (PSCSI_ADAPTER_BUS_INFO) buffer;
        CFRg(adapterInfo->NumberOfBuses>0);
        if (returned < adapterInfo->BusData[0].InquiryDataOffset + sizeof(SCSI_INQUIRY_DATA))
        {
            hr = E_INVALIDARG;
            DebugMsg("GetDeviceSNwithNTScsiPassThrough: DeviceIoControl1 returned = %u < adapterInfo->BusData[0].InquiryDataOffset (%u) + sizeof(SCSI_INQUIRY_DATA) (%u)",
                     returned, adapterInfo->BusData[0].InquiryDataOffset, sizeof(SCSI_INQUIRY_DATA));
            goto Error;
        }
        inquiryData = (PSCSI_INQUIRY_DATA) (buffer +
                                            adapterInfo->BusData[0].InquiryDataOffset); // we know card readers has only one bus
    }

    ZeroMemory(&sptwb,sizeof(sptwb));

    sptwb.spt.Length = sizeof(SCSI_PASS_THROUGH);
    sptwb.spt.PathId = (status?inquiryData->PathId:0);
    sptwb.spt.TargetId = (status?inquiryData->TargetId:0);
    sptwb.spt.Lun = (status?inquiryData->Lun:0);
    sptwb.spt.CdbLength = CDB6GENERIC_LENGTH;
    sptwb.spt.SenseInfoLength = 24;
    sptwb.spt.DataIn = SCSI_IOCTL_DATA_IN;
    sptwb.spt.DataTransferLength = 256 /*256*/;
    sptwb.spt.TimeOutValue = 2;
    sptwb.spt.DataBufferOffset =
    offsetof(SCSI_PASS_THROUGH_WITH_BUFFERS,ucDataBuf);
    sptwb.spt.SenseInfoOffset = 
    offsetof(SCSI_PASS_THROUGH_WITH_BUFFERS,ucSenseBuf);
    sptwb.spt.Cdb[0] = 0x12     /* Command - SCSIOP_INQUIRY */;
    sptwb.spt.Cdb[1] = 0x01;    /* Request - VitalProductData */
    sptwb.spt.Cdb[2] = 0x80     /* VPD page 80 - serial number page */;
    sptwb.spt.Cdb[3] = 0;
    sptwb.spt.Cdb[4] = 0xff     /*255*/;
    sptwb.spt.Cdb[5] = 0;

    length = offsetof(SCSI_PASS_THROUGH_WITH_BUFFERS,ucDataBuf) +
             sptwb.spt.DataTransferLength;

    status = DeviceIoControl(fileHandle,
                             IOCTL_SCSI_PASS_THROUGH,
                             &sptwb,
                             sizeof(SCSI_PASS_THROUGH),
                             &sptwb,
                             length,
                             &returned,
                             FALSE); 
    CWRg(status);

    // CFRg(sptwb.ucDataBuf[3]>0);

    // Keep or remove this @@@@
    if (returned < offsetof(SCSI_PASS_THROUGH_WITH_BUFFERS,ucDataBuf) + 4)
    {
        hr = E_INVALIDARG;
        DebugMsg("GetDeviceSNwithNTScsiPassThrough: DeviceIoControl2 returned = %u < offsetof(SCSI_PASS_THROUGH_WITH_BUFFERS,ucDataBuf) + 4 = %u",
                    returned, offsetof(SCSI_PASS_THROUGH_WITH_BUFFERS,ucDataBuf) + 4);
        goto Error;
    }

    // Here there is a difference between Parallel and USB Unit:
    // Since the Parallel Unit is an emulation of SCSI disk, it doesn't follow SCSI spec.
    pSN->SerialNumberLength=0;
    pSN->dwVendorID=0;
    if ( sptwb.ucDataBuf[3] == 0 ) // this is the SanDisk USB device
    {
        pSN->SerialNumberLength = 20;
        // Keep or remove this @@@@
        if (returned < offsetof(SCSI_PASS_THROUGH_WITH_BUFFERS,ucDataBuf) + 5)
        {
            hr = E_INVALIDARG;
            DebugMsg("GetDeviceSNwithNTScsiPassThrough: DeviceIoControl2 returned = %u < offsetof(SCSI_PASS_THROUGH_WITH_BUFFERS,ucDataBuf) + 5 = %u",
                        returned, offsetof(SCSI_PASS_THROUGH_WITH_BUFFERS,ucDataBuf) + 5);
            goto Error;
        }
        if ( sptwb.ucDataBuf[4] > 0 )
        {
            if ((DWORD) (sptwb.ucDataBuf[4]) + 5 >= (DWORD) (pSN->SerialNumberLength))
            {
                bufOffset=(sptwb.ucDataBuf[4]+5)-(pSN->SerialNumberLength);
            }
            else
            {
                hr = E_INVALIDARG;
                goto Error;
            }
        }
        else
        {  // There are 50K ImageMate III devices that read like this
            bufOffset=36;
        }
    }
    else if ( sptwb.ucDataBuf[3] > 0 )
    {
        pSN->SerialNumberLength = sptwb.ucDataBuf[3];
        bufOffset=4;
    }

    DebugMsg("GetDeviceSNwithNTScsiPassThrough: DeviceIoControl2 pSN->SerialNumberLength = %u",
             pSN->SerialNumberLength);
    // The WMDMID structure we are using can only handle 128 bytes long serial numbers
    if ( pSN->SerialNumberLength > WMDMID_LENGTH )
    {
        hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
        DebugMsg("GetDeviceSNwithNTScsiPassThrough: DeviceIoControl2 pSN->SerialNumberLength > WMDMID_LENGTH = %u", WMDMID_LENGTH);
        goto Error;
    }

    // Keep or remove this @@@@
    if (returned < offsetof(SCSI_PASS_THROUGH_WITH_BUFFERS,ucDataBuf) + bufOffset + pSN->SerialNumberLength)
    {
        hr = E_INVALIDARG;
        DebugMsg("GetDeviceSNwithNTScsiPassThrough: DeviceIoControl2 returned = %u < offsetof(SCSI_PASS_THROUGH_WITH_BUFFERS,ucDataBuf) (=%u) + bufOffset (=%u) + pSN->SerialNumberLength) (=%u) = %u",
                    returned, offsetof(SCSI_PASS_THROUGH_WITH_BUFFERS,ucDataBuf), bufOffset, pSN->SerialNumberLength,
                    offsetof(SCSI_PASS_THROUGH_WITH_BUFFERS,ucDataBuf) + bufOffset + pSN->SerialNumberLength);
        goto Error;
    }

    for ( i=0; i<pSN->SerialNumberLength; i++ )
    {
        pSN->pID[i] = sptwb.ucDataBuf[bufOffset+i];
        if ( !(pSN->dwVendorID) && pSN->pID[i] && pSN->pID[i] != 0x20 )
            pSN->dwVendorID = MDSP_PMID_SANDISK;
    }

    if ( !(pSN->dwVendorID) )
        hr=S_FALSE;
    else
        hr=S_OK;

    Error:
    if ( fileHandle != INVALID_HANDLE_VALUE )
        CloseHandle(fileHandle);
    DebugMsg("GetDeviceSNwithNTScsiPassThrough: returning hr = 0x%x", hr);
    return hr;
}


HRESULT GetMediaSerialNumberFromNTService(DWORD dwDN, PWMDMID pSN)
{
    HANDLE      hPipe = INVALID_HANDLE_VALUE; 
    BYTE        ubBuf[256]; 
    BOOL        fSuccess; 
    DWORD       cbRead, cbWritten; 
    WCHAR       wszPipename[64] = L"\\\\.\\pipe\\WMDMPMSPpipe"; 
    DWORD       dwErr;
    PMEDIA_SERIAL_NUMBER_DATA pMSN;
    HRESULT     hr;
    BOOL        bStarted = 0;

    if (dwDN >= 26)
    {
        _ASSERTE(dwDN < 26);
        hr = E_INVALIDARG;
        goto ErrorExit;
    }

    // Try to open a named pipe; wait for it, if necessary.   	
    for ( DWORD dwTriesLeft = 3; dwTriesLeft; dwTriesLeft -- )
    {
        // Set the impersonation level to the lowest one that works.
        // The real server impersonates us to validate the drive type.
        // SECURITY_ANONYMOUS is enough for this as long as the drive
        // specified is of the form x: (i.e., is not an ms-dos device name
        // in the DosDevices directory)
        hPipe = CreateFileW(
                          wszPipename, 
                          GENERIC_READ |GENERIC_WRITE, 
                          0, 
                          NULL, 
                          OPEN_EXISTING, 
                          SECURITY_SQOS_PRESENT | SECURITY_ANONYMOUS,
                          NULL
                          );   

        // Break if the pipe handle is valid. 
        if ( hPipe != INVALID_HANDLE_VALUE )
        {
            // Success 
            fSuccess=TRUE;
            break; 
        }

        // If all pipe instances are busy or if server has not yet created
        // the first instance of the named pipe, wait for a while and retry.
        // Else, exit.
        dwErr=GetLastError();
        DebugMsg("GetMediaSerialNumberFromNTService(): CreateFile on drive %u failed, last err = %u, Tries left = %u, bStarted = %d",
                 dwDN, dwErr, dwTriesLeft, bStarted);
        if ( dwErr != ERROR_PIPE_BUSY && dwErr != ERROR_FILE_NOT_FOUND)
        {
            fSuccess=FALSE;
            break;
        }
        if (dwErr == ERROR_FILE_NOT_FOUND && !bStarted)
        {
            dwTriesLeft++;      // Don't count this iteration
            bStarted = 1;

            // We start the service here because the service now
            // times out sfter a period of inactivity.
            // We ignore errors. If the start fails, we'll
            // timeout anyway. (If we did respond to errors, note
            // that the service may already be running and that 
            // shuld not be considered an error.)
            UtilStartStopService(TRUE);

            // Wait for service to start
            for (DWORD i = 2; i > 0; i--)
            {
                Sleep(1000);
                if (WaitNamedPipeW(wszPipename, 0))
                {
                    // Service is up and running and a pipe instance
                    // is available
                    break;
                }
                else
                {
                    // Either the service has not yet started or no
                    // pipe instance is available. Just keep going.
                }
            }

            // Even if the wait for the named pipe failed,
            // go on. We'll try once more below and bail out.
        }

        // All pipe instances are busy (or the service is starting), 
        // so wait for 1 second. 
        // Note: Do not use NMPWAIT_USE_DEFAULT_WAIT since the
        // server of this named pipe may be spoofing our server
        // and may have the set the default very high.
        if ( ! WaitNamedPipeW(wszPipename, 1000) )
        {
            fSuccess=FALSE;
            break;
        }
    } // end of for loop 

    if ( !fSuccess )
    {
        hr=HRESULT_FROM_WIN32(ERROR_CANTOPEN);
        goto ErrorExit;
    }


    ZeroMemory(ubBuf, sizeof(ubBuf));
    pMSN = (PMEDIA_SERIAL_NUMBER_DATA)ubBuf;
    // pMSN->SerialNumberLength = 128;
    pMSN->Reserved[1] = dwDN;

    DWORD cbTotalWritten = 0;

    do
    {
        fSuccess = WriteFile(
                        hPipe,                  // pipe handle 
                        ubBuf + cbTotalWritten, // message 
                        sizeof(*pMSN)- cbTotalWritten, // +128, // message length 
                        &cbWritten,             // bytes written 
                        NULL                    // not overlapped 
                        );                  

        if ( !fSuccess) // || cbWritten != sizeof(*pMSN))
        {
            hr=HRESULT_FROM_WIN32(ERROR_CANTWRITE); 
            goto ErrorExit;
        }
        cbTotalWritten += cbWritten;
        _ASSERTE(cbTotalWritten <= sizeof(*pMSN));
    }
    while (cbTotalWritten < sizeof(*pMSN));

    DWORD cbTotalRead = 0;
    DWORD cbTotalToRead;
    do 
    {
        // Read from the pipe. 
        fSuccess = ReadFile(
                           hPipe,      // pipe handle 
                           ubBuf + cbTotalRead, // buffer to receive reply 
                           sizeof(ubBuf) - cbTotalRead, // size of buffer 
                           &cbRead,    // number of bytes read 
                           NULL        // not overlapped 
                           );    

        // This is a byte mode pipe, not a message mode one, so we 
        // do not expect ERROR_MORE_DATA. Anyway, let this be as is.
        if ( !fSuccess && (dwErr=GetLastError()) != ERROR_MORE_DATA )
        {
            break; 
        }
        cbTotalRead += cbRead;
        _ASSERTE(cbTotalRead <= sizeof(ubBuf));

        // We expect at least FIELD_OFFSET(MEDIA_SERIAL_NUMBER_DATA, SerialNumberData)
        // bytes in the response
        cbTotalToRead = FIELD_OFFSET(MEDIA_SERIAL_NUMBER_DATA, SerialNumberData);
        if (cbTotalRead >= cbTotalToRead)
        {
            pMSN = (PMEDIA_SERIAL_NUMBER_DATA)ubBuf;
            if ( ERROR_SUCCESS == pMSN->Result )
            {
                cbTotalToRead += pMSN->SerialNumberLength;
            }
            else
            {
                cbTotalToRead = sizeof(MEDIA_SERIAL_NUMBER_DATA);
            }
            // Server should write exactly cbTotalToRead bytes.
            // We should not have read any more because
            // we wrote only 1 request. (If we write >1 request, we may 
            // get responses to both request.) 
            _ASSERTE(cbTotalRead <= cbTotalToRead);

            if (cbTotalToRead > sizeof(ubBuf))
            {
                // We don't expect this. Server bad?
                fSuccess = FALSE;
                break;
            }
        }
        else
        {
            // cbTotalToRead does not have to be changed
        }

    } while ( !fSuccess || cbTotalRead < cbTotalToRead);  // repeat loop if ERROR_MORE_DATA 

    if ( fSuccess )
    {
        pMSN = (PMEDIA_SERIAL_NUMBER_DATA)ubBuf;

        if ( ERROR_SUCCESS == pMSN->Result &&
             pMSN->SerialNumberLength <= sizeof(pSN->pID))
        {
            CopyMemory(pSN->pID, pMSN->SerialNumberData, pMSN->SerialNumberLength);
            pSN->SerialNumberLength = pMSN->SerialNumberLength;
            pSN->dwVendorID = pMSN->Reserved[1];
            pSN->cbSize = sizeof(*pSN);
            hr=S_OK;
        }
        else if (pMSN->Result != ERROR_SUCCESS)
        {
            hr = HRESULT_FROM_WIN32(pMSN->Result);
        }
        else
        {
            hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
        }
    }
    else
    {
        hr=HRESULT_FROM_WIN32(ERROR_CANTREAD);
    }

    ErrorExit:

    if ( hPipe != INVALID_HANDLE_VALUE )
        CloseHandle(hPipe);

    return hr;
}


HRESULT UtilGetHardSN(WCHAR *wcsDeviceName, DWORD dwDriveNum, PWMDMID pSN)
{
    HRESULT hr=S_OK;
    ULONG i;

    DebugMsg("Entering UtilGetHardSN, drivenum %u", dwDriveNum);
    CARg(pSN);

    DWORD dwLastError;

    if ( IsAdministrator(dwLastError) )
    {
        // Convert device name to an ascii char - done only on Win9x
        char szTmp[MAX_PATH];
        *szTmp = 0;

        // Following only for NT. If we have a DOS device name, use it.
        // Else, open the drive letter.
        WCHAR  wcsDriveName[] = L"\\\\.\\?:";
        
        if (dwDriveNum >= 26)
        {
            _ASSERTE(dwDriveNum < 26);
            hr = E_INVALIDARG;
            goto Error;
        }
        LPCWSTR wcsDeviceToOpen = wcsDriveName;
        wcsDriveName[4] = (WCHAR) (dwDriveNum + L'A');

        // Try IOCTL calls 
        if ( IsWinNT() )
        {
            // NT, try IOCTL_GET_MEDIA_SERIAL_NUMBER method first
            hr = GetMSNWithNtIoctl(wcsDeviceToOpen, pSN);
        }
        else
        {
            if ( WideCharToMultiByte(CP_ACP, NULL, wcsDeviceName, -1, szTmp, sizeof(szTmp), NULL, NULL) == 0 )
            {
                hr = E_INVALIDARG;
                goto Error;
            }
            // Try two other IOCTL calls on Win9x
            hr = GetMSNWith9xIoctl( szTmp[0], pSN, 0x440D, (0x0800 | 0x75) );
            if ( FAILED(hr) )
            {
                hr = GetMSNWith9xIoctl( szTmp[0], pSN, 0x4404, WIN9X_IOCTL_GET_MEDIA_SERIAL_NUMBER );
            }
        }

        // Try Iomega
        if ( FAILED(hr) )
        {
            if ( IsIomegaDrive(dwDriveNum) )
            {
                if ( GetIomegaDiskSerialNumber(dwDriveNum, pSN) )
                {
                    hr=S_OK;
                }
                else
                {
                    hr = E_FAIL;
                    goto Error;
                }
            }
        }

        // Try new SCSI_PASS_THROUGH "Get Media Serial Number" command
        if ( FAILED(hr) )
        {
            if ( IsWinNT() )
            {
                // This was pulled because it was not standardized.
                // hr = GetMediaSNwithNTScsiPassThrough(szTmp, pSN);
            }
            else
            {
                // @@@@ Remove this as well?
                Aspi32Util  a32u;
                if ( a32u.DoSCSIPassThrough(szTmp, pSN, TRUE ) )
                {
                    hr=S_OK;
                }
                else
                {
                    hr = E_FAIL;
                }
            }
        }

        // Last chance, try old 'bad' 
        // SCSI_PASS_THROUGH "Get Device Serial Number" command
        if ( FAILED(hr) )
        {

//            // We are using the DEVICE serial number as a MEDIA serial number.
//            // This violates the SCSI spec. We are only keeping this functionality 
//            // for the devices we know that needs it.
//            if( CheckForKBDevice( szTmp[0] ) == FALSE )
//            {
//                hr = E_FAIL;
//                goto Error;
//            }

            if ( IsWinNT() )
            {
                CHRg(GetDeviceSNwithNTScsiPassThrough(wcsDeviceToOpen, pSN));
            }
            else
            {
                Aspi32Util  a32u;
                CFRg( a32u.DoSCSIPassThrough(szTmp, pSN, FALSE ) );
            }
        }
    }
    else if (dwLastError != ERROR_SUCCESS)
    {
        hr = HRESULT_FROM_WIN32(dwLastError);
        goto Error;
    }
    else // If on NT and nonAdmin, try use PMSP Service
    {
        hr = GetMediaSerialNumberFromNTService(dwDriveNum, pSN);
        if (FAILED(hr))
        {
            goto Error;
        }
    }

    // put sanity check here
    hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
    for ( i=0; i<(pSN->SerialNumberLength); i++ )
    {
        if ( pSN->pID[i] && pSN->pID[i] != 0x20 )
        {
            hr = S_OK;
            break;
        }
    }
    Error:
    DebugMsg("Leaving UtilGetHardSN, hr = 0x%x");
    return hr;
}

// fCreate is an unused parameter. Ir was used in an obsolete code path that 
// has been deleted
HRESULT __stdcall UtilGetSerialNumber(WCHAR *wcsDeviceName, PWMDMID pSerialNumber, BOOL fCreate)
{
    HRESULT hr = E_FAIL;

    DebugMsg("Entering UtilGetSerialNumber");

    if (!pSerialNumber || !wcsDeviceName)
    {
        return E_INVALIDARG;
    }

    DWORD dwDriveNum;

    // We use only the first char of pDeviceName and expect it to 
    // be a drive letter. The rest of pDeviceName is not validated.
    // Perhaps it should, but we don't want to break our clients.
    if (wcsDeviceName[0] >= L'A' && wcsDeviceName[0] <= L'Z')
    {
        dwDriveNum = wcsDeviceName[0] - L'A';
    }
    else if (wcsDeviceName[0] >= L'a' && wcsDeviceName[0] <= L'z')
    {
        dwDriveNum = wcsDeviceName[0] - L'a';
    }
    else
    {
        hr = E_INVALIDARG;
        goto Error;
    }

    pSerialNumber->cbSize = sizeof(WMDMID);
    hr = UtilGetHardSN(wcsDeviceName, dwDriveNum, pSerialNumber);

    if ( FAILED( hr ) )
    {
        if ( hr != HRESULT_FROM_WIN32(ERROR_INVALID_DATA) )
        {
            pSerialNumber->SerialNumberLength = 0;
            pSerialNumber->dwVendorID = 0;
            ZeroMemory(pSerialNumber->pID, sizeof(pSerialNumber->pID));
            hr = HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
        }
        // hr = S_FALSE;
    }

Error:
    DebugMsg("Leaving UtilGetSerialNumber, hr = 0x%x", hr);
    return hr;
}

HRESULT __stdcall UtilStartStopService(bool fStartService)
{
    HRESULT hr = S_OK;
    SERVICE_STATUS    ServiceStatus;

    DWORD dwLastError;

    if ( IsAdministrator(dwLastError) )
    {
        //  
        // We are on Win 9x machine or NT machine with admin previleges. In
        // either case, we don't want to run the service.
        //  
        DebugMsg("UtilStartStopService(): fStartService = %d, returning S_OK (IsAdmin returned TRUE)",
                fStartService);
        return S_OK;
    }
    else
    {
        // We ignore dwLastError
    }

    // open the service control manager
    SC_HANDLE hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
    SC_HANDLE hService = NULL;

    if ( !hSCM )
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        DebugMsg("UtilStartStopService(): fStartService = %d, OpenSCManager failed, last err (as hr) = 0x%x",
                fStartService, hr);
        goto Error;
    }

    // open the service
    hService = OpenService(hSCM,
                           "WmdmPmSp",
                           (fStartService? SERVICE_START : SERVICE_STOP) | SERVICE_QUERY_STATUS);

    if ( !hService )
    {
        hr = HRESULT_FROM_WIN32(GetLastError());
        DebugMsg("UtilStartStopService(): fStartService = %d, OpenService failed, last err (as hr) = 0x%x",
                fStartService, hr);
        goto Error;
    }

    if ( !QueryServiceStatus( hService, &ServiceStatus ) )
    {

        hr = HRESULT_FROM_WIN32(GetLastError());
        DebugMsg("UtilStartStopService(): fStartService = %d, QueryServiceStatus failed, last err (as hr) = 0x%x",
                fStartService, hr);
        goto Error;
    }

    if ( fStartService && ServiceStatus.dwCurrentState != SERVICE_RUNNING)
    {
        // start the service
        if(!StartService(hService, 0, NULL) )
        {
            hr = HRESULT_FROM_WIN32(GetLastError());
            DebugMsg("UtilStartStopService(): fStartService = %d, StartService failed, last err (as hr) = 0x%x",
                    fStartService, hr);
            goto Error;
        }     
    }

    if(!fStartService && ServiceStatus.dwCurrentState != SERVICE_STOP)
    {
        // stop the service.
        if(!ControlService(hService, SERVICE_CONTROL_STOP, &ServiceStatus))
        {
            hr = HRESULT_FROM_WIN32(GetLastError());
            DebugMsg("UtilStartStopService(): fStartService = %d, ControlService failed, last err (as hr) = 0x%x",
                    fStartService, hr);
            goto Error;            
        }
    }

Error:
    if ( hService )
    { 
        CloseServiceHandle(hService);
    }
    if ( hSCM )
    {
        CloseServiceHandle(hSCM);
    }
    DebugMsg("UtilStartStopService(): fStartService = %d, returning hr = 0x%x",
             fStartService, hr);

    return hr;
}