.#loader_win32.cpp.1.40

这是DVD中伺服部分的核心代码

                                    NULL,             
                                    &cdromDiskData,                       
                                    sizeof(cdromDiskData),                              
                                    &outputByteCount,               // output byte count
                                    NULL);                          // overlapped structure for async operations



    if (win32Result != 0x00)
    {
        pLoaderData->trayStatus = LOADER_TRAY_CLOSED;
        pMediaData->bNumLayers = 1;

        if ( cdromDiskData.DiskData & CDROM_DISK_AUDIO_TRACK ) 
        {
            pMediaData->eMediaType = LOADER_MEDIA_TYPE_CD_ROM;
            return ( LOADER_SUCCESS );
        }

        if ( cdromDiskData.DiskData & CDROM_DISK_DATA_TRACK ) 
        {
            #if DETECT_CDROM_XA_AS_BDROM
                pMediaData->eMediaType = LOADER_MEDIA_TYPE_BD_ROM;
            #else
                pMediaData->eMediaType = LOADER_MEDIA_TYPE_CD_ROM;
            #endif

            return ( LOADER_SUCCESS );
        }
    }


    pMediaData->eMediaType = LOADER_MEDIA_TYPE_NODISK;

    return ( LOADER_SUCCESS );
}






/**
 *******************************************************************************
 *  LoaderReadCopyrightType
 *
 *  @brief      Read DVD Copyright Type
 *
 *  @param      loaderHandle    Loader handle.
 *  @param      pbType          Copyright type will be returned through this pointer.
 *
 *  @return     Loader error
 *******************************************************************************/
LOADER_ERR LoaderReadCopyrightType(LOADER_HANDLE loaderHandle, LOADER_COPYRIGHT_TYPE* pbType)
{
    LoaderData*                 pLoaderData;
    BOOL                        win32Result;
    DWORD                       outputByteCount;
    BYTE                        copyProtectionDescriptorBuffer[sizeof(DVD_COPYRIGHT_DESCRIPTOR) + sizeof(DVD_DESCRIPTOR_HEADER)];
    DVD_COPYRIGHT_DESCRIPTOR*   pDvdCopyrightDescriptor = NULL;
    DVD_READ_STRUCTURE          dvdReadStructure;

    DBGPRINT(DEBUG_ON(DEBUG_TRACE), ("LoaderReadCopyrightType\n"));

    LOADER_ASSERT_ERROR( (pbType==NULL),  LOADER_INVALID_PARAMETER );

    LOADER_RAISE_ERROR( LoaderValidateHandle( loaderHandle ));
    pLoaderData = (LoaderData*) loaderHandle;
    AutoMutex(&pLoaderData->mutex);

    *pbType = LOADER_COPYRIGHT_TYPE_NONE;

    LOADER_ASSERT_ERROR( (pLoaderData->deviceHandle==INVALID_HANDLE_VALUE), LOADER_FAILURE );

    memset(&dvdReadStructure, 0, sizeof(dvdReadStructure));
    dvdReadStructure.Format = DvdCopyrightDescriptor;

    win32Result = DeviceIoControl(  pLoaderData->deviceHandle,             // device handle
                                    IOCTL_DVD_READ_STRUCTURE,       // operation
                                    &dvdReadStructure,                       
                                    sizeof(dvdReadStructure),             
                                    &copyProtectionDescriptorBuffer,                       
                                    sizeof(copyProtectionDescriptorBuffer),                              
                                    &outputByteCount,               // output byte count
                                    NULL);                          // overlapped structure for async operations

    LOADER_ASSERT_ERROR( (win32Result==0), LOADER_FAILURE );

    pDvdCopyrightDescriptor = (DVD_COPYRIGHT_DESCRIPTOR *) &(copyProtectionDescriptorBuffer[sizeof(DVD_DESCRIPTOR_HEADER)]);
    if ( pDvdCopyrightDescriptor->CopyrightProtectionType == 1)
    {
        *pbType = LOADER_COPYRIGHT_TYPE_CSS;
    }

    return ( LOADER_SUCCESS );
}







