/**MOD+**********************************************************************/
/* Header:    CLicense.cpp                                                  */
/*                                                                          */
/* Purpose:   Client License Manager implementation                         */
/*                                                                          */
/* Copyright(C) Microsoft Corporation 1997-1999                             */
/*                                                                          */
/****************************************************************************/

#include <adcg.h>

extern "C" {
#include <clicense.h>
#define TRC_GROUP TRC_GROUP_SECURITY
#define TRC_FILE  "clicense"
#include <atrcapi.h>

#ifdef ENFORCE_LICENSE

#include "license.h"
#include "cryptkey.h"
#include "hccontxt.h"
#endif  //ENFORCE_LICENSE
}

#include "clicense.h"
#include "autil.h"
#include "wui.h"
#include "sl.h"

/****************************************************************************/
/* License Handle Data                                                      */
/****************************************************************************/
typedef struct tagCLICENSE_DATA
{
    int ANumber;

} CLICENSE_DATA, * PCLICENSE_DATA;

/****************************************************************************/
/* Define our memory alloc function                                         */
/****************************************************************************/

#define MemoryAlloc(x) LocalAlloc(LMEM_FIXED, x)
#define MemoryFree(x) LocalFree(x)

CLic::CLic(CObjs* objs)
{
    _pClientObjects = objs;
}


CLic::~CLic()
{
}


/**PROC+*********************************************************************/
/* Name:      CLicenseInit                                                  */
/*                                                                          */
/* Purpose:   Initialize ClientLicense Manager                              */
/*                                                                          */
/* Returns:   Handle to be passed to subsequent License Manager functions   */
/*                                                                          */
/* Params:    None                                                          */
/*                                                                          */
/* Operation: LicenseInit is called during Client initialization.  Its      */
/*            purpose is to allow one-time initialization.  It returns a    */
/*            handle which is subsequently passed to all License Manager    */
/*            functions.  A typical use for this handle is as a pointer to  */
/*            memory containing per-instance data.                          */
/*                                                                          */
/**PROC-*********************************************************************/
int CALL_TYPE CLic::CLicenseInit(
    HANDLE FAR * phContext
    )
{
    int 
        nResult = LICENSE_OK;
    LICENSE_STATUS
        Status;

    DC_BEGIN_FN( "CLicenseInit" );

    _pUt  = _pClientObjects->_pUtObject;
    _pSl  = _pClientObjects->_pSlObject;
    _pMcs = _pClientObjects->_pMCSObject;
    _pUi  = _pClientObjects->_pUiObject;

    //Set only if server capability specifies it
    _fEncryptLicensePackets = FALSE;

    TRC_NRM( ( TB, _T("ClicenseInit Called\n") ) );

    if( _pSl->_SL.encrypting )
    {
        //
        // Security exchange has already taken place, so we do not
        // have to do the server authentication again.
        //

        Status = LicenseInitializeContext(
                            phContext, 
                            LICENSE_CONTEXT_NO_SERVER_AUTHENTICATION );

        if( LICENSE_STATUS_OK != Status ) 
        {
            TRC_ERR( ( TB, _T("Error Initializing License Context: %d\n"), Status ) );
            nResult = LICENSE_ERROR;
        }
    
        //
        // Keep track of the proprietory certificate or the public key that the
        // server has sent to us.
        //

        if( _pSl->_SL.pServerCert )
        {
            Status = LicenseSetCertificate( *phContext, _pSl->_SL.pServerCert );

            if( LICENSE_STATUS_OK != Status )
            {
                TRC_ERR( ( TB, _T("Error setting server certificate: %d\n"), Status ) );
                nResult = LICENSE_ERROR;
            }
        }
        else if( _pSl->_SL.pbServerPubKey )
        {
            Status = LicenseSetPublicKey( *phContext, _pSl->_SL.cbServerPubKey, _pSl->_SL.pbServerPubKey );

            if( LICENSE_STATUS_OK != Status )
            {
                TRC_ERR( ( TB, _T("Error setting server public key: %d\n"), Status ) );
                nResult = LICENSE_ERROR;
            }
        }
        else
        {
            TRC_ERR( ( TB, _T("Error: no server certificate or public key after security exchange\n") ) );
            nResult = LICENSE_ERROR;
        }
    }
    else
    {
        Status = LicenseInitializeContext( phContext, 0 );                            

        if( LICENSE_STATUS_OK != Status ) 
        {
            TRC_ERR( ( TB, _T("Error Initializing License Context: %d\n"), Status ) );
            nResult = LICENSE_ERROR;
        }
    
    }

    DC_END_FN();
    return( nResult );
}


