dr_app.cpp

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

 * @retval DR_ERROR
 */
static DR_ERROR drIsBdDiscAacs(DRHANDLE *dr, BYTE *bAacs)
{
    BYTE bBdRoExists, bBdRwExists;
    LOADER_ERR rc;
    LOADER_FILE_HANDLE f;
    ULONG tmp_read;
    ULONG pBytesRead = AACS_CCC_SZ;
    uint8 pBuf[AACS_CCC_SZ];
    uint8 pBufCompare[AACS_CCC_SZ];
    memset(pBuf, 0x00, AACS_CCC_SZ);
    memset(pBufCompare, 0x00, AACS_CCC_SZ);
    DbgAssert(bAacs != NULL);
    DbgAssert(dr != NULL);
    *bAacs = 0;

    DBGPRINT(DBG_ON(DBG_TRACE), ("\n\ndrIsBdDiscAacs() - Entered function\n"));

    // Checks if a MKB is present
    rc = LoaderFileAccess(dr->tLoaderDev, "/mnt/cdrom/AACS/MKB_RO.inf", LOADER_FILE_ACCESS_EXIST, &bBdRoExists);
    if (rc != LOADER_SUCCESS)
    {
        return (DR_FAILURE);
    }

    rc = LoaderFileAccess(dr->tLoaderDev, "/mnt/cdrom/AACS/MKB_RW.inf", LOADER_FILE_ACCESS_EXIST, &bBdRwExists);
    if (rc != LOADER_SUCCESS)
    {
        return (DR_FAILURE);
    }

    // Either one of the MKB files must be present to be an AACS BD disc.
    if ( (bBdRoExists == 1) || (bBdRwExists == 1) )
    {
        // Check if a CPS unit usage file is present
        rc = LoaderFileAccess(dr->tLoaderDev, "/mnt/cdrom/AACS/CPSUnit00001.cci", LOADER_FILE_ACCESS_EXIST, bAacs);
        if (rc != LOADER_SUCCESS)
        {
            return (DR_FAILURE);
        }
        if (*bAacs == 0)
        {
            return (DR_SUCCESS);
        }

        // Check if a content hash table is present
        rc = LoaderFileAccess(dr->tLoaderDev, "/mnt/cdrom/AACS/ContentHash000.tbl", LOADER_FILE_ACCESS_EXIST, bAacs);
        if (rc != LOADER_SUCCESS)
        {
            return (DR_FAILURE);
        }
        if (*bAacs == 0)
        {
            return (DR_SUCCESS);
        }

        // Check if a unit key file is present
        rc = LoaderFileAccess(dr->tLoaderDev, "/mnt/cdrom/AACS/Unit_Key_RO.inf", LOADER_FILE_ACCESS_EXIST, bAacs);
        if (rc != LOADER_SUCCESS)
        {
            return (DR_FAILURE);
        }
        if (*bAacs == 0)
        {
            return (DR_SUCCESS);
        }

        // Check if a content revocation file is present.
        rc = LoaderFileAccess(dr->tLoaderDev, "/mnt/cdrom/AACS/ContentRevocation.lst", LOADER_FILE_ACCESS_EXIST, bAacs);
        if (rc != LOADER_SUCCESS)
        {
            return (DR_FAILURE);
        }
        if (*bAacs == 0)
        {
            return (DR_SUCCESS);
        }

        // Check if a content certificate is present
        rc = LoaderFileAccess(dr->tLoaderDev, "/mnt/cdrom/AACS/Content000.cer", LOADER_FILE_ACCESS_EXIST, bAacs);
        if (rc != LOADER_SUCCESS)
        {
            return (DR_FAILURE);
        }
        if (*bAacs == 0)
        {
            return (DR_SUCCESS);
        }

        DBGPRINT(DBG_ON(DBG_TRACE), ("\ndrIsBdDiscAacs() - AACS disc detected, determining if AACS-Ready of AACS (Normal) disc.\n"));

        if (LoaderFileOpen(dr->tLoaderDev, "/mnt/cdrom/AACS/Content000.cer", &f) == LOADER_SUCCESS)
        {
            DBGPRINT(DBG_ON(DBG_TRACE), ("drIsBdDiscAacs() - Content Certificate Opened.....verifying contents...\n"));
            if (LoaderFileRead(dr->tLoaderDev, f, (PVOID) pBuf, pBytesRead, &tmp_read) != LOADER_SUCCESS)
            {
                DBGPRINT(DBG_ON(DBG_TRACE), ("drIsBdDiscAacs() - Content Certificate Read FAILURE.....verifying contents......\n"));
                LoaderFileClose(dr->tLoaderDev, f);
            }
            else
            {
                if (tmp_read == AACS_CCC_SZ)
                {
                    DBGPRINT(DBG_ON(DBG_TRACE), ("drIsBdDiscAacs() - Content Certificate Read SUCCESS (AACS_CCC_SZ).\n"));
                }

                if (memcmp(pBuf, pBufCompare, AACS_CCC_SZ) == 0)
                {
                    DBGPRINT(DBG_ON(DBG_TRACE), ("drIsBdDiscAacs() - AACS-READY Disc detected...\n"));
                    *bAacs = 2;
                }
                if (LoaderFileClose(dr->tLoaderDev, f) != LOADER_SUCCESS)
                {
                    DBGPRINT(DBG_ON(DBG_TRACE), ("drIsBdDiscAacs() - Error closing Content Certificate.\n"));
                    return (DR_FAILURE);
                }
            }
        }
        else
        {
            DBGPRINT(DBG_ON(DBG_TRACE), ("drIsBdDiscAacs() - Error opening Content Certificate.\n"));
            return (DR_FAILURE);
        }
    }

    return DR_SUCCESS;
}

