1 /*

     2 * Copyright (c) 2003 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:  Imps engine wbxml message decoder

    15 *

    16 *

    17 */

    18 

    19 

    20 // INCLUDE FILES

    21 #include    <apparc.h>

    22 #include    <s32mem.h>

    23 #include    <utf.h>

    24 #include    <e32std.h>

    25 

    26 #include    "ImpsDecodewbxml.h"

    27 #include    "Imps_1_1_Tokens.h"

    28 #include    "Imps_1_2_Tokens.h"

    29 #include    "ImpsDataAccessorApi.h"

    30 #include    "ImpsErrors.h"

    31 #include    "ImpsWbXmlCommon.h"

    32 #include    "ImpsVariantAPI.h"

    33 #include    "impsutils.h"

    34 #include    "ImpsFields.h"

    35 #include    "ImpsDataUtils.h"

    36 

    37 //LITERALS

    38 // TODO: This could be changed so that the NS form the message itself is used!

    39 // There is no simple solution for proper attribute handling because of the callback

    40 // interface logic!!!

    41 

    42 _LIT8( KAttr11, " xmlns=\"http://www.wireless-village.org/TRC1.1\"");

    43 _LIT8( KAttr12, " xmlns=\"http://www.openmobilealliance.org/DTD/WV-TRC1.2\"");

    44 _LIT8( KPresSubListAttr11, " xmlns=\"http://www.wireless-village.org/PA1.1\"");

    45 _LIT8( KPresSubListAttr12,  " xmlns=\"http://www.openmobilealliance.org/DTD/WV-PA1.2\"");

    46 

    47 // Maximum length of the element in DTD

    48 const TInt KDtdElementMaxLength = 100;

    49 

    50 // ==================== LOCAL FUNCTIONS ====================

    51 

    52 // ---------------------------------------------------------

    53 // TagStart

    54 // Callback function for handling tag begin

    55 // Returns: NW_Status_t indicates success

    56 // ---------------------------------------------------------

    57 //

    58 NW_Status_t TagStart(NW_WBXML_Parser_t* aParser, void* aContext)

    59     {

    60 

    61     if(aParser)

    62     {

    63         ((CImpsDecodeWbXml*)aContext)->SetState(EImpsDecodeStateTagStart);

    64     }

    65     return NW_STAT_SUCCESS;

    66     }

    67 

    68 // ---------------------------------------------------------

    69 // AttributeStart

    70 // Callback function for handling attribute begin

    71 // Returns: NW_Status_t indicates success

    72 // ---------------------------------------------------------

    73 //

    74 NW_Status_t AttributeStart(NW_WBXML_Parser_t* aParser, void* aContext)

    75     {

    76  

    77     if(aParser)

    78     {

    79         ((CImpsDecodeWbXml*)aContext)->SetState(EImpsDecodeStateAttributeStart);

    80     }

    81     return NW_STAT_SUCCESS;

    82     }

    83 

    84 // ---------------------------------------------------------

    85 // Binary

    86 // Callback function for handling WBXML binary data

    87 // Returns: NW_Status_t indicates success

    88 // ---------------------------------------------------------

    89 //

    90 NW_Status_t Binary(NW_WBXML_Parser_t* aParser,TUint32 aValue, void* aContext)

    91     {

    92     

    93     if(aParser)

    94     {

    95         NW_Status_t rcode = NW_STAT_SUCCESS;

    96         TRAPD(error,rcode = ((CImpsDecodeWbXml*)aContext)->StoreTokenL(aValue));

    97         if(error != KErrNone)

    98         {

    99             return NW_STAT_FAILURE;

   100         }

   101         else

   102         {

   103             return rcode;

   104         }

   105     }

   106     else

   107     {

   108         return NW_STAT_FAILURE;

   109     }

   110 

   111     }

   112 

   113 // ---------------------------------------------------------

   114 // FQTokenL

   115 // Callback function for handling WBXML tokens

   116 // Returns: NW_Status_t indicates success

   117 // ---------------------------------------------------------

   118 //

   119 NW_Status_t FQTokenL(NW_WBXML_Parser_t* aParser,TUint32 aFqtoken, void* aContext)

   120     {

   121 

   122     if(aParser)

   123     {

   124         NW_Status_t rcode = NW_STAT_SUCCESS;

   125         TRAPD(error,rcode = ((CImpsDecodeWbXml*)aContext)->StoreTokenL(aFqtoken));

   126         if(error != KErrNone)

   127         {

   128             return NW_STAT_FAILURE;

   129         }

   130         else

   131         {

   132             return rcode;

   133         }

   134     }

   135     return NW_STAT_FAILURE;

   136     }

   137 

   138 // ---------------------------------------------------------

   139 // InlineStringL

   140 // Callback function for handling WBXML inline strings

   141 // Returns: NW_Status_t indicates success

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

   143 //

   144 NW_Status_t InlineStringL(NW_WBXML_Parser_t* aParser,TUint32 aLength, void* aContext)

   145     {

   146     

   147     if(aParser)

   148     {

   149         NW_Status_t rcode = NW_STAT_SUCCESS;

   150         TRAPD(error,rcode = ((CImpsDecodeWbXml*)aContext)->StoreInlineStringL(aParser,aLength));

   151         if(error != KErrNone)

   152         {

   153             return NW_STAT_FAILURE;

   154         }

   155         else

   156         {

   157             return rcode;

   158         }

   159     }

   160     

   161     return NW_STAT_SUCCESS;

   162     }

   163 

   164 // ---------------------------------------------------------

   165 // TableStringL

   166 // Callback function for handling WBXML string table strings

   167 // Returns: NW_Status_t indicates success

   168 // ---------------------------------------------------------

   169 //

   170 NW_Status_t TableStringL(NW_WBXML_Parser_t* aParser,TUint32 aIndex, void* aContext)

   171     {

   172     

   173     if(aParser)

   174     {

   175         NW_Status_t rcode = NW_STAT_SUCCESS;

   176         TRAPD(error,rcode = ((CImpsDecodeWbXml*)aContext)->StoreTableStringL(aIndex));

   177         if(error != KErrNone)

   178         {

   179             return NW_STAT_FAILURE;

   180         }

   181         else

   182         {

   183             return rcode;

   184         }

   185     }

   186     else

   187     {

   188         return NW_STAT_FAILURE;

   189     }

   190     }

   191 

   192 // ---------------------------------------------------------

   193 // Extension

   194 // Callback function for handling WBXML extension tokens

   195 // Returns: NW_Status_t indicates success

   196 // ---------------------------------------------------------

   197 //

   198 NW_Status_t Extension(NW_WBXML_Parser_t* aParser,void* aContext)

   199     {

   200     

   201     if(aParser)

   202     {

   203         ((CImpsDecodeWbXml*)aContext)->SetState(EImpsDecodeStateExtension);

   204     }

   205     

   206     return NW_STAT_SUCCESS;

   207     }

   208 

   209 // ---------------------------------------------------------

   210 // Opaque

   211 // Callback function for handling WBXML opaque data

   212 // Returns: NW_Status_t indicates success

   213 // ---------------------------------------------------------

   214 //

   215 NW_Status_t Opaque(NW_WBXML_Parser_t* aParser,TUint32 aLength, void* aContext)

   216     {

   217     

   218     return(((CImpsDecodeWbXml*)aContext)->StoreOpaqueData(aParser,aLength));

   219     

   220     }

   221 

   222 // ---------------------------------------------------------

   223 // BinaryL

   224 // Callback function for handling WBXML binary data

   225 // Returns: NW_Status_t indicates success

   226 // ---------------------------------------------------------

   227 //

   228 NW_Status_t BinaryL(NW_WBXML_Parser_t* aParser,TUint32 aValue, void* aContext)

   229     {

   230     

   231     if(aParser)

   232     {

   233         NW_Status_t rcode = NW_STAT_SUCCESS;

   234         TRAPD(error,rcode = ((CImpsDecodeWbXml*)aContext)->StoreTokenL(aValue));

   235         if(error != KErrNone)

   236         {

   237             return NW_STAT_FAILURE;

   238         }

   239         else

   240         {

   241             return rcode;

   242         }

   243     }

   244     else

   245     {

   246         return NW_STAT_FAILURE;

   247     }

   248     

   249     }

   250 

   251 // ---------------------------------------------------------

   252 // StartDocument

   253 // Callback function for handling wbxml document header information

   254 // Returns: NW_Status_t indicates success

   255 // ---------------------------------------------------------

   256 //

   257 

   258 NW_Status_t StartDocument(NW_WBXML_Parser_t* aParser,

   259                           NW_WBXML_Document_t* aDocument, void* aContext)

   260     {

   261     

   262     if(aParser)

   263     {

   264         return(((CImpsDecodeWbXml*)aContext)->StoreDocument(aDocument));

   265     }

   266     return NW_STAT_SUCCESS;

   267 

   268     }

   269 

   270 // ---------------------------------------------------------

   271 // AttributeValue

   272 // Callback function for handling attribute value

   273 // Returns: NW_Status_t indicates success

   274 // ---------------------------------------------------------

   275 //

   276 NW_Status_t AttributeValue(NW_WBXML_Parser_t* aParser, void* aContext)

   277     {

   278     

   279     if(aParser)

   280     {

   281         ((CImpsDecodeWbXml*)aContext)->SetState(EImpsDecodeStateAttributeValue);

   282     }

   283     

   284     return NW_STAT_SUCCESS;

   285     }

   286 

   287 // ---------------------------------------------------------

   288 // TagEndL

   289 // Callback function for handling tag end

   290 // Returns: NW_Status_t indicates success

   291 // ---------------------------------------------------------

   292 //

   293 

   294 NW_Status_t TagEndL(NW_WBXML_Parser_t* aParser, void* aContext)

   295     {

   296     

   297     if(aParser)

   298     {   

   299         NW_Status_t rcode = NW_STAT_SUCCESS;

   300         TRAPD(error,rcode = ((CImpsDecodeWbXml*)aContext)->TagEndHandleL( ));

   301         if(error != KErrNone)

   302         {

   303             return NW_STAT_FAILURE;

   304         }

   305         else

   306         {

   307             return rcode;

   308         }

   309     }

   310     else

   311     {

   312         return NW_STAT_FAILURE;

   313     }

   314     

   315     }

   316 

   317 // ---------------------------------------------------------

   318 // Content

   319 // Callback function for handling WBXML content

   320 // Returns: NW_Status_t indicates success

   321 // ---------------------------------------------------------

   322 //

   323 NW_Status_t Content(NW_WBXML_Parser_t* aParser, void* aContext)

   324     {

   325 

   326     if(aParser)

   327     {

   328         ((CImpsDecodeWbXml*)aContext)->SetState(EImpsDecodeStateContent);

   329     }

   330     

   331     return NW_STAT_SUCCESS;

   332     

   333     }

   334 

   335 // ---------------------------------------------------------

   336 // EntityL

   337 // Callback function for handling WBXML entity

   338 // Returns: NW_Status_t indicates success

   339 // ---------------------------------------------------------

   340 //

   341 NW_Status_t EntityL(NW_WBXML_Parser_t* aParser, TUint32 aValue, void* aContext)

   342     {

   343     

   344     if(aParser)

   345     {

   346         if(aValue)

   347         {

   348             TRAPD(error, ((CImpsDecodeWbXml*)aContext)->DecodeEntityL(aValue));

   349             if(error != KErrNone)

   350             {

   351                 return NW_STAT_FAILURE;

   352             }

   353         }

   354     }

   355     

   356     return NW_STAT_SUCCESS;

   357     

   358     }

   359 

   360 // ---------------------------------------------------------

   361 // Exception

   362 // Callback function for handling WBXML parser exceptions

   363 // Returns: NW_Status_t indicates success

   364 // ---------------------------------------------------------

   365 //

   366 NW_Status_t Exception(NW_WBXML_Parser_t* aParser,NW_WBXML_Exception_t aException, void* aContext)

   367     {

   368     

   369     if(aParser)

   370     {

   371     

   372         ((CImpsDecodeWbXml*)aContext)->ExceptionHandle(aException);

   373     }

   374     

   375     return NW_STAT_FAILURE;

   376     

   377     }

   378 

   379 // ================= MEMBER FUNCTIONS =======================

   380 

   381 // C++ default constructor can NOT contain any code, that

   382 // might leave.

   383 //

   384 CImpsDecodeWbXml::CImpsDecodeWbXml():

   385     iDecodeToXml(EFalse),

   386     iTransactions(0),

   387     iTypeStatus(EFalse),

   388     iPureMessageType( EImpsMessageNone )

   389     {

   390     

   391     }

   392 

   393 // default constructor can leave.

   394 void CImpsDecodeWbXml::ConstructL()

   395     {

   396         // create buffers for data handling

   397     

   398     iStoreValue8   = HBufC8::NewL(KImpsWbXmlMaxStringLength);

   399     iElementValue  = HBufC8::NewL(KImpsWbXmlMaxStringLength);

   400     iStoreValue    = HBufC::NewL(KImpsWbXmlMaxStringLength);

   401 

   402     // create handler for wbxml data

   403     iWbXmlData = CImpsWbXmlData::NewL( );

   404 

   405     // PEC in use ?

   406     CImpsVariant* dpb = CImpsVariant::NewLC();

   407     if (dpb->IsFeatureSupportedL(EDpb))

   408     {

   409         iXmlUtils = CImpsXmlUtils::NewL( );

   410         iPEC = ETrue;

   411     }

   412     else

   413     {

   414         iXmlUtils = NULL;

   415         iPEC = EFalse;

   416     }

   417     CleanupStack::PopAndDestroy( );

   418 

   419     iCurrentDictionary = iDictionaryCount = 0;

   420     iDictionaries[iDictionaryCount++] = 

   421         (NW_WBXML_Dictionary_s*)&NW_Imps_1_1_WBXMLDictionary;

   422     iDictionaries[iDictionaryCount++] = 

   423         (NW_WBXML_Dictionary_s*)&NW_Imps_1_2_WBXMLDictionary;

   424     if(NW_WBXML_Dictionary_initialize (iDictionaryCount,iDictionaries) != NW_STAT_SUCCESS)

   425         {

   426         User::Leave(KImpsErrorEncode);

   427         }

   428 

   429 

   430     iStack = new(ELeave) CStack<NW_String_UCS2Buff_t, EFalse>();

   431     }

   432 

   433 // Two-phased constructor.

   434 CImpsDecodeWbXml* CImpsDecodeWbXml::NewL( MImpsCSPSession* /*aCallback*/ )

   435     {

   436 

   437     CImpsDecodeWbXml* self = new (ELeave) CImpsDecodeWbXml;

   438     

   439     CleanupStack::PushL( self );

   440     self->ConstructL();

   441     CleanupStack::Pop();

   442 

   443     return self;

   444     }

   445 

   446     

   447 // Destructor

   448 CImpsDecodeWbXml::~CImpsDecodeWbXml()

   449     {

   450     

   451     delete iWbXmlData;

   452     delete iStoreValue;

   453     delete iStoreValue8;

   454     delete iElementValue;

   455     delete iXmlUtils;

   456     delete iStack;

   457 

   458     NW_WBXML_Dictionary_destroy(); 

   459     }

   460 

   461 // ---------------------------------------------------------

   462 // CImpsDecodeXml::DecodeMsgAsyncL

   463 // ---------------------------------------------------------

   464 //

   465 TInt CImpsDecodeWbXml::DecodeMsgAsyncL( HBufC8** aBuffer )

   466     {

   467 

   468     // TODO: implement it!

   469     __ASSERT_DEBUG(aBuffer, User::Panic(KImpsPanicCategory, KErrArgument));

   470     delete *aBuffer;

   471     *aBuffer = NULL; // indicate that the ownerships was taken

   472     return 0;

   473     }

   474 

   475 // ---------------------------------------------------------

   476 // CImpsDecodeXml::DecodeMessageL

   477 // ---------------------------------------------------------

   478 //

   479 void CImpsDecodeWbXml::CancelDecoding()

   480     {

   481     // TODO: implement it!

   482 //    TTime finished;

   483 //    finished.HomeTime();

   484 //    TReal sec = finished.MicroSecondsFrom(started).Int64()/1000000.0;

   485     }

   486 

   487 

   488 // ---------------------------------------------------------

   489 // CImpsDecodeXml::DecodeMessageL

   490 // IMPS engine WBXML message decoder main function and API for user

   491 // aImpsData provides data storage for parsed out values

   492 // aDecodeBuffer contains message to be decoded

   493 // if error occurs method leaves with error code

   494 // ---------------------------------------------------------

   495 //

   496 void CImpsDecodeWbXml::DecodeMessageL(

   497     MImpsDataAccessor& aImpsData,

   498     HBufC8**  aDecodeBuffer )

   499     {

   500 

   501     __ASSERT_DEBUG(aDecodeBuffer, User::Panic(KImpsPanicCategory, KErrArgument));

   502     HBufC8* decodeBuffer = *aDecodeBuffer;

   503     *aDecodeBuffer = NULL; // indicate that the ownership was taken;

   504     CleanupStack::PushL(decodeBuffer); // take the message buffer

   505     iImpsData = &aImpsData;

   506         

   507     // initializing the XML decoder states

   508     iTransactions = 0;

   509     iDecodeToXml = EFalse;

   510     iTypeStatus = EFalse;

   511     iStack->Reset();

   512     //////////////////////////////////////

   513    

   514 

   515     // CREATE AND INITIALIZE WBXML PARSER

   516     NW_WBXML_Parser_t WBXML_parser;

   517     NW_WBXML_Parser_newInPlace(&WBXML_parser);

   518     WBXML_parser.ext_t_not_table_index = NW_TINYDOM_EXTENSION_TYPE_EXT_T_INTEGER;

   519     WBXML_parser.recursiveCallCnt = 0;

   520 

   521     // CREATE EVENT HANDLER AND SET EVENT HANDLER CALLBACK

   522     // FUNCTION POINTERS

   523     NW_WBXML_EventHandler_t WBXML_event_handler;

   524     WBXML_event_handler.StartDocument_CB = StartDocument;

   525     WBXML_event_handler.EndDocument_CB = NULL;

   526     WBXML_event_handler.Pi_CB = NULL;

   527     WBXML_event_handler.Tag_Start_CB = TagStart;

   528     WBXML_event_handler.Tag_End_CB = TagEndL;

   529     WBXML_event_handler.Attr_Start_CB = AttributeStart;

   530     WBXML_event_handler.Attr_Val_CB = AttributeValue;

   531     WBXML_event_handler.Content_CB = Content;

   532     WBXML_event_handler.CodePage_CB = NULL;

   533     WBXML_event_handler.Extension_CB = Extension;

   534     WBXML_event_handler.FQToken_CB = FQTokenL;

   535     WBXML_event_handler.InlineString_CB = InlineStringL;

   536     WBXML_event_handler.TableString_CB = TableStringL;

   537     WBXML_event_handler.Opaque_CB = Opaque;

   538     WBXML_event_handler.Binary_CB = BinaryL;

   539     WBXML_event_handler.Entity_CB = EntityL;

   540     WBXML_event_handler.Exception_CB = Exception;

   541 

   542         // REGISTER EVENT HANDLER TO PARSER

   543     NW_Status_t status = NW_WBXML_Parser_registerHandler(&WBXML_parser,&WBXML_event_handler,(void*)this);

   544     if(status != NW_STAT_SUCCESS)

   545     {

   546         User::Leave(KImpsErrorDecode);

   547     }

   548 

   549     iNameSpace = KImpsNameSpaceCspMessage;

   550     iPreviousNameSpace = KImpsNameSpaceCspMessage;

   551 

   552     // PREPARE PARSER AND START PARSING

   553 //    iVersion.Copy(KImpsMessageVersion);

   554     NW_WBXML_Document_t document;

   555 //    document.doc_type = NULL;

   556     NW_WBXML_Document_construct(&document,KImpsWvCsp11PublicIdentifier);

   557     TUint32 size = decodeBuffer->Size();

   558 //    iDecodeBuffer->ResizeL(size+1);

   559     TPtr8 p = decodeBuffer->Des();

   560 //    p.SetLength(size);

   561     const unsigned char *buffer = decodeBuffer->Ptr();

   562 

   563     // GET DATA ACCESS KEY FROM DATA STORAGE

   564     iAccessKey = iImpsData->NewKeyL();

   565 

   566     // change wbxml public document identifier for IOP purposes

   567     // Assume that Unknown ID is CSP 1.1

   568     if(p[KImpsWbXmlPublicID] == KImpsWbXmlPublicIdUnknown)

   569     {

   570         p[KImpsWbXmlPublicID] = KImpsWvCsp11PublicIdentifier;

   571     }

   572 

   573     // START PARSER

   574     iError = KErrNone;

   575     iDecodingState = EImpsDecodeStateContent;

   576     status = NW_WBXML_Parser_parseBuffer(&WBXML_parser,&document,(unsigned char*)buffer,size);

   577 

   578     NW_WBXML_Document_destruct(&document);

   579     iAccessKey->Destroy( );

   580 

   581     if(status != NW_STAT_SUCCESS)

   582     {

   583         if(iError == KErrNone)

   584         {

   585             User::Leave(KImpsErrorDecode);

   586         }

   587         else

   588         {

   589             User::Leave(iError);

   590         }

   591     }

   592 

   593     CleanupStack::PopAndDestroy(); // message buffer

   594     }

   595 

   596 // ---------------------------------------------------------

   597 // CImpsDecodeWbXml::SetState

   598 // method updates current parser state

   599 // ---------------------------------------------------------

   600 //

   601 void CImpsDecodeWbXml::SetState(TImpsDecodeState aState)

   602     {

   603     

   604 

   605     iDecodingState = aState;

   606     

   607     }

   608 

   609 // ---------------------------------------------------------

   610 // CImpsDecodeWbXml::StoreDocument

   611 // method verifies document header information

   612 // ---------------------------------------------------------

   613 //

   614 NW_Status_t CImpsDecodeWbXml::StoreDocument(NW_WBXML_Document_t* aDocument)

   615     {

   616     

   617     if(aDocument->version !=  KImpsWbXmlVersion)

   618     {

   619         return NW_STAT_FAILURE;

   620     }

   621     if(aDocument->charset !=  KImpsDefaultCharset)

   622     {

   623         return NW_STAT_FAILURE;

   624     }

   625 

   626     if(aDocument->publicid==KImpsWvCsp12PublicIdentifier)

   627         {

   628         iImpsData->GetImpsFields()->SetCspVersion(EImpsCspVersion12);

   629         }

   630     else // the default CSP version is 1.1

   631         {

   632         iImpsData->GetImpsFields()->SetCspVersion(EImpsCspVersion11);

   633         }

   634 

   635     iDocument = aDocument;

   636     return NW_STAT_SUCCESS;

   637 

   638     }

   639 

   640 // ---------------------------------------------------------

   641 // CImpsDecodeWbXml::ExceptionHandle

   642 // method for parser exception handling

   643 // ---------------------------------------------------------

   644 //

   645 void CImpsDecodeWbXml::ExceptionHandle(NW_WBXML_Exception_t aException)

   646     {

   647     

   648     iError = (TInt)aException;

   649 

   650     }

   651 

   652 // ---------------------------------------------------------

   653 // CImpsDecodeWbXml::TagEndHandleL

   654 // method stores parsed out data to data accessor and removes

   655 // token from data accessor key

   656 // ---------------------------------------------------------

   657 //

   658 NW_Status_t CImpsDecodeWbXml::TagEndHandleL( )

   659     {

   660     

   661     //////////////////////////////////////////////////////////////////////////

   662     if (iDecodeToXml)

   663         {

   664         if ( !iStack->IsEmpty() )

   665             {

   666             NW_String_UCS2Buff_t* nw_str = iStack->Pop();

   667             TBuf8<KDtdElementMaxLength> elementString;

   668             ConvertToDes8((TUint16*)nw_str->bytes, elementString);

   669             iXmlUtils->EndElementL(elementString);

   670             }

   671         else

   672             {

   673             // we are done with TransactionContent

   674             iDecodeToXml = EFalse;

   675 

   676             iXmlUtils->StorePureDataL(*iImpsData, iTransactions-1, iPureMessageType );

   677                    

   678             // reseting the XML decoder states

   679             // the transaction number is not reseted as there can be more in the message

   680             iDecodeToXml = EFalse;

   681             // reset the variable

   682             iPureMessageType = EImpsMessageNone;

   683             iNameSpace = KImpsNameSpaceCspMessage;

   684             iPreviousNameSpace = KImpsNameSpaceCspMessage;

   685             iStack->Reset();

   686             if (iTypeStatus)

   687                 {

   688                 iTypeStatus = EFalse;

   689                 iAccessKey->PopL();

   690                 }

   691             else

   692                 {

   693                 // clean the IMPS keys too

   694                 // POP Transaction and TransactionContent

   695                 iAccessKey->PopL(2);

   696                 return NW_STAT_SUCCESS;

   697                 }

   698 

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

   700             }

   701         if (!iTypeStatus)

   702             {

   703             return NW_STAT_SUCCESS;

   704             }

   705         }

   706 

   707     //////////////////////////////////////////////////////////////////////////

   708     

   709 

   710     TInt type = 0;

   711     

   712     if(iAccessKey->Count())

   713         {

   714         type = iImpsData->KeyTypeL(iAccessKey);

   715         }

   716     else

   717         {

   718         type = EImpsDataTypeNone;

   719         }

   720     

   721     if ( type == EImpsDataTypeContentData )

   722         {

   723         type = TImpsDataUtils::GetContentDataTypeL( iImpsData, ( iTransactions-1 ) );

   724         }

   725 

   726     if(type == EImpsDataTypeNone || type == EImpsDataTypeNotSupported)

   727         {

   728         iExtension = 0;

   729         iOpaque.length = 0;

   730         iElementValue->Des().Zero();

   731         }

   732     else if(type == EImpsDataTypeInt)

   733         {

   734         if(iExtension == NW_WBXML_EXT_T_0 || iExtension == NW_WBXML_EXT_T_1 || iExtension == NW_WBXML_EXT_T_2)

   735             {

   736             TInt value = iWbXmlData->GetImpsEngineValue(iElementToken,iExtensionValue);

   737             if(value != KErrNotFound) iImpsData->StoreIntegerL(iAccessKey,value);

   738             iExtension = 0;

   739             }

   740         else if(iOpaque.length)

   741             {

   742             TInt value = 0;

   743             if (iOpaque.data)

   744             	{

   745 	            for(TUint8 i=0;i<iOpaque.length;i++) 

   746 	                {

   747 	                value = (value << 8) + iOpaque.data[i];

   748 	                }

   749             	}

   750             iImpsData->StoreIntegerL(iAccessKey,value);

   751             iOpaque.length = 0;

   752             if(iElementToken == KImpsWbXmlContentSize)

   753                 {

   754                 iContentSize = value;

   755                 }

   756             }

   757         else if(iElementValue->Des().Length())

   758             {

   759             if(iExtension == NW_WBXML_EXT_I_0 || iExtension == NW_WBXML_EXT_I_1 || iExtension == NW_WBXML_EXT_I_2)

   760                 {

   761                 iExtension = 0;

   762                 }

   763             else

   764                 {

   765                 TInt value = iWbXmlData->GetImpsEngineValue(iElementToken,iElementValue->Des());

   766                 if(value == KImpsWbXmlDataNotFound)

   767                     {

   768                     // Try to convert the string to integer

   769                     TLex8 tmp(iElementValue->Des());

   770                     if (tmp.Val(value) != KErrNone )

   771                         {

   772                         // Cannot be converted

   773                         return NW_STAT_FAILURE;

   774                         }

   775                     }

   776                 iImpsData->StoreIntegerL(iAccessKey,value);

   777                 }

   778             iElementValue->Des().Zero();

   779             }

   780         }

   781     else if(type == EImpsDataTypeBoolean)

   782         {

   783         if(iExtension == NW_WBXML_EXT_T_0 || iExtension == NW_WBXML_EXT_T_1 || iExtension == NW_WBXML_EXT_T_2)

   784             {

   785             TInt value = iWbXmlData->GetImpsEngineValue(iElementToken,iExtensionValue);

   786             if(value != KErrNotFound)

   787                 {

   788                 iImpsData->StoreBooleanL(iAccessKey,value);

   789                 }

   790             iExtension = 0;

   791             }

   792         else if(iOpaque.length)

   793             {

   794             iImpsData->StoreBooleanL(iAccessKey,(TInt)*iOpaque.data);

   795             iOpaque.length = 0;

   796             }

   797         }

   798     else if(type == EImpsDataTypeDesc8)

   799         {

   800         iStoreValue8->Des().Zero();

   801         if(iExtension == NW_WBXML_EXT_T_0 || iExtension == NW_WBXML_EXT_T_1 || iExtension == NW_WBXML_EXT_T_2)

   802             {

   803             iStoreValue8->Des().Copy(iWbXmlData->GetImpsEngineDesc8Value(iElementToken,iExtensionValue));

   804             iExtension = 0;

   805             }

   806         if(iElementValue->Des().Length())

   807             {

   808             if(iExtension == NW_WBXML_EXT_I_0 || iExtension == NW_WBXML_EXT_I_1 || iExtension == NW_WBXML_EXT_I_2)

   809                 {

   810                 iExtension = 0;

   811                 }

   812             else

   813                 {

   814                 if((iElementValue->Des().Length() + (iStoreValue8->Des().Length()) > iStoreValue8->Des().MaxLength()))

   815                     {

   816                     HBufC8* ptr = HBufC8::NewL(iStoreValue8->Des().Length() + iElementValue->Des().Length());

   817                     ptr->Des().Append(iStoreValue8->Des());

   818                     delete iStoreValue8;

   819                     iStoreValue8 = ptr;

   820                     }

   821                 iStoreValue8->Des().Append(iElementValue->Des());

   822                 }

   823             iElementValue->Des().Zero();

   824             }

   825         else if(iOpaque.length)

   826             {

   827             if(((TInt)iOpaque.length + iStoreValue8->Des().Length()) > iStoreValue8->Des().MaxLength())

   828                 {

   829                 HBufC8* ptr = HBufC8::NewL(iStoreValue8->Des().Length() + iOpaque.length + 1);

   830                 ptr->Des().Append(iStoreValue8->Des());

   831                 delete iStoreValue8;

   832                 iStoreValue8 = ptr;

   833                 }

   834             for(TInt i=0;i<(TInt)iOpaque.length;i++)

   835                 {

   836                 iStoreValue8->Des().Append(iOpaque.data[i]);

   837                 }

   838             iOpaque.length = 0;

   839             }

   840         if(iStoreValue8->Des().Length())

   841             {

   842             iImpsData->StoreDesc8L(iAccessKey,iStoreValue8->Des());

   843             }

   844         if(iStoreValue8->Des().Length() > KImpsWbXmlMaxBufferSize)

   845             {

   846             delete iStoreValue8;

   847             iStoreValue8 = NULL;

   848             iStoreValue8 = HBufC8::NewL(KImpsWbXmlMaxStringLength);

   849             }

   850         }

   851     else if(type == EImpsDataTypeDesc)

   852         {

   853         iStoreValue->Des().Zero();

   854         if(iExtension == NW_WBXML_EXT_T_0 || iExtension == NW_WBXML_EXT_T_1 || iExtension == NW_WBXML_EXT_T_2)

   855             {

   856             TInt token = 0;

   857             if(iNameSpace == KImpsNameSpacePresenceSubList)

   858                 {

   859                 token = iAccessKey->GetElementL((iAccessKey->Count() - 2),iKeyType);

   860 //                token = iWbXmlData->GetWbXmlTokenPre(token);

   861                 }

   862             else

   863                 {

   864                 token = iElementToken;

   865                 }

   866             iStoreValue->Des().Copy(iWbXmlData->GetImpsEngineDescValue(token,iExtensionValue));

   867             iExtension = 0;

   868             }

   869         TPtr p = iStoreValue->Des();

   870         if(iElementValue->Des().Length())

   871             {

   872             if(iExtension == NW_WBXML_EXT_I_0 || iExtension == NW_WBXML_EXT_I_1 || iExtension == NW_WBXML_EXT_I_2)

   873                 {

   874                 iExtension = 0;

   875                 }

   876             else

   877                 {

   878                 if((iElementValue->Des().Length() + iStoreValue->Des().Length()) > iStoreValue->Des().MaxLength())

   879                     {

   880                     HBufC* ptr = HBufC::NewL(iElementValue->Des().Length() + iStoreValue->Des().Length());

   881                     ptr->Des().Append(iStoreValue->Des());

   882                     delete iStoreValue;

   883                     iStoreValue = ptr;

   884                     p.Set(iStoreValue->Des());

   885                     }

   886                 if(iStoreValue->Des().Length())

   887                     {

   888                     TPtrC pp = iStoreValue->Mid(p.Length());

   889                     p.Set((unsigned short*)pp.Ptr(),0,(p.MaxLength() - p.Length()));

   890                     if(CnvUtfConverter::ConvertToUnicodeFromUtf8(p,iElementValue->Des()) != KErrNone)

   891                         {

   892                         return NW_STAT_FAILURE;

   893                         }

   894                     p.Set((unsigned short*)iStoreValue->Des().Ptr(),

   895                         (iStoreValue->Des().Length() + iElementValue->Des().Length()),

   896                         iStoreValue->Des().MaxLength());

   897                     }

   898                 else

   899                     {

   900                     if(CnvUtfConverter::ConvertToUnicodeFromUtf8(p,iElementValue->Des()) != KErrNone)

   901                         {

   902                         return NW_STAT_FAILURE;

   903                         }

   904                     }

   905                 }

   906             iElementValue->Des().Zero();

   907             }

   908         // Handle also the case when String is encoded as Opaque!

   909         if(iOpaque.length)

   910             {

   911             if ( iElementToken == (KImpsWbXmlDateTime & KImpsTokenMask) ) 

   912                 {

   913                 // !DateTime needs special handling as it is not string!

   914                 // TODO: Now just ignored, needs proper date&time decoding

   915                 }

   916             else

   917                 {

   918                 // Normal String decoding

   919                 // Check the buffer size

   920                 if(((TInt)iOpaque.length + iStoreValue->Des().Length()) > iStoreValue->Des().MaxLength())

   921                     {

   922                     HBufC* ptr = HBufC::NewL(iStoreValue->Des().Length() + iOpaque.length + 1);

   923                     ptr->Des().Append(iStoreValue->Des());

   924                     delete iStoreValue;

   925                     iStoreValue = ptr;

   926                     p.Set(iStoreValue->Des());

   927                     }

   928                 // Copy the data from opaque to string format

   929                 for(TInt i=0;i<(TInt)iOpaque.length;i++)

   930                     {

   931                     iElementValue->Des().Append(iOpaque.data[i]);

   932                     }

   933                 // convert the UTF-8 to Unicode

   934                 if(iStoreValue->Des().Length())

   935                     {

   936                     // if iStoreValue has already a string which was encoded as EXT, e.g. "http://"

   937                     TPtrC pp = iStoreValue->Mid(p.Length());

   938                     p.Set((unsigned short*)pp.Ptr(),0,(p.MaxLength() - p.Length()));

   939                     if(CnvUtfConverter::ConvertToUnicodeFromUtf8(p,iElementValue->Des()) != KErrNone)

   940                         {

   941                         return NW_STAT_FAILURE;

   942                         }

   943                     p.Set((unsigned short*)iStoreValue->Des().Ptr(),

   944                         (iStoreValue->Des().Length() + iElementValue->Des().Length()),

   945                         iStoreValue->Des().MaxLength());

   946                     }

   947                 else

   948                     {

   949                     if(CnvUtfConverter::ConvertToUnicodeFromUtf8(p,iElementValue->Des()) != KErrNone)

   950                         {

   951                         return NW_STAT_FAILURE;

   952                         }

   953                     }

   954                 }

   955             iOpaque.length = 0;

   956             iElementValue->Des().Zero();

   957             }

   958         

   959         // FIX: empty values are now stored too

   960         // if this fix causes that the TransactionContent and PresenceSubList 

   961         // will appear in the iImpsData with zero length descriptor value

   962 //        if(p.Length())

   963 //            {

   964        iImpsData->StoreDescL(iAccessKey,p);

   965 //            }

   966 

   967        // reduce the size of the buffer if needed

   968        if(iStoreValue->Des().Length() > KImpsWbXmlMaxBufferSize)

   969             {

   970             delete iStoreValue;

   971             iStoreValue = NULL;

   972             iStoreValue = HBufC::NewL(KImpsWbXmlMaxStringLength);

   973             }

   974         }

   975         else if(type == EImpsDataTypeExt)

   976             {

   977             TPtr8 name = iElementValue->Des();

   978             TPtrC8 ext = iElementValue->Mid(name.Locate(NULL) + 1);

   979             name.SetLength(name.Locate(NULL));

   980             if(name.Length())

   981                 {

   982                 iImpsData->StoreExtL(iAccessKey,name,ext);

   983                 }

   984             iElementValue->Des().Zero();

   985             }

   986         if(iAccessKey->Count())

   987             {

   988             iPreviousElement = iAccessKey->GetElementL((iAccessKey->Count() - 1),iKeyType);

   989             iPreviousNameSpace = iNameSpace;

   990             iAccessKey->PopL( );

   991             switch(iPreviousElement)

   992                 {

   993                 case EImpsKeyTransactionContent:

   994                     if(iNameSpace == KImpsNameSpaceTransactionContent)

   995                         {

   996                         iPreviousNameSpace = iNameSpace;

   997                         iNameSpace = KImpsNameSpaceCspMessage;

   998                         }

   999                     break;

  1000                     

  1001                 case EImpsKeyPresenceSubList:

  1002                     if(iNameSpace == KImpsNameSpacePresenceSubList)

  1003                         {

  1004                         iPreviousNameSpace = iNameSpace;

  1005                         iNameSpace = KImpsNameSpaceTransactionContent;

  1006                         }

  1007                     break;

  1008                     

  1009                 default:

  1010                     break;

  1011                 }

  1012             }

  1013         

  1014         return NW_STAT_SUCCESS;

  1015         

  1016     }

  1017 

  1018 // ---------------------------------------------------------

  1019 // CImpsDecodeWbXml::StoreTokenL

  1020 // method for handling wbxml tokens 

  1021 // ---------------------------------------------------------

  1022 //

  1023 NW_Status_t CImpsDecodeWbXml::StoreTokenL(TUint32 aToken)

  1024     {

  1025     

  1026     TInt impskey = 0;

  1027     TInt index = 0;

  1028 

  1029     switch(iDecodingState)

  1030     {

  1031     

  1032     case EImpsDecodeStateTagStart:

  1033     

  1034         if((aToken & KImpsByteMask) == NW_WBXML_LITERAL ||

  1035             (aToken & KImpsByteMask) == NW_WBXML_LITERAL_A ||

  1036             (aToken & KImpsByteMask) == NW_WBXML_LITERAL_AC ||

  1037             (aToken & KImpsByteMask) == NW_WBXML_LITERAL_C)

  1038             {

  1039             iDecodingState = EImpsDecodeStateLiteral;

  1040             iElementToken = aToken;

  1041             impskey = EImpsKeyPRExt;

  1042             iKeyType = EImpsKeyTypePre;

  1043             }

  1044         else

  1045             {

  1046             iElementToken = aToken & KImpsTokenMask;

  1047             

  1048             //////////////////////////////////////////////////////////////////////////

  1049             

  1050             // keep track of the transaction number in case of multitrans

  1051             if ( iElementToken == KImpsWbXmlTransaction ) 

  1052                 {

  1053                 ++iTransactions;

  1054                 }

  1055             // Decoding directly to XML

  1056 

  1057             

  1058             // We have started to write the XML even we don't know the Transaction type yet

  1059             // If the transaction type is not what we want we have to cancel the XML processing

  1060             if ( iStack->Count() == 1 )

  1061                 {

  1062                 // we have only 1 element in the stack and that is  TransactionContent

  1063                 // now we can check the Transaction type

  1064                 if ( IsPureTransaction(iElementToken) ) 

  1065                     {

  1066 #ifndef _NO_IMPS_LOGGING_

  1067                     CImpsClientLogger::Log(_L("WBXMLdecoder: decoding to XML, TR_Key %x"), iElementToken);

  1068 #endif

  1069                     iDecodeToXml = ETrue;

  1070                     // store the message type to the variable

  1071                     iPureMessageType = iElementToken;

  1072                     }

  1073                 else

  1074                     {

  1075 #ifndef _NO_IMPS_LOGGING_

  1076                     CImpsClientLogger::Log(_L("WBXMLdecoder: decoding to internal, TR_Key %x"),iElementToken);

  1077 #endif

  1078                     // Not presence transaction, let's get rid of the pushed element

  1079                     iStack->Pop(); 

  1080                     }

  1081                 }

  1082 

  1083             if ( iDecodeToXml )

  1084                 {

  1085 

  1086                 NW_String_UCS2Buff_t* nw_str = NW_WBXML_Dictionary_getTagByFqToken(aToken);

  1087                 

  1088                 if ( nw_str == NULL ) 

  1089                     {

  1090                     return NW_STAT_FAILURE;

  1091                     }

  1092 

  1093 				iStack->PushL(nw_str);

  1094 				

  1095                 TBuf8<KDtdElementMaxLength> elementString;

  1096                 ConvertToDes8((TUint16*)nw_str->bytes, elementString);

  1097 //                iXmlUtils->WriteToBufferL(_L8("<"));

  1098 //                iXmlUtils->WriteToBufferL(elementString);

  1099                 if ( iElementToken == KImpsWbXmlPresenceSubList ) 

  1100                     {

  1101                     iXmlUtils->StartElementL(elementString, 

  1102                         iDocument->publicid == 0x10 ? KPresSubListAttr11() : KPresSubListAttr12());

  1103                     }

  1104                 else

  1105                     {

  1106                     iXmlUtils->StartElementL(elementString, KNullDesC8);

  1107                     }

  1108 				

  1109 				// Status is decoded to internal too

  1110                 if ( !iTypeStatus ) 

  1111                     {

  1112                     break;

  1113                     }

  1114                 }

  1115 

  1116             // check for TransactionContent

  1117             // because the <TransactionConent> is present in pure data we must

  1118             // continue also with normal decoding

  1119             // in the next round we will get the Transaction type and can decide

  1120             // whether we need to continue to decode normally

  1121             if(iElementToken == KImpsWbXmlTransactionContent)

  1122                 {

  1123 #ifndef _NO_IMPS_LOGGING_

  1124                 CImpsClientLogger::Log(_L("WBXMLdecoder: Transaction content found"));

  1125 #endif

  1126 

  1127                 iXmlUtils->ResetL();

  1128 

  1129                 NW_String_UCS2Buff_t* nw_str = NW_WBXML_Dictionary_getTagByFqToken(aToken);

  1130                 if ( nw_str == NULL ) 

  1131                     {

  1132                     return NW_STAT_FAILURE;

  1133                     }

  1134 //                TPtrC elementPtr;

  1135 //                elementPtr.Set((TUint16*)nw_str->bytes);