/**PROC+*********************************************************************/
/* Name:      CLicenseData                                                  */
/*                                                                          */
/* Purpose:   Handle license data received from the Server                  */
/*                                                                          */
/* Returns:   LICENSE_OK       - License negotiation is complete            */
/*            LICENSE_CONTINUE - License negotiation will continue          */
/*                                                                          */
/* Params:    pHandle   - handle returned by LicenseInit                    */
/*            pData     - data received from Server                         */
/*            dataLen   - length of data received                           */
/*                                                                          */
/* Operation: This function is passed all license packets received from the */
/*            Server.  It should parse the packet and respond (by calling   */
/*            suitable SL functions - see aslapi.h) as required.            */
/*                                                                          */
/*            If license negotiation is complete, this function must return */
/*            LICENSE_OK                                                    */
/*            If license negotiation is not yet complete, return            */
/*            LICENSE_CONTINUE                                              */
/*                                                                          */
/*            Incoming packets from the Client will continue to be          */
/*            interpreted as license packets until this function returns    */
/*            LICENSE_OK.                                                   */
/*                                                                          */
/**PROC-*********************************************************************/
int CALL_TYPE CLic::CLicenseData(
    HANDLE hContext,
    LPVOID pData,
    DWORD dwDataLen,
    UINT32 *puiExtendedErrorInfo)
{
    SL_BUFHND bufHandle;
    DWORD dwBufLen;
    DWORD dwHeaderLen, dwTotalLen, newDataLen;
    BYTE FAR * pbBuffer;
    LICENSE_STATUS lsReturn = LICENSE_STATUS_OK;
    PRNS_SECURITY_HEADER2 pSecHeader2;

    DC_BEGIN_FN("CLicenseData");

    TRC_NRM((TB, _T("CLicenseData Called\n")));
    TRC_NRM((TB, _T("CLicenseData called, length = %ld"), dwDataLen));

    lsReturn = LicenseAcceptContext( hContext,
                                     puiExtendedErrorInfo,
                                     (BYTE FAR *)pData,
                                     dwDataLen,
                                     NULL,
                                     &dwBufLen);

    if( lsReturn == LICENSE_STATUS_OK)
    {
        TRC_NRM((TB, _T("License verification succeeded\n")));
        DC_END_FN();
        return LICENSE_OK;
    }

    if(lsReturn != LICENSE_STATUS_CONTINUE)
    {
        TRC_ERR((TB, _T("Error %d during license verification.\n"), lsReturn));
        DC_END_FN();
        return LICENSE_ERROR;
    }

    /************************************************************************/
    /* Adjust requested length to account for SL header and                 */
    /* get the buffer from NL                                               */
    /************************************************************************/

    if (_pSl->_SL.encrypting)
    {
        if (_pSl->_SL.encryptionMethodSelected == SM_FIPS_ENCRYPTION_FLAG) {
            // If FIPS is used, 
            // it must have room for an extra block
            dwHeaderLen = sizeof(RNS_SECURITY_HEADER2);
            newDataLen = TSCAPI_AdjustDataLen(dwBufLen);
            dwTotalLen = newDataLen + dwHeaderLen;
        }
        else {
            dwHeaderLen = sizeof(RNS_SECURITY_HEADER1);
            dwTotalLen = dwBufLen + dwHeaderLen;
        }
        TRC_DBG((TB, _T("Ask NL for %d (was %d) bytes"), dwTotalLen, dwBufLen));
    }
    else
    {
        dwHeaderLen = sizeof(RNS_SECURITY_HEADER);
        dwTotalLen = dwBufLen + dwHeaderLen;
        TRC_DBG((TB, _T("Not encrypting, ask NL for %d bytes"), dwTotalLen));
    }

    if( !_pMcs->NL_GetBuffer((DCUINT)(dwTotalLen),
                      (PPDCUINT8)&pbBuffer,
                      &bufHandle) )
    {
        /********************************************************************/
        /* Buffer not available so can't send, try later.                   */
        /********************************************************************/

        TRC_ALT((TB, _T("Failed to get buffer for licensing data\n")));
        DC_END_FN();
        return LICENSE_ERROR;
    }

    // Since FIPS need extra block, fill in the padding size
    if (_pSl->_SL.encryptionMethodSelected == SM_FIPS_ENCRYPTION_FLAG) {
        pSecHeader2 = (PRNS_SECURITY_HEADER2)pbBuffer;
        pSecHeader2->padlen = (TSUINT8)(newDataLen - dwBufLen);
    }

    /********************************************************************/
    /* Adjust buffer pointer to account for SL header                   */
    /********************************************************************/

    pbBuffer += dwHeaderLen;

    lsReturn = LicenseAcceptContext(hContext,
                                    0,
                                    (BYTE FAR *)pData,
                                    dwDataLen,
                                    pbBuffer,
                                    &dwBufLen);

    if( lsReturn != LICENSE_STATUS_CONTINUE )
    {
        TRC_ERR((TB, _T("Error %d during license verification.\n"), lsReturn));
        DC_END_FN();
        return LICENSE_ERROR;
    }

    if(dwBufLen >0)
    {
        //
        // Now send the data
        //

        _pSl->SL_SendPacket( pbBuffer,
                       (DCUINT)(dwBufLen),
                       RNS_SEC_LICENSE_PKT |
                       (_fEncryptLicensePackets ? RNS_SEC_ENCRYPT : 0 ),
                       bufHandle,
                       _pUi->UI_GetClientMCSID(),
                       _pUi->UI_GetChannelID(),
                       TS_LOWPRIORITY );

        TRC_NRM((TB, _T("Sending license verification data, length = %ld"),
                dwBufLen));
        TRC_NRM((TB, _T("Send License Verification data.\n")));
        DC_END_FN();
        DC_END_FN();
        return LICENSE_CONTINUE;
    }

    DC_END_FN();
    return(LICENSE_OK);
}