static DR_ERROR drGetCopyrightType(DRHANDLE *dr, BYTE *type)
{
    DbgAssert(type != NULL);
    DbgAssert(dr != NULL);

    if (LoaderReadCopyrightType(dr->tLoaderDev, type) != LOADER_SUCCESS)
    {
        DBGPRINT(DBG_ON(DBG_TRACE), ("LoaderReadCopyrightType failed\n"));
        return (DR_FAILURE);
    }

    return DR_SUCCESS;
}

/**
 * Takes in a disk type and changes the state accordingly. Also gets the dvd disk key
 *
 * @param drType - The disk type.
 *
 * @retval DR_ERROR
 */
static DR_ERROR drIdentifyDiscType(DRHANDLE *dr, DR_DISK_TYPE drType)
{
    cPayload    *pStreamPayload = NULL;
    BYTE        type;
#ifdef BDROM_ENABLE
    BYTE        bAacs;
#endif

    /* reset encryption state */
    dr->EncryptionType = NONE;

    /* grab the copyright information, if appropriate */
    if (drType == DR_DISK_TYPE_DVD)
    {
        if (drGetCopyrightType(dr, &type) != DR_SUCCESS)
        {
            DBGPRINT(DBG_ON(DBG_ERROR), ("drIdentifyDiscType: Could not get copyright type!\n"));
            goto errout;
        }
        DBGPRINT(DBG_ON(DBG_TRACE), ("drIdentifyDiscType: copyright type = %d\n", type));
    }
//jared - aacs (begin) - (ISSUE #1) Samsung HD DVD drive does not retrieve the correct copyright type from HD DVD discs
    else if ( (drType == DR_DISK_TYPE_HDDVD_STD) ||
              (drType == DR_DISK_TYPE_HDDVD_ADV) )
    {
        /* Necessary in order for "test_hddvd_aacs" to work correctly */
        if (LOADER_COPYRIGHT_TYPE_NONE == bHDDVDEncryptionType)
        {
            DBGPRINT(1, ("drIdentifyDiscType: hardcoding HD DVD encryption type to NO ENCRYPTION\n"));
        }
        else if (LOADER_COPYRIGHT_TYPE_AACS == bHDDVDEncryptionType)
        {
            DBGPRINT(1, ("drIdentifyDiscType: hardcoding HD DVD encryption type to AACS ENCRYPTION\n"));
        }
        else
        {
            DBGPRINT(1, ("drIdentifyDiscType: invalid HD DVD encryption type, forcing to NO ENCRYPTION\n"));
            bHDDVDEncryptionType = LOADER_COPYRIGHT_TYPE_NONE;
        }
        type = bHDDVDEncryptionType;
    }
//jared - aacs (end)

    /* proceed based on the disc type */
    switch (drType)
    {
    case DR_DISK_TYPE_CDDA:
    case DR_DISK_TYPE_MP3:
        /* this is a CD so transition to the CD_ATTACH_STREAM state */
        dr->State = DR_STATE_CD_ATTACH_STREAM;
        DBGPRINT(DBG_ON(DBG_TRACE), ("dr->State: DR_STATE_CD_ATTACH_STREAM\n"));
        break;

    case DR_DISK_TYPE_VCD:
        /* this is a VCD so transition to the VCD_ATTACH_STREAM state */
        dr->State = DR_STATE_VCD_ATTACH_STREAM;
        DBGPRINT(DBG_ON(DBG_TRACE), ("dr->State: DR_STATE_VCD_ATTACH_STREAM\n"));
        break;

#ifdef BDROM_ENABLE
    case DR_DISK_TYPE_BDROM:
        /* this is a BDROM so transition to the BDROM_ATTACH_STREAM state */
        dr->State = DR_STATE_BDROM_ATTACH_STREAM;
        DBGPRINT(DBG_ON(DBG_TRACE), ("dr->State: DR_STATE_BDROM_ATTACH_STREAM\n"));

        /* Check if the disc is AACS compliant */
        if (drIsBdDiscAacs(dr, &bAacs) != DR_SUCCESS)
        {
            goto errout;
        }

        if (bAacs == 1)
        {
#ifdef DRM_SUPPORT
            /*
             * TODO: disc is aacs protected, init drm module and extract keys
             */
            dr->EncryptionType = AES_ECB;
            DbgPrint(("%s:%d - NO DRM SUPPORT\n", __FILE__, __LINE__));
#else
            /* no drm support so fail */
            DbgPrint(("%s:%d - NO DRM SUPPORT\n", __FILE__, __LINE__));
            goto errout;
#endif
        }
        else
        {
            dr->EncryptionType = NONE;
        }
        break;
#endif

#ifdef HDDVD_ENABLE
    case DR_DISK_TYPE_HDDVD_STD:
        /* this is an HD DVD (standard) so transition to the HDDVD_STD_ATTACH_STREAM state */
        dr->State = DR_STATE_HDDVD_STD_ATTACH_STREAM;
        DBGPRINT(DBG_ON(DBG_TRACE), ("dr->State: DR_STATE_HDDVD_STD_ATTACH_STREAM\n"));

        if (type == LOADER_COPYRIGHT_TYPE_AACS)
        {
#ifdef DRM_SUPPORT
            /*
            * TODO: disc is aacs protected, init drm module and extract keys
            */
            dr->EncryptionType = AES_ECB;
            DbgPrint(("%s:%d - NO DRM SUPPORT\n", __FILE__, __LINE__));
#else
            /* no drm support so fail */
            DbgPrint(("%s:%d - NO DRM SUPPORT\n", __FILE__, __LINE__));
            goto errout;
#endif
        }
        else
        {
            dr->EncryptionType = NONE;
        }
        break;

    case DR_DISK_TYPE_HDDVD_ADV:
        /* this is an HD DVD (advanced) so transition to the HDDVD_ADV_ATTACH_STREAM state */
        dr->State = DR_STATE_HDDVD_ADV_ATTACH_STREAM;
        DBGPRINT(DBG_ON(DBG_TRACE), ("dr->State: DR_STATE_HDDVD_ADV_ATTACH_STREAM\n"));

        if (type == LOADER_COPYRIGHT_TYPE_AACS)
        {
#ifdef DRM_SUPPORT
            /*
            * TODO: disc is aacs protected, init drm module and extract keys
            */
            dr->EncryptionType = AES_ECB;
            DbgPrint(("%s:%d - NO DRM SUPPORT\n", __FILE__, __LINE__));
#else
            /* no drm support so fail */
            DbgPrint(("%s:%d - NO DRM SUPPORT\n", __FILE__, __LINE__));
            goto errout;
#endif
        }
        else
        {
            dr->EncryptionType = NONE;
        }
        break;
#endif

    case DR_DISK_TYPE_DVD:
        /* get payload buffer for the key */
        pStreamPayload = NEW_PAYLOAD;
        if (pStreamPayload == NULL)
        {
            DbgPrint(("drIdentifyDiscType(DVD): ERROR system out of payloads, cannot get disc key\n"));
            goto errout;
        }

        /* proceed based on the copyright type */
        switch (type)
        {
        case LOADER_COPYRIGHT_TYPE_NONE:
            /* no copyright system */
            DbgPrint(("drIdentifyDiscType(DVD): copyright type = NONE\n"));
            dr->EncryptionType = NONE;
            break;

        case LOADER_COPYRIGHT_TYPE_CSS: 
            /* CSS */
            DbgPrint(("drIdentifyDiscType(DVD): copyright type = CSS\n"));
            if (CSSGetDiskKey(dr->tLoaderDev, (BYTE *)(pStreamPayload->get_wr_ptr())) != CSS_SUCCESS)
            {
                DbgPrint(("drIdentifyDiscType(): ERROR CSSGetDiskKey() failed\n"));
                dr->EncryptionType = NONE;
            }
            else
            {
                dr->EncryptionType = CSS;
            }
            break;

        case LOADER_COPYRIGHT_TYPE_CPRM:
        case LOADER_COPYRIGHT_TYPE_AACS:
        default:
            /* all other cases */
            DbgPrint(("drIdentifyDiscType(): ERROR unknown copyright type = %d\n", type));
            DbgAssert(false);
            break;
        }

        /* release the payload */
        delete (pStreamPayload);
        pStreamPayload = NULL;

        /* transition to the attach stream state */
        dr->State = DR_STATE_DVD_ATTACH_STREAM;
        DBGPRINT(DBG_ON(DBG_TRACE), ("dr->State: DR_STATE_DVD_ATTACH_STREAM\n"));
        break;

    default:
        goto errout;
        break;
    }

    return (DR_SUCCESS);

errout:
    DBGPRINT(DBG_ON(DBG_TRACE), ("drIdentifyDiscType: FAILED\n"));
    return (DR_FAILURE);
}