/**
 *******************************************************************************
 *  LoaderReadHDDVDCopyrightType
 *
 *  @brief      Read HD-DVD Copyright Type
 *
 *  @param      loaderHandle    Loader handle.
 *  @param      pbType          HDDVD copyright type will be returned through this pointer.
 *
 *  @return     Loader error
 *******************************************************************************/
LOADER_ERR LoaderReadHDDVDCopyrightType(LOADER_HANDLE loaderHandle, LOADER_COPYRIGHT_TYPE *pbType)
{
    BYTE bExists = 0;

    /* Validate incoming parameters */
    LOADER_ASSERT_ERROR( (pbType==NULL),  LOADER_INVALID_PARAMETER );
    LOADER_RAISE_ERROR( LoaderValidateHandle( loaderHandle ));

    /* Initialize the encryption type */
    *pbType = LOADER_COPYRIGHT_TYPE_NONE;

    /* Check for the "AACS" directory on the current disc */
    if (LoaderFileAccess(loaderHandle, "/mnt/cdrom/AACS/", LOADER_FILE_ACCESS_EXIST, &bExists) != LOADER_SUCCESS)
    {
        DBGPRINT(DEBUG_ON(DBG_ERROR), ("*** ERROR: %s() - line %d\n", __FUNCTION__, __LINE__));
        bExists = 0;
    }
    else if (bExists == 1)
    {
        DBGPRINT(DEBUG_ON(DBG_ERROR), ("%s() - Detected AACS encryption\n", __FUNCTION__));
        *pbType = LOADER_COPYRIGHT_TYPE_AACS;
    }

    /* Return successfully */
    return ( LOADER_SUCCESS );
}






/**
 *******************************************************************************
 *  LoaderSectorRead
 *
 *  @brief      Reads a specific number of blocks from the storage media at the specified sector.
 *
 *  @param      loaderHandle    Loader handle.
 *  @param      ulLBA           Sector offset to begin the read from.
 *  @param      pbData          Pointer to a buffer to receive the data.
 *  @param      ulNumBlocks     Number of sector sized blocks to be read. 
 *
 *  @return     Loader error
 *******************************************************************************/
LOADER_ERR LoaderSectorRead(LOADER_HANDLE loaderHandle, ULONG ulLBA, BYTE* pbData, ULONG ulNumBlocks)
{
    LoaderData*     pLoaderData;
    DWORD           dwFilePointerLowPart;
    long            lHighPart;
    DWORD           numberOfBytesRead;
    BOOL            win32Result;

    DBGPRINT(DEBUG_ON(DEBUG_TRACE), ("LoaderSectorRead (LBA=%u)\n",ulLBA));
 
    LOADER_ASSERT_ERROR( (pbData==NULL),   LOADER_INVALID_PARAMETER );
    LOADER_ASSERT_ERROR( (ulNumBlocks==0), LOADER_INVALID_PARAMETER );


    LOADER_RAISE_ERROR( LoaderValidateHandle( loaderHandle ));
    pLoaderData = (LoaderData*) loaderHandle;
    AutoMutex(&pLoaderData->mutex);


    LOADER_ASSERT_ERROR( (pLoaderData->deviceHandle==INVALID_HANDLE_VALUE), LOADER_FAILURE );

   
    lHighPart = ulLBA >> 21;
    dwFilePointerLowPart = ::SetFilePointer (pLoaderData->deviceHandle, ulLBA << 11, &lHighPart, FILE_BEGIN); 

    if (( dwFilePointerLowPart == 0xFFFFFFFF ) && ( GetLastError() != NO_ERROR) )
    {
        // set file pointer failed
        return ( LOADER_FAILURE );
    }


    numberOfBytesRead = 0;
    win32Result = ::ReadFile(pLoaderData->deviceHandle, pbData, ulNumBlocks << 11, &numberOfBytesRead, NULL);

    LOADER_ASSERT_ERROR( (win32Result==0), LOADER_FAILURE );

    // check for incomplete read
    LOADER_ASSERT_ERROR( (numberOfBytesRead!=(ulNumBlocks << 11)), LOADER_FAILURE );

    return ( LOADER_SUCCESS );
}