/**PROC+*********************************************************************/
/* Name:      CLicenseTerm                                                  */
/*                                                                          */
/* Purpose:   Terminate Client License Manager                              */
/*                                                                          */
/* Returns:   None                                                          */
/*                                                                          */
/* Params:    pHandle - handle returned from LicenseInit                    */
/*                                                                          */
/* Operation: This function is provided to do one-time termination of the   */
/*            License Manager.  For example, if pHandle points to per-      */
/*            instance memory, this would be a good place to free it.       */
/*                                                                          */
/*            Note that CLicenseTerm is called if CLicenseInit fails, hence */
/*            it can be called with a NULL pHandle.                         */
/*                                                                          */
/**PROC-*********************************************************************/

int CALL_TYPE CLic::CLicenseTerm(
    HANDLE hContext )
{
    LICENSE_STATUS lsReturn = LICENSE_STATUS_OK;
    DC_BEGIN_FN("CLicenseTerm");
    TRC_NRM((TB, _T("CLicenseTerm called.\n")));
 
    if( LICENSE_STATUS_OK != ( lsReturn = LicenseDeleteContext(hContext) ) )
    {
        TRC_ERR((TB, _T("Error %d while deleting license context.\n"), lsReturn));
        DC_END_FN();
        return LICENSE_ERROR;
    }

    DC_END_FN();
    return LICENSE_OK;
}