/**
 * Takes in a state and returns a new prefetch object based on the disk type of that state information
 *
 * @param state - the DR state.
 *
 * @retval DR_ERROR
 */
static DRPrefetch *drNewPrefetchForState(DR_STATE &state)
{

    switch (state & DR_STATE_DISC_FIELD)
    {
#ifdef CDDA_ENABLE
    case DR_STATE_CD:
        return (new DRPrefetch_CDDA);
#endif
#ifdef VCD_ENABLE
    case DR_STATE_VCD:
        return (new DRPrefetch_VCD);
#endif
    case DR_STATE_DVD:
        return (new DRPrefetch_DVD);
#ifdef HDDVD_ENABLE
    case DR_STATE_HDDVD_STD:
        return (new DRPrefetch_HDDVD_STD);
    case DR_STATE_HDDVD_ADV:
        return (new DRPrefetch_HDDVD_ADV);
#endif
#ifdef BDROM_ENABLE
    case DR_STATE_BDROM:
        return (new DRPrefetch_BDROM);
#endif

    default:
        return(NULL);
    }
}



/**
 *  all dr prefetch objects are given this as their event handler.
 *  this event handler then passes on the event to an external handler,
 *  if one has been specified.
 *
 * @param pContext      - the context.
 * @param event         - the event.
 * @param pvEventInfo   - the event information.
 *
 * @retval DR_ERROR
 */
static DR_ERROR drEventPasser(PVOID pContext, DR_EVENT_CODE event, PVOID pvEventInfo)
{
    DR_ERROR status = DR_FAILURE;
    DRHANDLE *dr = (DRHANDLE*)pContext;

    if (dr->eventCallback != NULL)
    {
        status = dr->eventCallback(dr->eventContext, event, pvEventInfo);
    }
    return(status);
}