1 /*

     2 * Copyright (c) 2006-2006 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:        

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 

    26 // INCLUDE FILES

    27 #include <SenXmlElement.h> // check if this include is needed(?)

    28 #include <SenXmlUtils.h>

    29 

    30 #include "wsstarrstresponse.h"

    31 #include "SenDateUtils.h"

    32 #include "senlogger.h"

    33 

    34 using namespace WSStarTrustFault;

    35 

    36 // Local CONSTANTS

    37 const TInt KStateParsingRSTResponse  = 502; // ignore state   (even number)

    38 const TInt KStateParsingPOP = 503;

    39 const TInt KStateParsingLifeTime = 505;

    40 const TInt KStateParsingEntropy = 507;

    41 const TInt KStateParsingAppliesTo = 509;

    42 const TInt KStateParsingAttachedReference = 510;//even becouse of parsing delegation

    43 const TInt KStateParsingKeySize = 511;

    44 const TInt KStateParsingSearchHeader = 512;

    45 const TInt KStateParsingHeader = 514;

    46 const TInt KStateParsingTokenType = 515;

    47 

    48 

    49 CWSStarRSTResponse* CWSStarRSTResponse::NewL(TBool aParseIssuedTokens, const TDesC8& aAppliedTo, const TDesC8* aVersion)

    50     {

    51     CWSStarRSTResponse* pNew = NewLC(aParseIssuedTokens, aAppliedTo, aVersion);

    52     CleanupStack::Pop(pNew);

    53     return pNew;

    54     }

    55 CWSStarRSTResponse* CWSStarRSTResponse::NewLC(TBool aParseIssuedTokens, const TDesC8& aAppliedTo, const TDesC8* aVersion)

    56     {

    57     CWSStarRSTResponse* pNew =

    58             new (ELeave) CWSStarRSTResponse(aParseIssuedTokens, aAppliedTo);

    59     CleanupStack::PushL(pNew);

    60     pNew->ConstructL(aVersion);

    61     return pNew;

    62     }

    63 

    64 CWSStarRSTResponse::CWSStarRSTResponse(TBool aParseIssuedTokens, const TDesC8& aAppliedTo)

    65     {

    66     iContextToken = EFalse;

    67     iIsResponse = EFalse;

    68     iCollection = EFalse;

    69     iTokenEstablished = EFalse;

    70     iDefTokenEstablished = EFalse;

    71     iParseIssuedTokens = aParseIssuedTokens;

    72     iAppliedTo.Set(aAppliedTo);

    73     if (iParseIssuedTokens)

    74         {

    75         iState = KStateParsingSearchHeader;

    76         }

    77     }

    78 

    79 void CWSStarRSTResponse::ConstructL(const TDesC8* aVersion)

    80     {

    81     iActiveXmlns = aVersion;

    82     //unlimited value

    83     iNotOnOrAfter = Time::MaxTTime();

    84     CSenBaseFragment::BaseConstructL(

    85         *aVersion,

    86         WSTrust::KRSTResponseTag

    87         );

    88 

    89     }

    90 

    91 CWSStarRSTResponse::~CWSStarRSTResponse()

    92     {

    93     delete iCredential;

    94     delete iSTRFr;

    95     delete iSTR;

    96     delete iPOPencodedAsBase64;

    97     delete iTokenType;

    98     delete iTypeOfBinary;

    99     delete iEntropySTS;

   100     delete iComputedKey;

   101     delete iCredentialExpires;

   102     delete iCredentialCreated;

   103     delete iKeySize;

   104     delete iCredentialDef;

   105     delete iSTRDef;

   106     delete iPOPencodedAsBase64Def;

   107     delete iTokenTypeDef;

   108     delete iTypeOfBinaryDef;

   109     delete iEntropySTSDef;

   110     delete iComputedKeyDef;

   111     delete iCredentialExpiresDef;

   112     delete iCredentialCreatedDef;    

   113     delete iKeySizeDef;

   114     }

   115 

   116 void CWSStarRSTResponse::StartElementL(

   117     const TDesC8& aNsUri,

   118     const TDesC8& aLocalName,

   119     const TDesC8& aQName,

   120     const RAttributeArray& aAttributes )

   121     {

   122     switch (iState)

   123         {

   124         case KStateIgnore:

   125             {    

   126             if ((aNsUri == *iActiveXmlns)&& (!iTokenEstablished))

   127                 {

   128                 iParsingApliedTo = EFalse;

   129                 if  (aLocalName == WSTrust::KRSTResponseTag)

   130                     {

   131                     iState = KStateParsingRSTResponse;

   132                     iIsResponse = ETrue;

   133                     }

   134                 else if(aLocalName == WSTrust::KRSTResponseCollectionTag)

   135                     {

   136                     iCollection = ETrue;

   137                     }

   138                 }

   139             break;

   140             }

   141         case KStateParsingRSTResponse:

   142             {            

   143             if (aNsUri == *iActiveXmlns)

   144                 {

   145                 if (aLocalName == WSTrust::KRequestedSecurityTokenTag)

   146                     {

   147                     iState = KStateParsingSingleCredential;

   148                     iContextToken = EFalse;

   149                     }

   150                 else if((aLocalName == WSTrust::KLifetimeTag)

   151                         ||

   152                         (aLocalName == WSTrust::KLifeTimeTag))

   153                     {

   154                     iState = KStateParsingLifeTime;

   155                     }

   156                 else if(aLocalName == WSTrust::KProofTokenTag)

   157                     {

   158                     iState = KStateParsingPOP;

   159                     }            

   160                 else if(aLocalName == WSTrust::KTokenTypeTag)

   161                     {

   162                     iState = KStateParsingTokenType;

   163                     }            

   164                 else if(aLocalName == WSTrust::KEntropyTag)

   165                     {

   166                     iState = KStateParsingEntropy;

   167                     }            

   168                 else if(aLocalName == WSTrust::KKeySize)

   169                     {

   170                     ResetContentL();

   171                     iState = KStateParsingKeySize;

   172                     }            

   173                 else if(((aLocalName ==

   174                           WSTrust::KRequestedAttachedReferenceTag) &&

   175                          (aNsUri == WSTrust::KTrustNamespace200502)) ||

   176                         ((aLocalName ==

   177                           WSTrust::KRequestedTokenReferenceTag) &&

   178                          (aNsUri == WSTrust::KTrustNamespace200404)))

   179                     {

   180                     iState = KStateParsingAttachedReference;

   181                     }

   182                 }

   183             else if(iPolicyVersion && aNsUri == *iPolicyVersion)

   184                 {

   185                 if (aLocalName == WSPolicy::KAppliesToTag)

   186                     {

   187                     iState = KStateParsingAppliesTo;

   188                     }

   189                 }

   190                                 

   191                 

   192             break;

   193             }

   194         case KStateParsingSingleCredential:

   195             {

   196             if ((aNsUri == WSSecureConversation::KSecureConversationNamespace()

   197                 || aNsUri == WSSecureConversation::KSecureConversationNamespaceMS())

   198                 && (aLocalName == WSSecureConversation::KSecurityContextToken())

   199                )

   200                 {

   201                 iContextToken = ETrue;

   202                 }

   203             CSenCredential* pCredential = CSenCredential::NewL(

   204                aNsUri, aLocalName, aQName, aAttributes);

   205             delete iCredential;

   206             iCredential = NULL;

   207             iCredential = pCredential;

   208             DelegateParsingL(*iCredential);

   209             //in case when credential parsed after lifetime

   210             //  if first credentail is parsed this assigment is reduntant, 

   211             //  but it costs less than checking time

   212             iCredential->DetachL();

   213             iCredential->SetValidUntil(iNotOnOrAfter);

   214             break;

   215             }

   216         case KStateParsingAttachedReference:

   217             {

   218             //parsing STR

   219             delete iSTRFr;

   220             iSTRFr = NULL;

   221             iSTRFr = CSenBaseFragment::NewL(aNsUri, aLocalName, aQName,

   222                     aAttributes);

   223             DelegateParsingL(*iSTRFr);

   224             break;

   225             }

   226         case KStateParsingPOP:

   227             {

   228             // We clean the buffer so that we can save the element content

   229             // At endElement we will know what member of the resource offering

   230             // to set.

   231              if (aNsUri == *iActiveXmlns && aLocalName == WSTrust::KBinarySecretTag)

   232                 {

   233                 delete iTypeOfBinary;

   234                 iTypeOfBinary = NULL;

   235                 iTypeOfBinary = SenXmlUtils::AttrValue(aAttributes, WSTrust::KBinaryTypeAttr).AllocL();

   236                 ResetContentL();

   237                 }

   238              else if (aNsUri == *iActiveXmlns && aLocalName == WSTrust::KComputedKeyTag)

   239                 {

   240                 ResetContentL();

   241                 }            

   242                 break;

   243             }

   244         case KStateParsingEntropy:

   245             {

   246             if (aNsUri == *iActiveXmlns && aLocalName == WSTrust::KBinarySecretTag)

   247                 {

   248                 delete iTypeOfBinary;

   249                 iTypeOfBinary = NULL;

   250                 iTypeOfBinary = SenXmlUtils::AttrValue(aAttributes, WSTrust::KBinaryTypeAttr).AllocL();

   251                 ResetContentL();

   252                 }

   253             break;

   254             }

   255         case KStateParsingTokenType:

   256             {

   257             ResetContentL();

   258             }            

   259             break;

   260         case KStateParsingLifeTime:

   261             {

   262             if (aNsUri == WSTrust::KWsuNamespace && 

   263                 ((aLocalName == WSTrust::KExpiresTag) || (aLocalName == WSTrust::KCreatedTag)))

   264                 {

   265                 ResetContentL();

   266                 }

   267             break;

   268             }

   269         case KStateParsingSearchHeader:

   270             {

   271             if (((aNsUri == KSenSoapEnvelopeXmlns) || (aNsUri == KSenSoap12EnvelopeXmlns)) &&

   272                 (aLocalName == KSenSoapEnvelopeHeaderName))

   273                 {

   274                 iState = KStateParsingHeader;

   275                 }

   276             break;

   277             }

   278         case KStateParsingHeader:

   279             {

   280             if ((aNsUri == *iActiveXmlns) &&

   281                 (aLocalName == WSTrust::KIssuedTokens))

   282                 {

   283                 iState = KStateIgnore;

   284                 }

   285             else

   286                 {

   287                 iState = KStateParsingSearchHeader;

   288                 }

   289             break;

   290             }

   291         case KStateParsingAppliesTo:

   292             {

   293             if (iAddressingNs 

   294                 && iAddressingEndpointTag

   295                 && aNsUri == *iAddressingNs

   296                 && aLocalName == *iAddressingEndpointTag)

   297                 {

   298                 ResetContentL();

   299                 }

   300             break;

   301             }                            

   302         default:

   303             break;

   304         }

   305     }

   306 

   307 void CWSStarRSTResponse::EndElementL(

   308     const TDesC8& aNsUri,

   309     const TDesC8& aLocalName,

   310     const TDesC8& /*aQName*/

   311     )

   312     {

   313      switch (iState)

   314         {

   315         case KStateIgnore:

   316             {

   317             break;

   318             }

   319         case KStateParsingRSTResponse:

   320             {

   321             if (aNsUri == *iActiveXmlns && aLocalName == WSTrust::KRSTResponseTag)

   322                 {

   323                 iState = KStateIgnore;

   324                 if (iParsingApliedTo)

   325                     {

   326                     iTokenEstablished = ETrue;

   327                     iDefTokenEstablished = EFalse;

   328                     }

   329                 else if(!iDefTokenEstablished)

   330                     {

   331                     iDefTokenEstablished = ETrue;

   332                     iCredentialDef = iCredential;

   333                     iCredential = NULL;

   334                     iKeySizeDef = iKeySize;

   335                     iKeySize = NULL;

   336                     iSTRDef = iSTR;

   337                     iSTR = NULL;

   338                     iPOPencodedAsBase64Def = iPOPencodedAsBase64;

   339                     iPOPencodedAsBase64 = NULL;

   340                     iTokenTypeDef = iTokenType;

   341                     iTokenType = NULL;

   342                     iTypeOfBinaryDef = iTypeOfBinary;

   343                     iTypeOfBinary = NULL;

   344                     iEntropySTSDef = iEntropySTS;

   345                     iEntropySTS = NULL;

   346                     iComputedKeyDef = iComputedKey;

   347                     iComputedKey = NULL;

   348                     iCredentialExpiresDef = iCredentialExpires;

   349                     iCredentialExpires = NULL;

   350                     iCredentialCreatedDef = iCredentialCreated;    

   351                     iCredentialCreated = NULL;

   352                     }

   353                 }

   354             break;

   355             }     

   356         case KStateParsingSingleCredential:

   357             {

   358             if (aNsUri == *iActiveXmlns && aLocalName == WSTrust::KRequestedSecurityTokenTag)

   359                 {

   360                 iState = KStateParsingRSTResponse;

   361                 }

   362             break;

   363             }

   364         case KStateParsingAttachedReference:

   365             {

   366             delete iSTR;

   367             iSTR = NULL;

   368             if (iSTRFr->LocalName() == KSecurityTokenReference)

   369                 {

   370                 iSTRFr->DetachL();

   371                 iSTR = iSTRFr->AsXmlL();

   372                 }

   373             else

   374                 {

   375                 TLSLOG(KSenFaultsLogChannel, KSenFaultsLogLevel, KBadSCT());

   376                 }

   377             delete iSTRFr;

   378             iSTRFr = NULL;

   379             iState = KStateParsingRSTResponse;

   380             break;

   381             }

   382         case KStateParsingTokenType:

   383                 {

   384                 if (aNsUri == *iActiveXmlns && aLocalName == WSTrust::KTokenType)

   385                     {

   386                     delete iTokenType;

   387                     iTokenType = NULL;

   388                     iTokenType = Content().AllocL();

   389                     }

   390                 iState = KStateParsingRSTResponse;

   391                 break;   

   392                 }

   393         case KStateParsingPOP:

   394             {

   395             if (aNsUri == *iActiveXmlns && aLocalName == WSTrust::KBinarySecretTag)

   396                 {

   397                 iState = KStateParsingRSTResponse;

   398                 delete iPOPencodedAsBase64;

   399                 iPOPencodedAsBase64 = NULL;

   400                 iPOPencodedAsBase64 = Content().AllocL();

   401                 }

   402             else if (aNsUri == *iActiveXmlns && aLocalName == WSTrust::KComputedKeyTag)

   403                 {

   404                 iState = KStateParsingRSTResponse;

   405                 delete iComputedKey;

   406                 iComputedKey = NULL;

   407                 iComputedKey = Content().AllocL();

   408                 }

   409             break;

   410             }

   411         case KStateParsingEntropy:

   412             {

   413             if (aNsUri == *iActiveXmlns && aLocalName == WSTrust::KBinarySecretTag)

   414                 {

   415                 iState = KStateParsingRSTResponse;

   416                 delete iEntropySTS;

   417                 iEntropySTS = NULL;

   418                 iEntropySTS = Content().AllocL();

   419                 }

   420             break;

   421             }

   422         case KStateParsingKeySize:

   423             {

   424             iState = KStateParsingRSTResponse;

   425             delete iKeySize;

   426             iKeySize = NULL;

   427             iKeySize = new (ELeave) TInt(0);

   428             TLex8 lex(Content());

   429             if (lex.Val(*iKeySize) != KErrNone)

   430                 {

   431                 delete iKeySize;

   432                 iKeySize = NULL;

   433                 };

   434             break;

   435             }

   436         case KStateParsingLifeTime:

   437             {

   438             if (aNsUri == WSTrust::KWsuNamespace() && aLocalName == WSTrust::KExpiresTag)

   439                 {

   440                 delete iCredentialExpires;

   441                 iCredentialExpires = NULL;

   442                 iCredentialExpires = Content().AllocL();

   443                 iNotOnOrAfter =  SenDateUtils::FromXmlDateTimeL(*iCredentialExpires);

   444                 iState = KStateParsingRSTResponse;

   445                 //in case if credential has been already parsed

   446                 if (iCredential)

   447                     {

   448                     iCredential->SetValidUntil(iNotOnOrAfter);

   449                     }

   450                 }

   451             else if(aNsUri == WSTrust::KWsuNamespace() && aLocalName == WSTrust::KCreatedTag)

   452                 {

   453                 delete iCredentialCreated;

   454                 iCredentialCreated = NULL;

   455                 iCredentialCreated = Content().AllocL();

   456                 //check if only created tag, what hapeens with states & parsing

   457                 }

   458             break;

   459             }

   460         case KStateParsingAppliesTo:            

   461             {

   462             if(aNsUri == *iPolicyVersion && aLocalName == WSPolicy::KAppliesToTag)

   463                 {

   464                 iState = KStateParsingRSTResponse;

   465                 }

   466             else if (iAddressingNs 

   467                 && iAddressingEndpointTag

   468                 && aNsUri == *iAddressingNs

   469                 && aLocalName == *iAddressingEndpointTag)

   470                 {

   471                 //if no collection, we take anyway, we will try

   472                 if ((iAppliedTo != Content()) && (iAppliedTo != KNullDesC8)) 

   473                     {

   474                     Reset();

   475                     iState = KStateIgnore;

   476                     }

   477                 else

   478                     {

   479                     iParsingApliedTo = ETrue;

   480                     }

   481                 }

   482             break;

   483             }

   484         default:

   485             break;

   486         }

   487     }

   488 

   489 CSenCredential* CWSStarRSTResponse::Credential()

   490     {

   491     return iDefTokenEstablished ? iCredentialDef : iCredential;

   492     }

   493 

   494 TPtrC8 CWSStarRSTResponse::POPBase64()

   495     {

   496     HBufC8* POPencodedAsBase64 = iDefTokenEstablished ? iPOPencodedAsBase64Def :

   497             iPOPencodedAsBase64;

   498     if (POPencodedAsBase64)

   499         {

   500         return *POPencodedAsBase64;    

   501         }

   502     else 

   503         {

   504         return KNullDesC8();

   505         }

   506     }

   507 TPtrC8 CWSStarRSTResponse::TokenType()

   508     {

   509     HBufC8* tokenType = iDefTokenEstablished ? iTokenTypeDef :

   510             iTokenType;

   511     if (tokenType)

   512         {

   513         return *tokenType;    

   514         }

   515     else 

   516         {

   517         return KNullDesC8();

   518         }

   519     }

   520 TPtrC8 CWSStarRSTResponse::BinaryType()

   521     {

   522     HBufC8* typeOfBinary = iDefTokenEstablished ? iTypeOfBinaryDef :

   523             iTypeOfBinary;

   524     if (typeOfBinary && typeOfBinary->Length())

   525         {

   526         return *typeOfBinary;    

   527         }

   528     else

   529         {

   530         return WSTrust::KBinaryTypeSimmetricValue(); 

   531         }

   532        

   533     }

   534 TPtrC8 CWSStarRSTResponse::EntropySTS()

   535     {

   536     HBufC8* entropySTS = iDefTokenEstablished ? iEntropySTSDef : iEntropySTS;

   537     if (entropySTS)

   538         {

   539         return *entropySTS;    

   540         }

   541     else

   542         {

   543         return KNullDesC8();

   544         }

   545     }

   546 TPtrC8 CWSStarRSTResponse::ComputedKey()

   547     {

   548     HBufC8* computedKey = iDefTokenEstablished ? iComputedKeyDef : iComputedKey;

   549     if (computedKey)

   550         {

   551         return *computedKey;    

   552         }

   553     else

   554         {

   555         return KNullDesC8();

   556         }

   557     }

   558 TInt CWSStarRSTResponse::KeySize()

   559     {

   560     TInt* keySize = iKeySizeDef ? iKeySizeDef : iKeySize;

   561     if (keySize)

   562         {

   563         return *keySize;    

   564         }

   565     else

   566         {

   567         return 0;

   568         }

   569     }

   570 TPtrC8 CWSStarRSTResponse::CredentialExpires()

   571     {

   572     HBufC8* credentialExpires = iDefTokenEstablished ? iCredentialExpiresDef :

   573             iCredentialExpires;

   574     if (credentialExpires)

   575         {

   576         return *credentialExpires;    

   577         }

   578     else

   579         {

   580         return KNullDesC8();

   581         }

   582     }

   583 TPtrC8 CWSStarRSTResponse::CredentialCreated()

   584     {

   585     HBufC8* credentialCreated = iDefTokenEstablished ? iCredentialCreatedDef :

   586             iCredentialCreated;

   587     if (credentialCreated)

   588         {

   589         return *credentialCreated;    

   590         }

   591     else

   592         {

   593         return KNullDesC8(); 

   594         }

   595     }

   596 TPtrC8 CWSStarRSTResponse::STR()

   597     {

   598     HBufC8* str = iDefTokenEstablished ? iSTRDef : iSTR;

   599     return str ? *str : KNullDesC8();

   600     }

   601 TBool CWSStarRSTResponse::IsContextToken()

   602     {

   603     return iContextToken;

   604     }

   605 

   606 TBool CWSStarRSTResponse::IsResponse()

   607     {

   608     return iIsResponse;

   609     }

   610 

   611 void CWSStarRSTResponse::UpdateAddressingHoldersL(MSenSessionContext& aCtx)

   612     {

   613     //priority

   614     //  1)version declared by facet in SD scope (we get value by KAddressingVersion)

   615     //  2)version of addressing handler (we get value by KAddressinNsHolder)

   616     iAddressingNs = aCtx.GetDesC8L(WSStarContextKeys::KAddressingVersion);    

   617     if (!iAddressingNs)

   618         {

   619         iAddressingNs = aCtx.GetDesC8L(WSStarContextKeys::KAddressingNsHolder);    

   620         }

   621     iAddressingEndpointTag = aCtx.GetDesC8L(WSStarContextKeys::KAddressingEndpointTagHolder);

   622     }

   623 void CWSStarRSTResponse::Reset()    

   624     {

   625     delete iCredential;

   626     iCredential = NULL;

   627     

   628     delete iSTR;

   629     iSTR = NULL;

   630     

   631     delete iPOPencodedAsBase64;

   632     iPOPencodedAsBase64 = NULL;

   633     

   634     delete iTokenType;

   635     iTokenType = NULL;

   636     

   637     delete iTypeOfBinary;

   638     iTypeOfBinary = NULL;

   639     

   640     delete iEntropySTS;

   641     iEntropySTS = NULL;

   642     

   643     delete iComputedKey;

   644     iComputedKey = NULL;

   645     

   646     delete iCredentialExpires;

   647     iCredentialExpires = NULL;

   648     

   649     delete iCredentialCreated;    

   650     iCredentialCreated = NULL;

   651     }

   652 void CWSStarRSTResponse::SetPolicyVersion(const TDesC8* aVersion)

   653     {

   654     iPolicyVersion = aVersion;

   655     }    

   656 // End of File

   657