/**
 *******************************************************************************
 *  LoaderSectorReadAV
 *
 *  @brief      Reads a specific number of blocks from the storage media at the specified sector (streaming).
 *
 *  @param      loaderHandle    Loader handle.
 *  @param      ulLBA           Sector offset to begin the read from.
 *  @param      pbData          Pointer to a buffer to receive the data.
 *  @param      ulNumBlocks     Number of sector sized blocks to be read. 
 *
 *  @return     Loader error
 *******************************************************************************/
LOADER_ERR LoaderSectorReadAV(LOADER_HANDLE loaderHandle, ULONG ulLBA, BYTE* pbData, ULONG ulNumBlocks)
{
    DBGPRINT(DEBUG_ON(DEBUG_TRACE), ("LoaderSectorReadAV\n"));

    return(  LoaderSectorRead(loaderHandle, ulLBA, pbData, ulNumBlocks));
}






/**
 *******************************************************************************
 *  LoaderData::LoaderData
 *
 *  @brief      Initialize members to known state
 *
 *******************************************************************************/
LoaderData::LoaderData ( void )
{
    char    opticalDriveLetter;

#if DEBUG
    magicNumber = 0x12346000;
#endif

    memset(driveName,0,sizeof(driveName));
    deviceHandle        = INVALID_HANDLE_VALUE;
    sessionId           = 0;
    loaderMediaType     = LOADER_MEDIA_TYPE_UNKNOWN;
    regionMask          = 0x00;
    trayStatus          = LOADER_TRAY_UNKNOWN;

    opticalDriveLetter = LOADER_DEFAULT_OPTICAL_DRIVE_LETTER;


#if LOADER_SEARCH_FOR_OPTICAL_DRIVE
    const char* driveTypeString = NULL;

    char    driveStringsBuffer[256];
    UINT    driveType           = 0;
    DWORD   index               = 0;
    DWORD   driveStringsLength  = 0;
    

    // Find optical drive
    DBGPRINT(DEBUG_ON(DEBUG_INFO),("Loader: searching for drives:\n"));
    driveStringsLength = GetLogicalDriveStrings(sizeof(driveStringsBuffer),driveStringsBuffer);
    for ( index = 0; index < driveStringsLength; )
    {
        driveType = GetDriveType(&driveStringsBuffer[index]);
        switch ( driveType ) 
        {
            case DRIVE_UNKNOWN:         driveTypeString = "unknown";  break;
            case DRIVE_NO_ROOT_DIR:     driveTypeString = "unknown";  break;
            case DRIVE_REMOVABLE:       driveTypeString = "removable";  break;
            case DRIVE_FIXED:           driveTypeString = "fixed";  break;
            case DRIVE_REMOTE:          driveTypeString = "network";  break;
            case DRIVE_RAMDISK:         driveTypeString = "ram disk";  break;

            case DRIVE_CDROM: 
                opticalDriveLetter = driveStringsBuffer[index];          
                driveTypeString = "cd-rom";  
            break;
            
            default:                    driveTypeString = "ram disk";  break;
        }
        DBGPRINT(DEBUG_ON(DEBUG_INFO),("     %s  %s drive\n", &driveStringsBuffer[index], driveTypeString));

        index += strlen(&driveStringsBuffer[index])+1;
    }

#endif

    snprintf(driveName,sizeof(driveName), "\\\\.\\%c:",opticalDriveLetter);
    DBGPRINT(DEBUG_ON(DEBUG_INFO),("Loader:  using optical drive: %s\n",driveName));
}






/**
 *******************************************************************************
 *  LoaderData::~LoaderData
 *
 *  @brief      Free allocated resources
 *
 *******************************************************************************/
LoaderData::~LoaderData ( void )
{
    if ( deviceHandle != INVALID_HANDLE_VALUE )
    {
        CloseHandle ( deviceHandle );
    }

    deviceHandle = INVALID_HANDLE_VALUE;
}