1 /*

     2 * Copyright (c) 2002-2005 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 // INCLUDE FILES

    26 #include <xmlengnodelist.h>

    27 #include <badesca.h>

    28 #include <SenXmlReader.h>

    29 #include <s32mem.h>

    30 #include <utf.h>

    31 

    32 #include "SenWsSecurityHeader2.h"

    33 #include "SenSoapMessage2.h"

    34 

    35 #include "sendebug.h"

    36 #include "senlogger.h"

    37 

    38 

    39 EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewL()

    40     {

    41     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewL()");

    42     CSenSoapMessage2* pNew = CSenSoapMessage2::NewLC();

    43     CleanupStack::Pop(pNew);

    44     return pNew;    

    45     }

    46 

    47 EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewLC()

    48     {

    49     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewLC()");

    50     CSenSoapMessage2* pNew = new (ELeave) CSenSoapMessage2();

    51     CleanupStack::PushL(pNew);

    52     pNew->BaseConstructL();

    53     return pNew;

    54     }

    55 

    56 EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewL(TSOAPVersion aVersion)

    57     {

    58     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewL(aVersion)");

    59     CSenSoapMessage2* pNew = CSenSoapMessage2::NewLC(aVersion);

    60     CleanupStack::Pop(pNew);

    61     return pNew;    

    62     }

    63 

    64 EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewLC(TSOAPVersion aVersion)

    65     {

    66     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewLC(aVersion)");

    67     CSenSoapMessage2* pNew = new (ELeave) CSenSoapMessage2();

    68     CleanupStack::PushL(pNew);

    69     pNew->BaseConstructL(aVersion);

    70     return pNew;

    71     }

    72 

    73 EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewL(TSOAPVersion aVersion,

    74                                                   const TDesC8& aSecurityNs)

    75     {

    76     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewL(aVersion,aSecurityNs)");

    77     CSenSoapMessage2* pNew = CSenSoapMessage2::NewLC(aVersion, aSecurityNs);

    78     CleanupStack::Pop(pNew);

    79     return pNew;    

    80     }

    81 

    82 EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewLC(TSOAPVersion aVersion,

    83                                                    const TDesC8& aSecurityNs)

    84     {

    85     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewLC(aVersion,aSecurityNs)");

    86     CSenSoapMessage2* pNew = new (ELeave) CSenSoapMessage2();

    87     CleanupStack::PushL(pNew);

    88     pNew->BaseConstructL(aVersion, aSecurityNs);

    89     return pNew;

    90     }

    91 

    92 EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewL(MSenMessageContext& aContext)

    93     {

    94     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewL(aContext)");

    95     CSenSoapMessage2* pNew = CSenSoapMessage2::NewLC(aContext);

    96     CleanupStack::Pop(pNew);

    97     return pNew;    

    98     }

    99 

   100 EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewLC(MSenMessageContext& aContext)

   101     {

   102     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewLC(aContext)");

   103     CSenSoapMessage2* pNew = new (ELeave) CSenSoapMessage2();

   104     CleanupStack::PushL(pNew);

   105     pNew->BaseConstructL(aContext);

   106     return pNew;

   107     }

   108 

   109 EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewL(MSenMessageContext& aContext,

   110                                                   TSOAPVersion aVersion)

   111     {

   112     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewL(aContext,aVersion)");

   113     CSenSoapMessage2* pNew = CSenSoapMessage2::NewLC(aContext, aVersion);

   114     CleanupStack::Pop(pNew);

   115     return pNew;    

   116     }

   117 

   118 EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewLC(MSenMessageContext& aContext,

   119                                                    TSOAPVersion aVersion)

   120     {

   121     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewLC(aContext,aVersion)");

   122     CSenSoapMessage2* pNew = new (ELeave) CSenSoapMessage2();

   123     CleanupStack::PushL(pNew);

   124     pNew->BaseConstructL(aContext, aVersion);

   125     return pNew;

   126     }

   127 

   128 EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewL(MSenMessageContext& aContext,

   129                                                   TSOAPVersion aVersion,

   130                                                   const TDesC8& aSecurityNs)

   131     {

   132     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewL(aContext,aVersion,aSecurityNs)");

   133     CSenSoapMessage2* pNew = CSenSoapMessage2::NewLC(aContext,

   134                                                       aVersion,

   135                                                       aSecurityNs);

   136     CleanupStack::Pop(pNew);

   137     return pNew;    

   138     }

   139 

   140 EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewLC(MSenMessageContext& aContext,

   141                                                   TSOAPVersion aVersion,

   142                                                   const TDesC8& aSecurityNs)

   143     {

   144     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewLC(aContext,aVersion,aSecurityNs)");

   145     CSenSoapMessage2* pNew = new (ELeave) CSenSoapMessage2();

   146     CleanupStack::PushL(pNew);

   147     pNew->BaseConstructL(aContext, aVersion, aSecurityNs);

   148     return pNew;

   149     }

   150     

   151 EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewL(CSenSoapMessage2& aMessage)

   152     {

   153     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewL(aMessage)");

   154     CSenSoapMessage2* pNew = CSenSoapMessage2::NewLC(aMessage);

   155     CleanupStack::Pop(pNew); // pNew

   156     return pNew;    

   157     }

   158 

   159 EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewLC(CSenSoapMessage2& aMessage)

   160     {

   161     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewLC(aMessage)");

   162     CSenSoapMessage2* pNew = new (ELeave) CSenSoapMessage2();

   163     CleanupStack::PushL(pNew);

   164     pNew->BaseConstructL(aMessage);

   165     return pNew;

   166     }

   167     

   168 EXPORT_C CSenSoapMessage2::~CSenSoapMessage2()

   169     {

   170     if (ipSecurityHeader)

   171         {

   172         // We do not own the element, so remove it from the fragment.

   173         ipSecurityHeader->ExtractElement();

   174         delete ipSecurityHeader;

   175         }

   176     }

   177     

   178 EXPORT_C CSenSoapMessage2::CSenSoapMessage2()

   179 : ipSecurityHeader(NULL)

   180     {

   181     }

   182 

   183 EXPORT_C void CSenSoapMessage2::BaseConstructL()

   184     {

   185     CSenSoapEnvelope2::BaseConstructL();

   186     }

   187 

   188 EXPORT_C void CSenSoapMessage2::BaseConstructL(TSOAPVersion aVersion)

   189     {

   190     CSenSoapEnvelope2::BaseConstructL(aVersion);

   191     }

   192 

   193 EXPORT_C void CSenSoapMessage2::BaseConstructL(TSOAPVersion aVersion, const TDesC8& aSecurityNs)

   194     {

   195     BaseConstructL(aVersion);

   196     if ( ( aSecurityNs == KSecuritySchemeXmlNs ) || ( aSecurityNs == KSecurityXmlNs ) )

   197         {

   198         TXmlEngElement element = AsElementL();

   199         RSenDocument document = AsDocumentL();

   200         ipSecurityHeader = CSenWsSecurityHeader2::NewL(KNullDesC8,

   201                                                        aSecurityNs,

   202                                                        document,

   203                                                        element);

   204         this->AddHeaderL(ipSecurityHeader->AsElementL());

   205         }

   206     }

   207 

   208 EXPORT_C void CSenSoapMessage2::BaseConstructL(MSenMessageContext& aContext)

   209     {

   210     CSenSoapEnvelope2::BaseConstructL(aContext);

   211     }

   212 

   213 EXPORT_C void CSenSoapMessage2::BaseConstructL(MSenMessageContext& aContext,

   214                                                TSOAPVersion aVersion)

   215     {

   216     CSenSoapEnvelope2::BaseConstructL(aContext, aVersion);

   217     }

   218 

   219 EXPORT_C void CSenSoapMessage2::BaseConstructL(MSenMessageContext& aContext,

   220                                                TSOAPVersion aVersion,

   221                                                const TDesC8& aSecurityNs)

   222     {

   223     BaseConstructL(aContext, aVersion);

   224     if ( ( aSecurityNs == KSecuritySchemeXmlNs ) || ( aSecurityNs == KSecurityXmlNs ) )

   225         {

   226         TXmlEngElement element = AsElementL();

   227         RSenDocument document = AsDocumentL();

   228         ipSecurityHeader = CSenWsSecurityHeader2::NewL(KNullDesC8,

   229                                                        aSecurityNs,

   230                                                        document,

   231                                                        element);

   232         this->AddHeaderL(ipSecurityHeader->AsElementL());

   233         }

   234     }

   235     

   236 EXPORT_C void CSenSoapMessage2::BaseConstructL(CSenSoapMessage2& aMessage)

   237     {

   238     CSenSoapEnvelope2::BaseConstructL(aMessage);

   239     }

   240 

   241 EXPORT_C void CSenSoapMessage2::SetSecurityHeaderL(const TDesC8& aData)

   242     {

   243     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::SetSecurityHeaderL(aData)");

   244     CSenWsSecurityHeader2* pTemp = NULL;

   245     TXmlEngElement element = AsElementL();

   246     RSenDocument document = AsDocumentL();

   247 

   248     if ( aData == KNullDesC8 )

   249         {

   250         // we don't have credential

   251         pTemp = NewSecurityHeaderLC(NULL, document, element);

   252         }

   253     else

   254         {

   255         // there is a credential to add..

   256         pTemp = NewSecurityHeaderLC(&aData, document, element);

   257         }

   258 

   259     TXmlEngElement header = HeaderL();

   260     RXmlEngNodeList<TXmlEngElement> list;

   261     CleanupClosePushL(list);

   262     header.GetElementsByTagNameL(list, KSecurityName,

   263                                        pTemp->XmlNs());

   264     while ( list.HasNext() )

   265         {

   266         TXmlEngElement element = list.Next();

   267         element.Remove();

   268         }

   269 

   270     if ( ipSecurityHeader )

   271         {

   272         delete ipSecurityHeader;

   273         ipSecurityHeader = NULL;

   274         }

   275     

   276     CleanupStack::PopAndDestroy(&list);

   277         

   278     ipSecurityHeader = pTemp;

   279     CleanupStack::Pop(); // pTemp

   280     this->AddHeaderL(ipSecurityHeader->AsElementL());

   281     }

   282 

   283 EXPORT_C void CSenSoapMessage2::ParseHeaderL( const RTagInfo& aElement,

   284                                               const RAttributeArray& aAttributes)

   285     {

   286     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::ParseHeaderL");

   287     const TPtrC8 saxLocalName   = aElement.LocalName().DesC();

   288     const TPtrC8 saxNsUri       = aElement.Uri().DesC();

   289     const TPtrC8 saxPrefix      = aElement.Prefix().DesC();

   290     

   291     TXmlEngElement element = AsElementL();

   292     RSenDocument document = AsDocumentL();

   293     

   294     CSenWsSecurityHeader2* pTemp = NewSecurityHeaderLC(NULL, document, element);

   295 

   296     if ((pTemp->XmlNs() == saxNsUri) && (KSecurityName() == saxLocalName))

   297         {

   298         // Remove existing <Security> header

   299         TXmlEngElement header = HeaderL();

   300         RXmlEngNodeList<TXmlEngElement> list;

   301         CleanupClosePushL(list);

   302         header.GetElementsByTagNameL(list, KSecurityName, pTemp->XmlNs());

   303         while ( list.HasNext() )

   304             {

   305             TXmlEngElement element = list.Next();

   306             element.Remove();

   307             }

   308             

   309         CleanupStack::PopAndDestroy(&list);

   310 

   311         if ( ipSecurityHeader )

   312             {

   313             delete ipSecurityHeader;

   314             ipSecurityHeader = NULL;

   315             }

   316             

   317         ipSecurityHeader = pTemp;

   318         CleanupStack::Pop(); // pTemp

   319         

   320         TXmlEngElement wsSecurityHeader = ipSecurityHeader->AsElementL();

   321         wsSecurityHeader.MoveTo(header);

   322         OnDelegateParsingL(*ipSecurityHeader);        

   323         }

   324     else

   325         {

   326         TXmlEngElement rootElement = pTemp->AsElementL();

   327         rootElement.Remove();

   328         CleanupStack::PopAndDestroy(); // pTemp

   329         CSenSoapEnvelope2::ParseHeaderL(aElement, aAttributes);

   330         }

   331     }

   332 

   333 EXPORT_C TInt CSenSoapMessage2::AddSecurityTokenL(const TDesC8& aNewToken)

   334     {

   335     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::AddSecurityTokenL(aNewToken)");

   336     TXmlEngElement element = AsElementL();

   337     RSenDocument document = AsDocumentL();

   338     TXmlEngElement soapHeader = HeaderL();

   339     TXmlEngElement wsSecurityHeader;

   340 

   341     // Create <wsse:Security> element into wrong place

   342     // <=> into a root element = Envelope.

   343     // <S:Envelope>

   344     //   ...

   345     //   <wsse:Security>

   346     // That's because we don't want following search to find

   347     // this new header inside <S:Header> element.

   348     CSenWsSecurityHeader2* pHeader = NewSecurityHeaderLC(NULL, document, element);

   349     RXmlEngNodeList<TXmlEngElement> list;

   350     CleanupClosePushL(list);

   351     soapHeader.GetElementsByTagNameL(list, KSecurityName,

   352                                            pHeader->XmlNs());

   353                                           

   354     if ( !list.HasNext() )

   355         {

   356         // <wsse:Security> element was not found from <S:Header> element.

   357         // => Add new header by moving header from (root) <S:Envelope>

   358         //    element into <S:Header> element.

   359         wsSecurityHeader = pHeader->ExtractElement();

   360         wsSecurityHeader.MoveTo(soapHeader);

   361         }

   362     else

   363         {

   364         // <wsse:Security> element was found from <S:Header> element.

   365         // => Delete new header element from SoapMessage DOM tree by

   366         //    removing header from (root) <S:Envelope> element.

   367         wsSecurityHeader = pHeader->ExtractElement();

   368         wsSecurityHeader.Remove();

   369         

   370         // Select found <wsse:Security> element to be edited

   371         wsSecurityHeader = list.Next();

   372         }

   373         

   374     CleanupStack::PopAndDestroy(&list);

   375 

   376     CleanupStack::PopAndDestroy(); // pHeader // safe to delete

   377 

   378     TPtrC8 content = wsSecurityHeader.Text();

   379     HBufC8* pContent = HBufC8::NewLC( content.Length() + aNewToken.Length() );

   380     TPtr8 ptrContent = pContent->Des();

   381     ptrContent.Append(content);

   382     ptrContent.Append(aNewToken);

   383     wsSecurityHeader.SetTextNoEncL(*pContent);

   384     CleanupStack::PopAndDestroy(pContent);    

   385 

   386     return KErrNone;

   387     }

   388 

   389 EXPORT_C CSenWsSecurityHeader2* CSenSoapMessage2::NewSecurityHeaderLC( const TDesC8* aData,

   390                                                                        RSenDocument aDocument,

   391                                                                        TXmlEngElement element )

   392     {

   393     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewSecurityHeaderLC");

   394     CSenWsSecurityHeader2* pNew = NULL;

   395 

   396     if ( aData )

   397         {

   398         if ( ipSecurityHeader )

   399             {

   400             pNew = CSenWsSecurityHeader2::NewL(*aData, ipSecurityHeader->XmlNs(), aDocument, element);

   401             }

   402         else

   403             {

   404             pNew = CSenWsSecurityHeader2::NewL(*aData, aDocument, element);

   405             }

   406         }

   407     else

   408         {

   409         if ( ipSecurityHeader )

   410             {

   411             pNew = CSenWsSecurityHeader2::NewL(KNullDesC8, ipSecurityHeader->XmlNs(), aDocument, element);

   412             }

   413         else

   414             {

   415             pNew = CSenWsSecurityHeader2::NewL(aDocument, element);

   416             }

   417         }

   418 

   419     CleanupStack::PushL(pNew);

   420     return pNew;

   421     }

   422     

   423 EXPORT_C MSenMessage::TClass CSenSoapMessage2::Type()

   424     {

   425     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::Type");

   426     return MSenMessage::ESoapMessage2;

   427     }

   428     

   429 EXPORT_C MSenMessage* CSenSoapMessage2::CloneL()

   430     {

   431     TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::CloneL");

   432     CSenSoapMessage2* pMessage = CSenSoapMessage2::NewL(*this);

   433     return pMessage;

   434     }

   435     

   436 // End of File