1 /*

     2 * Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  This class implements the BbB-functionality.

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 

    21 #include <e32base.h>

    22 #include <s32file.h>

    23 #include <s32mem.h>

    24 #include <caf/caftypes.h>

    25 #include <wspdecoder.h>

    26 #include <wspencoder.h>

    27 

    28 #ifdef RD_MULTIPLE_DRIVE

    29 #include <DriveInfo.h>

    30 #endif

    31 

    32 #include "DrmRights.h"

    33 #include "Oma1DcfCreator.h"

    34 #include "b64.h"

    35 #include "DRMMessageParser.h"

    36 #include "DRMRightsParser.h"

    37 #include "DRMRightsClient.h"

    38 #include "DrmKeyStorage.h"

    39 

    40 

    41 // EXTERNAL DATA STRUCTURES

    42 // EXTERNAL FUNCTION PROTOTYPES  

    43 // CONSTANTS

    44 // MACROS

    45 // LOCAL CONSTANTS AND MACROS

    46 LOCAL_C const TInt KDefaultInputBufferSize = 2048;

    47 LOCAL_C const TInt KDRMMessageMalformed = KErrGeneral;

    48 

    49 _LIT8( KCIDString, "cid:" );

    50 LOCAL_C const TInt KCIDStringLength = 4;

    51 

    52 _LIT8( KFLPrefix, "flk:");

    53 LOCAL_C const TInt KFLKPrefixLength = 4;

    54 

    55 _LIT8( KFLSuffix, "@localhost");

    56 LOCAL_C const TUint8 KCDContentIDLength = 25; // 4 + 11 + 10

    57 LOCAL_C const TUint8 KCDPlainIDLength = 11; 

    58 

    59 LOCAL_C const TInt KInputBufferSize = 2048;

    60 LOCAL_C const TInt KBoundaryMarkLength = 2;

    61 

    62 LOCAL_C const TUint KInitialDCFBufferSize = 4096;

    63 

    64 #ifdef RD_MULTIPLE_DRIVE

    65 _LIT( KTempPath, "%c:\\system\\temp\\" );

    66 #else

    67 _LIT( KTempPath, "c:\\system\\temp\\" );

    68 #endif

    69 

    70 _LIT8( KColon, ":" );

    71 _LIT8( KSemiColon, ";" );

    72 _LIT8( KNewLine, "\n" );

    73 _LIT8( KEndLine, "\r\n" );

    74 LOCAL_C const TUint8 KEndLineLength = 2;

    75 

    76 _LIT8( KBoundaryMark, "--" );

    77 _LIT8( KContentType, "Content-Type" );

    78 _LIT8( KContentTransferEncoding, "Content-Transfer-Encoding" );

    79 _LIT8( KEncodingBase64, "base64" );

    80 _LIT8( KEncoding7bit, "7bit" );

    81 _LIT8( KEncoding8bit, "8bit" );

    82 _LIT8( KEncodingBinary, "binary" );

    83 _LIT8( KDRMXMLRightsType, "application/vnd.oma.drm.rights+xml");

    84 _LIT8( KDRMWBXMLRightsType, "application/vnd.oma.drm.rights+wbxml" );

    85 _LIT8( KDRMContentType, "application/vnd.oma.drm.content" );

    86 _LIT8( KRightsIssuer, "Rights-Issuer" );

    87 

    88 _LIT8( KRightsStartTag, "<o-ex:rights");

    89 

    90 _LIT8( KROPart1, "Content-Type: application/vnd.oma.drm.rights+xml\r\n\

    91 Content-Transfer-Encoding: binary\r\n\r\n\

    92 <o-ex:rights xmlns:o-ex=\"http://odrl.net/1.1/ODRL-EX\" \

    93 xmlns:o-dd=\"http://odrl.net/1.1/ODRL-DD\" \

    94 xmlns:ds=\"http://www.w3.org/2000/09/xmldsig#/\">\

    95 <o-ex:context><o-dd:version>1.0</o-dd:version></o-ex:context>\

    96 <o-ex:agreement><o-ex:asset><o-ex:context>\

    97 <o-dd:uid>");

    98 

    99 _LIT8( KROPart2, "</o-dd:uid></o-ex:context></o-ex:asset><o-ex:permission>\

   100 <o-dd:display/><o-dd:play/><o-dd:execute/><o-dd:print/>\

   101 </o-ex:permission></o-ex:agreement></o-ex:rights>");

   102 

   103 const TInt KFLROSize = sizeof(KROPart1) + sizeof(KROPart2);

   104 

   105 // MODULE DATA STRUCTURES

   106 struct TDeleteFileData

   107     {

   108     RFs aFs;

   109     TFileName aName;

   110     };

   111     

   112 // LOCAL FUNCTION PROTOTYPES

   113 LOCAL_C void DoResetAndDestroy( TAny* aPtr );

   114 LOCAL_C void DoResetAndDestroy2( TAny* aPtr );

   115 LOCAL_C void DoDeleteFile( TAny* aPtr );

   116 LOCAL_C void ConvertPermissionL( CDRMRights*& aRights,

   117                                  CDRMPermission& aPermission,

   118                                  const TDesC8& aURI );

   119 // FORWARD DECLARATIONS

   120 

   121 // ============================= LOCAL FUNCTIONS ===============================

   122 // -----------------------------------------------------------------------------

   123 // DoResetAndDestroy

   124 // Does ResetAndDestroy() to given RPointerArray< CDRMRights >

   125 // -----------------------------------------------------------------------------

   126 void DoResetAndDestroy( TAny* aPtr )

   127     {

   128     __ASSERT_DEBUG( aPtr, User::Invariant() );

   129     

   130     reinterpret_cast< RPointerArray< CDRMRights >* >( aPtr )->ResetAndDestroy();

   131     }

   132 

   133 void DoResetAndDestroy2( TAny* aPtr )

   134     {

   135     __ASSERT_DEBUG( aPtr, User::Invariant() );

   136     

   137     reinterpret_cast< RPointerArray< CDRMPermission >* >( aPtr )->ResetAndDestroy();

   138     }

   139 // -----------------------------------------------------------------------------

   140 // DoDeleteFile

   141 // Delete the file presented by TDeleteFileData pointer.

   142 // -----------------------------------------------------------------------------

   143 void DoDeleteFile( TAny* aPtr )

   144     {

   145     __ASSERT_DEBUG( aPtr, User::Invariant() );

   146     TDeleteFileData* data = reinterpret_cast< TDeleteFileData* >( aPtr );

   147     data->aFs.Delete( data->aName );

   148     }

   149 

   150 void ConvertPermissionL( CDRMRights*& aRights,

   151                          CDRMPermission& aPermission,

   152                          const TDesC8& aURI )

   153     {

   154     CDRMAsset* asset( NULL );

   155     CDRMRights* rights( NULL );

   156     

   157     aRights = NULL;

   158     

   159     rights = CDRMRights::NewL();

   160     CleanupStack::PushL( rights );

   161     

   162     asset = CDRMAsset::NewL();

   163     CleanupStack::PushL( asset );

   164     

   165     asset->iUid = aURI.AllocL();

   166     

   167     if ( aPermission.iParentUID )

   168         {

   169         asset->iParentRights = aPermission.iParentUID->AllocL();

   170         }

   171     

   172     rights->SetPermissionL( aPermission );

   173     rights->SetAssetL( *asset );

   174     

   175     CleanupStack::PopAndDestroy(); // asset

   176     CleanupStack::Pop(), // rights

   177     

   178     aRights = rights;

   179     }

   180 

   181 // ============================ MEMBER FUNCTIONS ===============================

   182 // -----------------------------------------------------------------------------

   183 // CDRMMessageParser::NewL

   184 // Two-phased constructor.

   185 // -----------------------------------------------------------------------------

   186 //

   187 EXPORT_C CDRMMessageParser* CDRMMessageParser::NewL( void )

   188     {

   189     CDRMMessageParser* self = new( ELeave ) CDRMMessageParser();

   190     

   191     CleanupStack::PushL( self );

   192     self->ConstructL();

   193     CleanupStack::Pop();

   194     

   195     return self;

   196     }

   197 

   198 // -----------------------------------------------------------------------------

   199 // CDRMMessageParser::CDRMMessageParser

   200 // Constructor.

   201 // -----------------------------------------------------------------------------

   202 //

   203 CDRMMessageParser::CDRMMessageParser() :

   204     iDcfCreator( NULL ),

   205     iBoundary( NULL ),

   206     iContentType( NULL ),

   207     iState( ESearchingBoundary ),

   208     iInputBuffer( NULL, 0, 0 )

   209     {

   210     iDCFHeaderSize[ 0 ] = KMaxTUint32;

   211     iDCFHeaderSize[ 1 ] = KMaxTUint32;

   212     }

   213 

   214 // -----------------------------------------------------------------------------

   215 // Destructor.

   216 // -----------------------------------------------------------------------------

   217 //

   218 EXPORT_C CDRMMessageParser::~CDRMMessageParser()

   219     {

   220     TInt error = KErrNone;

   221     TRAP( error, FinalizeMessageParserL() );

   222     

   223     Reset();

   224     

   225     User::Free( const_cast< TUint8* >( iInputBuffer.Ptr() ) );

   226     }

   227 

   228 // -----------------------------------------------------------------------------

   229 // CDRMMessageParser::

   230 // 

   231 // -----------------------------------------------------------------------------

   232 //

   233 EXPORT_C void CDRMMessageParser::InitializeMessageParserL( RWriteStream& aStream )

   234     {

   235     Reset();

   236     

   237     iDcfCreator = COma1DcfCreator::NewL();

   238     

   239     iOutputStream = aStream;

   240     }

   241 

   242 // -----------------------------------------------------------------------------

   243 // CDRMMessageParser::ProcessDataL

   244 // Choose which operation is required.

   245 // -----------------------------------------------------------------------------

   246 EXPORT_C void CDRMMessageParser::ProcessMessageDataL( const TDesC8& aMessageData )

   247     {

   248     /*

   249     * What happens here is:

   250     *   - a boundary string is located and extracted

   251     *   - MIME header is read, and based on content-type field the internal

   252     *     state is set to either EReadingRightsPart or EReadingContentPart.

   253     *   - after processing the MIME part, internal state is updated again to 

   254     *     EReadingHeaderPart if there are several MIME parts in the DRM 

   255     *     message.

   256     *   - data is consumed from iInputData in each phase.

   257     *   - after everything is done, internal state is set to EAllDone.

   258     */

   259     if ( iState & EBroken )

   260         {

   261         User::Leave( KErrNotReady );

   262         }

   263     

   264     if ( iState & EAllDone )

   265         {

   266         return;

   267         }

   268     

   269     iInputData.Set( aMessageData );

   270     

   271     while( iInputData.Length() )

   272         {

   273         if ( iState & EReadingHeaderPart )

   274             {

   275             ReadHeaderL();

   276             }

   277         else

   278             {

   279             if ( iState & EReadingContentPart )

   280                 {

   281                 HandleContentDataL();

   282                 }

   283             else

   284                 {

   285                 if ( iState & EReadingRightsPart )

   286                     {

   287                     HandleRightsDataL();

   288                     }

   289                 else

   290                     {

   291                     FindBoundaryL();

   292                     }

   293                 }

   294             }

   295         }

   296     }

   297 

   298 // -----------------------------------------------------------------------------

   299 // CDRMMessageParser::FinalizeL

   300 // Finalize the message parser.

   301 // -----------------------------------------------------------------------------

   302 EXPORT_C void CDRMMessageParser::FinalizeMessageParserL()

   303     {

   304     TInt error( KErrNone );

   305     

   306     if ( iState & EEncryptStreamOk )

   307         {

   308         if ( iInputBuffer.Length() )

   309             {

   310             // Message is not parsed fully ==> error.

   311             // Try to delete the RO if it is possible.

   312             DeletePermission();

   313             error = KDRMMessageMalformed;

   314             }

   315             

   316         ClearBit( EEncryptStreamOk );

   317         iDcfCreator->EncryptFinalizeL();

   318         

   319         iOutputStream.CommitL();

   320         }

   321 

   322     Reset();

   323     

   324     User::LeaveIfError( error );

   325     }

   326 

   327 // -----------------------------------------------------------------------------

   328 // CDRMMessageParser::ConstructL

   329 // Symbian 2nd phase constructor can leave.

   330 // -----------------------------------------------------------------------------

   331 //

   332 void CDRMMessageParser::ConstructL()

   333     {

   334     // Make some extra room for crazy b64decode().

   335     iInputBuffer.Set( reinterpret_cast< TUint8* >( 

   336                         User::AllocL( KInputBufferSize + 2 ) ), 

   337                       0, 

   338                       KInputBufferSize );

   339     }

   340 

   341 // -----------------------------------------------------------------------------

   342 // CDRMMessageParser::HandleContentDataL

   343 // Process the content data:

   344 // - base64 decoding

   345 // - boundary checks

   346 // - forward the processed data to ProcessContentDataL

   347 // -----------------------------------------------------------------------------

   348 //

   349 void CDRMMessageParser::HandleContentDataL()

   350     {

   351    TPtrC8 res( NULL, 0 );

   352     TBool cont( ETrue );

   353     TInt remainder( 0 );

   354     

   355     // Loop until 

   356     // - PrepareContentDataL leaves

   357     // - boundary end marker is found

   358     // - iInputBuffer is not updated anymore.

   359     for ( PrepareContentDataL(); 

   360           iInputBuffer.Length() && 

   361               ( remainder != iInputBuffer.Length() ) && 

   362               cont;

   363           PrepareContentDataL() )

   364         {

   365         TInt pos = iInputBuffer.Find( *iBoundary );

   366         

   367         if ( pos >= 0 )

   368             {

   369             if ( pos < KBoundaryMarkLength + 1 ) 

   370                 {

   371                 SetBrokenStateL( KDRMMessageMalformed );

   372                 }

   373             

   374             res.Set( iInputBuffer.Left( pos - KBoundaryMarkLength ) );

   375             

   376             StripEndLineL( res );

   377             

   378             cont = EFalse;

   379             }

   380         else

   381             {

   382             // All the data cannot be processed immediately, because

   383             // there may be only a part of boundary string in this buffer

   384             // and the rest is got from the next input descriptor.

   385             remainder = iBoundary->Length() + KBoundaryMarkLength + 1;

   386             

   387             if ( iInputBuffer.Length() <= remainder )

   388                 {

   389                 return;

   390                 }

   391             

   392             res.Set( iInputBuffer.Left( iInputBuffer.Length() - 

   393                                         remainder ) );

   394             }

   395         

   396         if ( iState & EBase64 )

   397             {

   398             iUsedFromInput = HandleBase64DataL( res );

   399             }

   400         

   401         else

   402             {

   403             iUsedFromInput = res.Length();

   404             }

   405         

   406         ProcessContentDataL( res );

   407         

   408         CompressInputBuffer();

   409 

   410         remainder = iInputBuffer.Length(); 

   411         }

   412     

   413     if ( !cont )

   414         {

   415         // Discard all the remaining data.

   416         ClearBit( EReadingContentPart );

   417         SetBit( EAllDone );

   418         iInputBuffer.SetLength( 0 );

   419         iInputData.Set( NULL, 0 );

   420         }

   421     }

   422 

   423 // -----------------------------------------------------------------------------

   424 // CDRMMessageParser::HandleRightsDataL

   425 // - check if the boundary is reached

   426 // - check if the whole rights part is read, and allocate memory && copy the RO

   427 //   if so

   428 // - save the rights object

   429 // -----------------------------------------------------------------------------

   430 //

   431 void CDRMMessageParser::HandleRightsDataL()

   432     {

   433     TPtrC8 res( NULL, 0 );

   434     

   435     do

   436         {

   437         res.Set( GetLineL() );

   438         

   439         TInt pos = res.Find( *iBoundary );

   440         

   441         if ( pos >= KBoundaryMarkLength )

   442             {

   443             if ( res.Left( KBoundaryMarkLength ) == KBoundaryMark )

   444                 {

   445                 // Allow empty RO here. If it is not allowed by 

   446                 // HandleRightsMessagePart(), an error is thrown.

   447                 TBool last = EFalse;

   448                 

   449                 // Returns always true.

   450                 IsBoundary( res, last );

   451                 

   452                 if ( last )

   453                     {

   454                     TInt error( KErrNone );

   455                     RPointerArray< CDRMRights > rights;

   456                     TPtrC8 ptr( iInputBuffer.Ptr(),         

   457                                 pos - KBoundaryMarkLength );

   458                     

   459                     error = ProcessRightsObject(ptr, rights);

   460                     rights.ResetAndDestroy();

   461                     

   462                     if ( !error )

   463                         {

   464                         SetBit( EAllDone );

   465                         }

   466                     else

   467                         {

   468                         SetBrokenStateL( error );

   469                         }

   470                     }

   471                 else

   472                     {

   473                     // Save the RO since the CID needs to be either changed 

   474                     // or created.

   475                     iRightsData = iInputBuffer.Left( iUsedFromInput - 

   476                                                      res.Length() ).AllocL();

   477                     }

   478                 

   479                 CompressInputBuffer();

   480                 

   481                 ClearBit( EReadingRightsPart );

   482                 ClearBit( EGotContentType );

   483                 ClearBit( EGotContentEncoding );

   484 

   485                 SetBit( EGotRightsPart );

   486                 SetBit( EReadingHeaderPart );

   487                 

   488                 res.Set( NULL, 0 );

   489 #ifndef __DRM_FULL

   490                 User::Leave(KErrNotSupported);

   491 #endif                

   492                 }

   493             else

   494                 {

   495                 SetBrokenStateL( KDRMMessageMalformed );

   496                 }

   497             }

   498         else

   499             {

   500             if ( pos >= 0 )

   501                 {

   502                 SetBrokenStateL( KDRMMessageMalformed );

   503                 }

   504             }

   505         } while ( res.Length() );

   506     }

   507 

   508 

   509 // -----------------------------------------------------------------------------

   510 // CDRMMessageParser::FindBoundaryL

   511 // Tries to locate the boundary string from the available data in iInputBuffer.

   512 // -----------------------------------------------------------------------------

   513 //

   514 void CDRMMessageParser::FindBoundaryL()

   515     {

   516     TPtrC8 line( NULL, 0 );

   517     

   518     FOREVER

   519         {

   520         line.Set( GetLineL() );

   521         

   522         if ( line.Length() > KBoundaryMarkLength )

   523             {

   524             TInt size = 0;

   525             

   526             if ( line.Left( KBoundaryMarkLength ) == KBoundaryMark )

   527                 {

   528                 size = line.Length() - KBoundaryMarkLength - 1;

   529                 

   530                 if ( line[ line.Length() - 2 ] == '\r' )

   531                     {

   532                     --size;

   533                     }

   534                 

   535                 iBoundary = line.Mid( KBoundaryMarkLength, size ).AllocL();

   536                 

   537                 SetBit( EGotBoundary );

   538                 SetBit( EReadingHeaderPart );

   539                 

   540                 CompressInputBuffer();

   541                 

   542                 return;

   543                 }

   544             }

   545         else

   546             {

   547             if ( line.Length() == 0 )

   548                 {

   549                 return;

   550                 }

   551             }

   552         

   553         // Something else, not interested.

   554         CompressInputBuffer();

   555         }

   556     }

   557 

   558 // ----------------------------------------------------------------------------

   559 // CDRMMessageParser::ReadHeaderL

   560 // The boundary is read and the following part is (should be) either a RO part

   561 // or content part. The data is kept in iInputBuffer until the whole header 

   562 // part of the MIME header part is received. After plain "\r\n" line is 

   563 // received and content-type is defined, iState is updated.

   564 // ----------------------------------------------------------------------------

   565 //

   566 void CDRMMessageParser::ReadHeaderL()

   567     {

   568     TPtrC8 line( NULL, 0 );

   569     TPtrC8 ptr( NULL, 0 );

   570     

   571     FOREVER

   572         {

   573         ///////////////////////////////////////////////////////////////////

   574         // Process the MIME header line-by-line. Process the lines if they

   575         // contain some information that is found useful. Update the 

   576         // internal state according to findings.

   577         ///////////////////////////////////////////////////////////////////

   578         line.Set( GetLineL() );

   579         

   580         if ( line.Length() )

   581             {

   582             if ( line == KEndLine || line == KNewLine )

   583                 {

   584                 ///////////////////////////////////////////////

   585                 // MIME header is read. Check what to do next.

   586                 ///////////////////////////////////////////////

   587                 if ( iState & EGotContentType )

   588                     {

   589                     // Sanity check: Either EReadingRightsPart or 

   590                     // EReadingContentPart must defined.

   591                     __ASSERT_DEBUG( ( iState & EReadingRightsPart ) ||

   592                         ( iState & EReadingContentPart ), 

   593                         User::Invariant() );

   594                     

   595                     ClearBit( EReadingHeaderPart );

   596                     

   597                     CompressInputBuffer();

   598                     

   599                     // Check which part was read.

   600                     // If content part is being processed, some checkings 

   601                     // need to be made.

   602                     if ( iState & EReadingContentPart )

   603                         {

   604                         if ( iContentType->CompareF( KDRMContentType ) == 0 )

   605                             {

   606                             if ( iState & EGotRightsPart )

   607                                 {

   608                                 // CD DCF.

   609                                 SetBrokenStateL( KErrCANotSupported );

   610                                 }

   611                             

   612                             InitDCFBufferL();

   613 

   614                             SetBit( EDCFFile );

   615                             }

   616                         else

   617                             {

   618                             // Non-DCF FL content or normal CD content. 

   619                             // Create or modify the CID, save the RO.

   620                             HandleFlContentL();

   621                             

   622                              iDcfCreator->EncryptInitializeL(

   623                                 iOutputStream,

   624                                 *iContentType,

   625                                 iRightsObject );

   626                             SetBit( EEncryptStreamOk );

   627                             

   628                             // The RO handle iRightsObject is kept in order 

   629                             // to delete the rights in case of content 

   630                             // encryption error. In that case, this will 

   631                             // generate unnecessary "RO Added / RO Deleted"

   632                             // notifications, but so what. "More correct"

   633                             // way of doing would be modifying 

   634                             // EncryptInitialize not to 

   635                             // save the RO, but then the key would have to

   636                             // be given to it by other means. Since we are

   637                             // not their "friend" class, we cannot access 

   638                             // their members, and making them to ask our

   639                             // members when doing EncryptInitialize/Finalize

   640                             // might cause some problems perhaps.

   641                             }

   642                         

   643                         delete iContentType;

   644                         iContentType = NULL;

   645                         }

   646                     

   647                     return;

   648                     }

   649                 

   650                 // Empty MIME header.

   651                 SetBrokenStateL( KDRMMessageMalformed );

   652                 }

   653             

   654             ///////////////////////////////////

   655             // Check the line for content-type.

   656             ///////////////////////////////////

   657             if ( line.Length() > KContentType().Length()  &&  

   658                 !( line.Left( KContentType().Length() ).CompareF( KContentType ) ) )

   659                 {

   660                 if ( iState & EGotContentType )

   661                     {

   662                     // Content-type given twice.

   663                     SetBrokenStateL( KDRMMessageMalformed );

   664                     }

   665                 

   666                 ptr.Set( HeaderValueL( line ) );

   667                 

   668                 SetBit( EGotContentType );

   669                 

   670                 // Which part this is: rights or the actual content?

   671                 if ( ( ptr.CompareF( KDRMXMLRightsType ) == 0 ) ||

   672                     ( ptr.CompareF( KDRMWBXMLRightsType ) == 0 ) )

   673                     {

   674                     if ( iState & EGotRightsPart )

   675                         {

   676                         // Rights are given twice.

   677                         SetBrokenStateL( KDRMMessageMalformed );

   678                         }

   679                     

   680                     SetBit( EReadingRightsPart );

   681                     }

   682                 else

   683                     {

   684                     if ( iState & EGotContentPart )

   685                         {

   686                         SetBrokenStateL( KDRMMessageMalformed );

   687                         }

   688                     

   689                     SetBit( EReadingContentPart );

   690                     

   691                     // Content-type is saved for future use.

   692                     iContentType = ptr.AllocL();

   693                     }

   694                 }

   695             else

   696                 {

   697                 ////////////////////////////////////////////////

   698                 // Check the line for content-transfer-encoding.

   699                 ////////////////////////////////////////////////

   700                 if ( line.Length() > KContentTransferEncoding().Length() &&

   701                     !( line.Left( KContentTransferEncoding().Length() ).

   702                     CompareF( KContentTransferEncoding ) ) )

   703                     {

   704                     if ( iState & EGotContentEncoding )

   705                         {

   706                         // Double line.

   707                         SetBrokenStateL( KDRMMessageMalformed );

   708                         }

   709                     

   710                     ptr.Set( HeaderValueL( line ) );

   711                     

   712                     SetBit( EGotContentEncoding );

   713 

   714                     // Throw an error if content-transfer-encoding 

   715                     // is something we don't support.

   716                     if ( ptr.CompareF( KEncoding8bit ) &&

   717                         ptr.CompareF( KEncoding7bit) &&

   718                         ptr.CompareF( KEncodingBinary ) )

   719                         {

   720                         if ( ptr.CompareF( KEncodingBase64 ) )

   721                             {

   722                             SetBrokenStateL( KErrCANotSupported );

   723                             }

   724                         

   725                         // So it has to be Base64.

   726                         SetBit( EBase64 );

   727                         }

   728                     }

   729                 else

   730                     {

   731                     //////////////////////////////////////////

   732                     // Check the line for end boundary marker.

   733                     //////////////////////////////////////////

   734                     TBool final( EFalse );

   735                     

   736                     if ( IsBoundary( line, final ) )

   737                         {

   738                         SetBrokenStateL( KDRMMessageMalformed );

   739                         }

   740                     

   741                     // Else: some X-field, parameter or something else. 

   742                     // The line is ignored.

   743                     }

   744                 }

   745             

   746             CompressInputBuffer();

   747             }

   748             

   749         else

   750             {

   751             // No line available yet.

   752             return;

   753             }

   754         }

   755     }

   756 

   757 // -----------------------------------------------------------------------------

   758 // CDRMMessageParser::GetLineL

   759 // Return a descriptor representing a single line ending to \n in iInputBuffer.

   760 // -----------------------------------------------------------------------------

   761 //

   762 TPtrC8 CDRMMessageParser::GetLineL()

   763     {

   764     TInt pos = 0;

   765     TPtrC8 res( NULL, 0 );

   766     

   767     if ( iInputBuffer.Length() > iUsedFromInput )

   768         {

   769         pos = iInputBuffer.Mid( iUsedFromInput ).Find( KNewLine );

   770         

   771         if ( pos >= 0 )

   772             {

   773             res.Set( iInputBuffer.Mid( iUsedFromInput, pos - iUsedFromInput + 1 ) );

   774             iUsedFromInput = pos + 1;

   775             }

   776         }

   777     

   778     if ( res.Length() == 0 )

   779         {

   780         if ( iInputData.Length() )

   781             {

   782             pos = iInputData.Find( KNewLine );

   783             

   784             if ( pos < 0 )

   785                 {

   786                 if ( iInputBuffer.MaxSize() - iInputBuffer.Length() < 

   787                     iInputData.Length() )

   788                     {

   789                     SetBrokenStateL( KDRMMessageMalformed );

   790                     }

   791                 

   792                 iInputBuffer.Append( iInputData );

   793                 iInputData.Set( NULL, 0 );

   794                 }

   795             else

   796                 {

   797                 if ( iInputBuffer.MaxSize() - iInputBuffer.Length() <

   798                     pos + 1 )

   799                     {

   800                     SetBrokenStateL( KDRMMessageMalformed );

   801                     }

   802                 

   803                 iInputBuffer.Append( iInputData.Left( pos + 1 ) );

   804                 res.Set( iInputBuffer.Mid( iUsedFromInput ) );

   805                 iUsedFromInput = iInputBuffer.Length();

   806                 

   807                 iInputData.Set( iInputData.Mid( pos + 1 ) );

   808                 }

   809             }

   810         }

   811     

   812     return res;

   813     }

   814 

   815 // -----------------------------------------------------------------------------

   816 // CDRMMessageParser::HeaderValueL

   817 // Return a descriptor representing a header value in aLine.

   818 // -----------------------------------------------------------------------------

   819 //

   820 TPtrC8 CDRMMessageParser::HeaderValueL( const TDesC8& aLine )

   821     {

   822     TInt pos( 0 );

   823     TPtrC8 res( NULL, 0 );

   824     

   825     pos = aLine.Find( KColon );

   826     

   827     if ( pos <= 0 )

   828         {

   829         SetBrokenStateL( KDRMMessageMalformed );

   830         }

   831     

   832     pos += 1;

   833     

   834     while ( pos < aLine.Length() && 

   835             TChar( aLine[ pos ] ).IsSpace() )

   836         {

   837         ++pos;

   838         }

   839 

   840     // Don't overindex.   

   841     if ( pos == aLine.Length() )

   842         {

   843         // Full of whitespaces.

   844         SetBrokenStateL( KDRMMessageMalformed );

   845         }

   846 

   847     // Drop possible parameters.

   848     res.Set( aLine.Mid( pos ) );

   849     pos = res.Find( KSemiColon );

   850     

   851     if ( pos >= 0 )

   852         {

   853         res.Set( res.Left( pos ) );

   854         }

   855     

   856     pos = res.Length();

   857     

   858     if ( !pos )

   859         {

   860         // Just parameters, no actual value.

   861         SetBrokenStateL( KDRMMessageMalformed );

   862         }

   863 

   864     // This can't underflow, since otherwise there would be only 

   865     // semicolon & parameters (checked earlier).

   866     while( TChar( res[ pos - 1 ] ).IsSpace() )

   867         {

   868         --pos;

   869         }

   870     

   871     return res.Left( pos );

   872     }

   873 

   874 // -----------------------------------------------------------------------------

   875 // CDRMMessageParser::CompressInputBuffer

   876 // Compress iInputBuffer.

   877 // -----------------------------------------------------------------------------

   878 //

   879 void CDRMMessageParser::CompressInputBuffer()

   880     {

   881     if ( iUsedFromInput )

   882         {

   883         const TInt size = iInputBuffer.Length() - iUsedFromInput;

   884         

   885         Mem::Copy( const_cast< TUint8* >( iInputBuffer.Ptr() ),

   886             iInputBuffer.Ptr() + iUsedFromInput,

   887             size );

   888         

   889         iInputBuffer.SetLength( size );

   890         iUsedFromInput = 0;

   891         }

   892     }

   893 

   894 // -----------------------------------------------------------------------------

   895 // CDRMMessageParser::PrepareContentDataL

   896 // Fills the iInputBuffer from iInputData.

   897 // -----------------------------------------------------------------------------

   898 //

   899 void CDRMMessageParser::PrepareContentDataL()

   900     {

   901     if ( iInputData.Length() )

   902         {

   903         if ( iInputBuffer.Length() == iInputBuffer.MaxSize() )

   904             {

   905             SetBrokenStateL( KDRMMessageMalformed );

   906             }

   907         

   908         const TInt size = Min( iInputBuffer.MaxSize() - iInputBuffer.Length(), 

   909                                iInputData.Length() );

   910         

   911         iInputBuffer.Append( iInputData.Left( size ) );

   912         

   913         iInputData.Set( iInputData.Mid( size ) );

   914         }

   915     }

   916     

   917 // -----------------------------------------------------------------------------

   918 // CDRMMessageParser::HandleBase64DataL

   919 // Decode base64 encoded data from and to aData descriptor.

   920 // 

   921 // -----------------------------------------------------------------------------

   922 //

   923 TInt CDRMMessageParser::HandleBase64DataL( TPtrC8& aData )

   924     {

   925     TUint8* consumed = const_cast< TUint8* >( aData.Ptr() );

   926     TUint32 temp1 = 0;

   927     TUint8 temp2 = 0;

   928 

   929     for ( temp1 = 0, temp2 = 0; ( TInt )temp1 < aData.Length(); ++temp1 )

   930         {

   931         if ( ValidB64CharL( *( aData.Ptr() + temp1 ) ) )

   932             {

   933             ++temp2;

   934             if ( temp2 == 4 )

   935                 {

   936                 consumed = const_cast< TUint8* >( aData.Ptr() ) + temp1;

   937                 temp2 = 0;

   938                 }

   939             }

   940         }

   941     

   942     if ( consumed != aData.Ptr() )

   943         {

   944         User::LeaveIfError( b64decode( const_cast< TUint8* >( aData.Ptr() ), 

   945                                        consumed - aData.Ptr() + 1,

   946                                        const_cast< TUint8* >( aData.Ptr() ), 

   947                                        &temp1 ) );

   948         

   949         aData.Set( aData.Ptr(), temp1 );

   950 

   951         temp1 = consumed - aData.Ptr() + 1;

   952         }

   953         

   954     else

   955         {

   956         aData.Set( aData.Ptr(), 0 );

   957         temp1 = 0;

   958         }

   959 

   960     return static_cast< TInt >( temp1 );

   961     }

   962 

   963 // -----------------------------------------------------------------------------

   964 // CDRMMessageParser::StripEndLineL

   965 // Remove \r\n from the end of the line. Update aBuf accordingly.

   966 // It is allowed that only \n exists, since some WAP gateways used to

   967 // strip \r's.

   968 // -----------------------------------------------------------------------------

   969 //

   970 void CDRMMessageParser::StripEndLineL( TPtrC8& aBuf )

   971     {

   972     TInt newSize( aBuf.Length() );

   973     

   974     if ( aBuf.Right( 1 ) == KNewLine )

   975         {

   976         --newSize;

   977         

   978         if ( ( aBuf.Length() > 1 ) && 

   979             ( aBuf.Right( 2 ) == KEndLine ) )

   980             {

   981             --newSize;

   982             }

   983         

   984         aBuf.Set( aBuf.Left( newSize ) );

   985         }

   986     else

   987         {

   988         SetBrokenStateL( KDRMMessageMalformed );

   989         }

   990     }

   991 

   992 // -----------------------------------------------------------------------------

   993 // CDRMMessageParser::IsBoundary

   994 // Check if the given line is a boundary line. Also check if the line is

   995 // the end boundary.

   996 // -----------------------------------------------------------------------------

   997 //

   998 TBool CDRMMessageParser::IsBoundary( const TDesC8& aLine, TBool& aLast ) const 

   999     {

  1000     TBool res = EFalse;

  1001     

  1002     __ASSERT_DEBUG( iBoundary, User::Invariant() );

  1003     

  1004     if ( iState & EGotBoundary )

  1005         {

  1006         if ( aLine.Length() > KBoundaryMarkLength + iBoundary->Length() )

  1007             {

  1008             TPtrC8 tmp( NULL, 0 );

  1009             

  1010             if ( ( aLine.Left( KBoundaryMarkLength ) == KBoundaryMark ) &&

  1011                 ( aLine.Mid( KBoundaryMarkLength, iBoundary->Length() ).

  1012                 Compare( *iBoundary ) == 0 ) )

  1013                 {

  1014                 res = ETrue;

  1015                 

  1016                 tmp.Set( aLine.Right( aLine.Length() - 

  1017                     KBoundaryMarkLength - 

  1018                     iBoundary->Length() ) );

  1019                 

  1020                 if ( ( tmp.Length() >= KBoundaryMarkLength ) &&

  1021                     ( tmp.Left( KBoundaryMarkLength ) == KBoundaryMark ) )

  1022                     {

  1023                     aLast = ETrue;

  1024                     }

  1025                 }

  1026             }

  1027         }

  1028     

  1029     return res;

  1030     }

  1031 

  1032 // -----------------------------------------------------------------------------

  1033 // CDRMMessageParser::HandleFlContentL

  1034 // Process FL/CD rights object.

  1035 // -----------------------------------------------------------------------------

  1036 //

  1037 void CDRMMessageParser::HandleFlContentL()

  1038     {

  1039     __ASSERT_DEBUG( !( iState & EDCFFile ), User::Invariant() );

  1040     

  1041     if ( iRightsData )

  1042         {

  1043         HBufC8* cid( NULL );

  1044         HBufC8* buf( NULL );

  1045         

  1046         // RO was found from DRM message.

  1047         CreateCDCIDL( cid );

  1048         CleanupStack::PushL( cid );

  1049       

  1050         buf = iRightsData;

  1051         CleanupStack::PushL( buf );

  1052         iRightsData = NULL;

  1053         

  1054         ProcessRightsDataL( *cid, 

  1055                             *buf );

  1056         

  1057         CleanupStack::PopAndDestroy(); // buf

  1058         CleanupStack::PopAndDestroy(); // cid

  1059         }

  1060     else

  1061         {

  1062         TInt error = RetrieveFlRights();

  1063         if ( error )

  1064             {

  1065             SetBrokenStateL( error );

  1066             }

  1067         }

  1068     }

  1069 

  1070 // -----------------------------------------------------------------------------

  1071 // CDRMMessageParser::ProcessRightsData

  1072 // Process DRM message -style rights object and fetch it to iRightsObject if 

  1073 // necessary.

  1074 // -----------------------------------------------------------------------------

  1075 //

  1076 void CDRMMessageParser::ProcessRightsDataL( 

  1077                             const TDesC8& aCID,

  1078                             const TDesC8& aData )

  1079     {

  1080     __ASSERT_DEBUG( !iRightsObject, User::Invariant() );

  1081     

  1082     TInt start = aData.Find(KRightsStartTag);

  1083     TInt end = aData.LocateReverse('>');

  1084     

  1085     if ( start >= 0 && end > start )

  1086         {

  1087         TDRMUniqueID localID( 0 );

  1088         CDrmRightsParser* parser( NULL );

  1089         CDRMAsset* asset( NULL );

  1090         RDRMRightsClient client;

  1091         TPtrC8 ptr( &aData[start], end - start + 1 );

  1092         TBuf8< KDCFKeySize > key;

  1093         key.SetLength(KDCFKeySize);

  1094         RPointerArray< CDRMRights > rights;

  1095         

  1096         TCleanupItem cleanup( DoResetAndDestroy, &rights );

  1097         CleanupStack::PushL( cleanup );

  1098         

  1099         User::LeaveIfError( client.Connect() );

  1100         CleanupClosePushL( client );

  1101         

  1102         parser = CDrmRightsParser::NewL();

  1103         CleanupStack::PushL( parser );

  1104         

  1105         parser->ParseL( ptr, rights );

  1106         

  1107         if (rights.Count()==0)

  1108         	{

  1109         	User::Leave(KErrCorrupt);

  1110         	}

  1111         

  1112         client.GetRandomDataL(key);

  1113 

  1114         User::LeaveIfError( client.AddRecord(

  1115                             key, 

  1116                             rights[0]->GetPermission(), 

  1117                             aCID, 

  1118                             localID) );

  1119         

  1120         iRightsObject = CDRMRights::NewL();

  1121         

  1122         asset = CDRMAsset::NewLC();

  1123         asset->iUid = aCID.AllocL();

  1124         

  1125         iRightsObject->SetAssetL(*asset);

  1126         iRightsObject->SetPermissionL(rights[0]->GetPermission());

  1127         

  1128         CleanupStack::PopAndDestroy( 4 ); // asset, parser, client, rights

  1129         }

  1130     else

  1131         {

  1132         SetBrokenStateL( KErrArgument );

  1133         }

  1134     }