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 

    26 

    27 

    28 // INCLUDE FILES

    29 #include "seninternalcredential.h"

    30 #include "SenFacet.h"

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

    32 #include "senwsdescription.h"

    33 #include "SenDateUtils.h"

    34 #include <SenIdentityProvider.h>

    35 #include "senlogger.h"

    36 

    37 

    38 #ifdef SYMBIAN_SECURE_ECOM

    39     // for S60 FP3 (2.8) platform or newer (3.0 and above)

    40     #include <xml/attribute.h> // needed for RAttributeArray

    41 //#else  // for S60 FP2 platform (2.6) or older

    42     //#include "Attribute.h"

    43 #endif

    44 

    45 #include <xmlengnodelist.h> 

    46 using namespace Xml;

    47 

    48 namespace

    49     {

    50     _LIT8(KProviderIdLocalName,  "ProviderID");

    51     _LIT8(KUserName,             "AuthzID");

    52     _LIT8(KPassword,             "Password");

    53     const TInt KCredIdBufSize    = 128;    

    54     }

    55 

    56 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewL()

    57     {

    58     CSenInternalCredential* pNew = NewLC();

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

    60     return pNew;

    61     }

    62 

    63 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewLC()

    64     {

    65     CSenInternalCredential* pNew = new (ELeave) CSenInternalCredential;

    66     CleanupStack::PushL(pNew);

    67     pNew->ConstructL(KNullDesC8);

    68     return pNew;

    69     }

    70 

    71 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewL(

    72                                            	const TDesC8& aNsUri,

    73                                             const TDesC8& aLocalName,

    74                                             const TDesC8& aQName,

    75                                             const RAttributeArray& aAttributes)

    76     {

    77     CSenInternalCredential* pNew = NewLC(aNsUri, aLocalName, aQName, aAttributes);

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

    79     return pNew;

    80     }

    81 

    82 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewLC(

    83                                             const TDesC8& aNsUri,

    84                                             const TDesC8& aLocalName,

    85                                             const TDesC8& aQName,

    86                                             const RAttributeArray& aAttributes)

    87     {

    88     CSenInternalCredential* pNew = new (ELeave) CSenInternalCredential;

    89     CleanupStack::PushL(pNew);

    90     pNew->ConstructL(aNsUri, aLocalName, aQName, aAttributes);

    91     return pNew;

    92     }

    93 

    94 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewL(

    95                                             const TDesC8& aNsUri,

    96                                             const TDesC8& aLocalName,

    97                                             const TDesC8& aQName,

    98                                             const RAttributeArray& aAttributes,

    99                                             TXmlEngElement& aParent)

   100     {

   101     CSenInternalCredential* pNew = NewLC(aNsUri, aLocalName,

   102                                          aQName, aAttributes, aParent);

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

   104     return pNew;

   105     }

   106 

   107 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewLC(

   108                                             const TDesC8& aNsUri,

   109                                             const TDesC8& aLocalName,

   110                                             const TDesC8& aQName,

   111                                             const RAttributeArray& aAttributes,

   112                                             TXmlEngElement& aParent)

   113     {

   114     CSenInternalCredential* pNew = new (ELeave) CSenInternalCredential;

   115     CleanupStack::PushL(pNew);

   116     pNew->ConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent);

   117     return pNew;

   118     }

   119 

   120 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewL(

   121                                             const TDesC8& aNsUri,

   122                                             const TDesC8& aLocalName,

   123                                             const TDesC8& aQName,

   124                                             const RAttributeArray& aAttributes,

   125                                             TXmlEngElement& aParent,

   126                                             RSenDocument& aOwnerDocument)

   127     {

   128     CSenInternalCredential* pNew = NewLC(aNsUri, aLocalName,

   129                                          aQName, aAttributes,

   130                                          aParent, aOwnerDocument);

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

   132     return pNew;

   133     }

   134 

   135 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewLC(

   136                                             const TDesC8& aNsUri,

   137                                             const TDesC8& aLocalName,

   138                                             const TDesC8& aQName,

   139                                             const RAttributeArray& aAttributes,

   140                                             TXmlEngElement& aParent,

   141                                             RSenDocument& aOwnerDocument)

   142     {

   143     CSenInternalCredential* pNew = new (ELeave) CSenInternalCredential;

   144     CleanupStack::PushL(pNew);

   145     pNew->ConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent,

   146                      aOwnerDocument);

   147     return pNew;

   148     }

   149 

   150 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewL(

   151                                              const CSenInternalCredential& aCredential)

   152     {

   153     CSenInternalCredential* pNew = NewLC(aCredential);

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

   155     return pNew;

   156     }

   157 

   158 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewLC(

   159                                              const CSenInternalCredential& aCredential)

   160     {

   161     CSenInternalCredential* pNew = new (ELeave) CSenInternalCredential;

   162     CleanupStack::PushL(pNew);

   163     pNew->ConstructL((CSenInternalCredential&)aCredential);

   164     return pNew;

   165     }

   166 

   167 

   168 EXPORT_C void CSenInternalCredential::ConstructL(CSenInternalCredential& aCredential)

   169     {

   170     CSenCredential2::BaseConstructL(aCredential);

   171     }

   172 

   173 EXPORT_C void CSenInternalCredential::ConstructL(const TDesC8&  aNsUri,

   174                                           const TDesC8&  aLocalName,

   175                                           const TDesC8&  aQName,

   176                                           const RAttributeArray& aAttributes,

   177                                           TXmlEngElement& aParent)

   178     {

   179     CSenCredential2::BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent);

   180     }

   181 

   182 EXPORT_C void CSenInternalCredential::ConstructL(const TDesC8&  aNsUri,

   183                                           const TDesC8&  aLocalName,

   184                                           const TDesC8&  aQName,

   185                                           const RAttributeArray& aAttributes,

   186                                           TXmlEngElement& aParent,

   187                                           RSenDocument& aOwnerDocument)

   188     {

   189     CSenCredential2::BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent, aOwnerDocument);

   190 

   191     }

   192 

   193 EXPORT_C void CSenInternalCredential::ConstructL(const TDesC8&  aNsUri,

   194                                           const TDesC8&  aLocalName,

   195                                           const TDesC8&  aQName,

   196                                           const RAttributeArray& aAttributes)

   197     {

   198     CSenCredential2::BaseConstructL(aNsUri, aLocalName, aQName, aAttributes);

   199     }

   200     

   201 EXPORT_C void CSenInternalCredential::ConstructL(const TDesC8& aLocalName)

   202     {

   203     CSenFragmentBase::BaseConstructL(aLocalName);

   204     }

   205 

   206 EXPORT_C CSenInternalCredential::CSenInternalCredential()

   207     {

   208     }

   209 

   210 EXPORT_C CSenInternalCredential::~CSenInternalCredential()

   211     {

   212     delete ipIdentifier;

   213     delete ipProperties;

   214     }

   215 

   216 EXPORT_C TBool CSenInternalCredential::IsApplicableL(const CSenWSDescription& aPattern)	//codescannerwarings

   217     {

   218     TPtrC8 value;

   219     CSenElement* valueElement;

   220     CSenElement& patternElement = ((CSenWSDescription&)aPattern).AsElement();

   221     CSenCredentialIdentifier& identifier = IdentifierL();	//codescannerwarings

   222 

   223     RXmlEngNodeList<TXmlEngAttr> attrList;

   224 

   225     RXmlEngNodeList<TXmlEngElement> list;

   226     CleanupClosePushL(list);

   227     TXmlEngElement element = identifier.AsElementL();

   228     element.GetChildElements(list);

   229     while ( list.HasNext() )

   230         {

   231         TXmlEngElement element = list.Next();

   232         if ( (element.Name() != KSenCredentialId) &&

   233              (element.Name() != KProviderIdLocalName)  &&

   234              (element.Name() != KSenIdpAuthzIDLocalname) &&

   235              (element.Name() != KSenIdpPasswordLocalname) )

   236             {

   237             HBufC8* pTag = element.Name().AllocLC();

   238             CleanupStack::PopAndDestroy(pTag);

   239                         

   240             valueElement = patternElement.Element(element.Name());

   241             if ( valueElement )

   242                 {

   243                 HBufC8* pElement1 = valueElement->Content().AllocLC();

   244                 HBufC8* pElement2 = element.Text().AllocLC();

   245                 CleanupStack::PopAndDestroy(pElement2);

   246                 CleanupStack::PopAndDestroy(pElement1);

   247 

   248                 if ( valueElement->Content() != element.Text() )

   249                     {

   250                     CleanupStack::PopAndDestroy(&list); // Close()

   251                     return EFalse;

   252                     }

   253                 else

   254                     {

   255                     element.GetAttributes(attrList);

   256                     CleanupClosePushL(attrList);

   257                     while ( attrList.HasNext() )

   258                         {

   259                         TXmlEngAttr attr = attrList.Next();

   260                         if ( *valueElement->AttrValue(attr.Name()) != attr.Value() )

   261                             {

   262                             CleanupStack::PopAndDestroy(&attrList); // Close()

   263                             CleanupStack::PopAndDestroy(&list); // Close()

   264                             return EFalse;

   265                             }

   266                         }

   267                     CleanupStack::PopAndDestroy(&attrList); // Close()

   268                     }

   269                 }

   270             else

   271                 {

   272                 CleanupStack::PopAndDestroy(&list); // Close()

   273                 return EFalse;

   274                 }

   275             }

   276         }

   277 

   278     CleanupStack::PopAndDestroy(&list); // Close()

   279     return ETrue;

   280     }

   281 

   282 EXPORT_C void CSenInternalCredential::SetIdentifier(CSenCredentialIdentifier* aIdentifier)

   283     {

   284     if ( ipIdentifier )

   285         {

   286         delete ipIdentifier;

   287         }

   288 

   289     ipIdentifier = aIdentifier;

   290     }

   291 

   292 EXPORT_C CSenCredentialIdentifier& CSenInternalCredential::IdentifierL()	//codescannerwarings

   293     {

   294     if ( !ipIdentifier )

   295         {

   296         ipIdentifier = CSenCredentialIdentifier::NewL();

   297         }

   298 

   299     return *ipIdentifier;

   300     }

   301 

   302 EXPORT_C void CSenInternalCredential::SetProperties(CSenCredentialProperties* aProperties)

   303     {

   304     if ( ipProperties )

   305         {

   306         delete ipProperties;

   307         }

   308 

   309     ipProperties = aProperties;

   310     }

   311 

   312 EXPORT_C CSenCredentialProperties& CSenInternalCredential::PropertiesL()	//codescannerwarings

   313     {

   314     if ( !ipProperties )

   315         {

   316         ipProperties = CSenCredentialProperties::NewL();

   317         }

   318 

   319     return *ipProperties;

   320     }

   321 

   322 EXPORT_C TBool CSenInternalCredential::HasProperties()

   323     {

   324     if ( !ipProperties )

   325         {

   326         return EFalse;

   327         }

   328     else 

   329         {

   330         return ETrue;

   331         }

   332     }

   333 

   334 EXPORT_C void CSenInternalCredential::SetIdentityProviderIdL(TDesC8& aIdentityProviderId)

   335     {

   336     IdentifierL().SetPropertyL(KProviderIdLocalName, aIdentityProviderId);	//codescannerwarings

   337     }

   338 EXPORT_C void CSenInternalCredential::SetAuthInfo(TDesC8& aUserId, TDesC8& aPassword)

   339     {

   340     TRAPD(retVal,

   341     		IdentifierL().SetPropertyL(KUserName, aUserId);

   342     		IdentifierL().SetPropertyL(KPassword, aPassword);

   343     		);

   344     }

   345 

   346 EXPORT_C TInt CSenInternalCredential::IdentityProviderIdL(TPtrC8& aIdTo)

   347     {

   348     return IdentifierL().PropertyL(KProviderIdLocalName, aIdTo);	//codescannerwarings

   349     }

   350 

   351 EXPORT_C void CSenInternalCredential::SetSession(CSenServiceSession& aSession)

   352     {

   353     ipSession = &aSession;

   354     }

   355 

   356 EXPORT_C CSenServiceSession* CSenInternalCredential::Session()

   357     {

   358     return ipSession;

   359     }

   360 

   361 

   362 

   363 

   364 EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewL()

   365     {

   366     CSenCredentialProperties* pNew = NewLC();

   367     CleanupStack::Pop(pNew);

   368     return pNew;

   369     }

   370 

   371 EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewLC()

   372     {

   373     CSenCredentialProperties* pNew = new (ELeave) CSenCredentialProperties;

   374     CleanupStack::PushL(pNew);

   375     pNew->BaseConstructL(KSenCredentialProperteisLocalname);

   376     return pNew;

   377     }

   378 

   379 EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewL(

   380                                             const TDesC8& aNsUri,

   381                                             const TDesC8& aLocalName,

   382                                             const TDesC8& aQName,

   383                                             const RAttributeArray& aAttributes)

   384     {

   385     CSenCredentialProperties* pNew = NewLC(aNsUri, aLocalName, aQName, aAttributes);

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

   387     return pNew;

   388     }

   389 

   390 EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewLC(

   391                                             const TDesC8& aNsUri,

   392                                             const TDesC8& aLocalName,

   393                                             const TDesC8& aQName,

   394                                             const RAttributeArray& aAttributes)

   395     {

   396     CSenCredentialProperties* pNew = new (ELeave) CSenCredentialProperties;

   397     CleanupStack::PushL(pNew);

   398     pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes);

   399     return pNew;

   400     }

   401 

   402 EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewL(

   403                                             const TDesC8& aNsUri,

   404                                             const TDesC8& aLocalName,

   405                                             const TDesC8& aQName,

   406                                             const RAttributeArray& aAttributes,

   407                                             TXmlEngElement& aParent)

   408     {

   409     CSenCredentialProperties* pNew = NewLC(aNsUri, aLocalName,

   410                                            aQName, aAttributes, aParent);

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

   412     return pNew;

   413     }

   414 

   415 EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewLC(

   416                                             const TDesC8& aNsUri,

   417                                             const TDesC8& aLocalName,

   418                                             const TDesC8& aQName,

   419                                             const RAttributeArray& aAttributes,

   420                                             TXmlEngElement& aParent)

   421     {

   422     CSenCredentialProperties* pNew = new (ELeave) CSenCredentialProperties;

   423     CleanupStack::PushL(pNew);

   424     pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent);

   425     return pNew;

   426     }

   427 

   428 EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewL(

   429                                             const TDesC8& aNsUri,

   430                                             const TDesC8& aLocalName,

   431                                             const TDesC8& aQName,

   432                                             const RAttributeArray& aAttributes,

   433                                             TXmlEngElement& aParent,

   434                                             RSenDocument& aOwnerDocument)

   435     {

   436     CSenCredentialProperties* pNew = NewLC(aNsUri, aLocalName,

   437                                            aQName, aAttributes,

   438                                            aParent, aOwnerDocument);

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

   440     return pNew;

   441     }

   442 

   443 EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewLC(

   444                                             const TDesC8& aNsUri,

   445                                             const TDesC8& aLocalName,

   446                                             const TDesC8& aQName,

   447                                             const RAttributeArray& aAttributes,

   448                                             TXmlEngElement& aParent,

   449                                             RSenDocument& aOwnerDocument)

   450     {

   451     CSenCredentialProperties* pNew = new (ELeave) CSenCredentialProperties;

   452     CleanupStack::PushL(pNew);

   453     pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent,

   454                          aOwnerDocument);

   455     return pNew;

   456     }

   457 

   458 EXPORT_C CSenCredentialProperties::~CSenCredentialProperties()

   459     {

   460     }

   461 

   462 CSenCredentialProperties::CSenCredentialProperties()

   463     {

   464     }

   465 

   466 EXPORT_C TInt CSenCredentialProperties::SetPropertyL(const TDesC8& aName,

   467                                                          const TDesC8& aValue)

   468     {

   469     TXmlEngElement element = AsElementL();

   470     RXmlEngNodeList<TXmlEngElement> list;

   471     CleanupClosePushL(list);

   472 

   473     element.GetElementsByTagNameL(list, aName);

   474 

   475     if ( list.Count() > 0 )

   476         {

   477         TXmlEngElement firstElement = list.Next();

   478         firstElement.SetTextNoEncL(aValue);

   479         CleanupStack::PopAndDestroy(&list); // Close();

   480         

   481         return KErrNone;

   482         }

   483     CleanupStack::PopAndDestroy(&list);

   484 

   485     TXmlEngElement newElement = element.AddNewElementL(aName);

   486     newElement.SetTextNoEncL(aValue);

   487     return KErrNone;

   488     }

   489 

   490 EXPORT_C TInt CSenCredentialProperties::PropertyL(const TDesC8& aName, TPtrC8& aValue)

   491     {

   492     TInt retVal(KErrNone);

   493 

   494     TXmlEngElement element = AsElementL();

   495     RXmlEngNodeList<TXmlEngElement> list;

   496     CleanupClosePushL(list);

   497 

   498     element.GetElementsByTagNameL(list, aName);

   499 

   500     if ( list.Count() > 0 )

   501         {

   502         TXmlEngElement firstElement = list.Next();

   503         aValue.Set(firstElement.Text());

   504         }

   505     else

   506         {

   507         retVal = KErrNotFound;

   508         }

   509 

   510     CleanupStack::PopAndDestroy(&list);

   511     return retVal;

   512     }

   513 

   514 EXPORT_C TInt CSenCredentialProperties::FacetValueL(TDesC8& aURI,

   515                                                         HBufC8*& aValueTo)

   516     {

   517     TInt retVal(KErrNotFound);

   518 

   519     TXmlEngElement element = AsElementL();

   520     RXmlEngNodeList<TXmlEngElement> list;

   521     CleanupClosePushL(list);

   522 

   523     element.GetElementsByTagNameL(list, KSenFacet);

   524 

   525     if ( list.Count() > 0 )

   526         {

   527         TXmlEngElement element;

   528         TPtrC8 value;

   529 

   530         while ( list.HasNext() )

   531             {

   532             element = list.Next();

   533             value.Set(element.AttributeValueL(KFacetAttrName));

   534             if ( value == aURI )

   535                 {

   536                 if ( element.Text().Length() < 1 )

   537                     {

   538                     aValueTo = KSenFacetValTrue().Alloc();

   539                     }

   540                 else

   541                     {

   542                     aValueTo = element.Text().Alloc();

   543                     }

   544 

   545                 if(!aValueTo) // OOM

   546                     {

   547                     retVal = KErrNoMemory;

   548                     }

   549                 else

   550                     {

   551                     retVal = KErrNone;

   552                     }

   553                 }

   554             }

   555         }

   556 

   557     CleanupStack::PopAndDestroy(&list);

   558 

   559     return retVal;

   560     }

   561 

   562 EXPORT_C TInt CSenCredentialProperties::RemoveFacetL(const TDesC8& aURI)

   563     {

   564     TInt retVal(KErrNotFound);

   565 

   566     TXmlEngElement element = AsElementL();

   567     RXmlEngNodeList<TXmlEngElement> list;

   568     CleanupClosePushL(list);

   569 

   570     element.GetElementsByTagNameL(list, KSenFacet);

   571 

   572     if ( list.Count() > 0 )

   573         {

   574         TXmlEngElement element;

   575         TPtrC8 value;

   576 

   577         while ( list.HasNext() )

   578             {

   579             element = list.Next();

   580             value.Set(element.AttributeValueL(KFacetAttrName));

   581             if ( value == aURI )

   582                 {

   583                 element.Remove();

   584                 retVal = KErrNone;

   585                 }

   586             }

   587         }

   588 

   589     CleanupStack::PopAndDestroy(&list);

   590     return retVal;

   591     }

   592 

   593 

   594 EXPORT_C TInt CSenCredentialProperties::AddFacetL(const CSenFacet& aFacet)

   595     {

   596     TInt retVal(KErrNotFound);

   597 

   598     TXmlEngElement element = AsElementL();

   599     RXmlEngNodeList<TXmlEngElement> list;

   600     CleanupClosePushL(list);

   601 

   602     element.GetElementsByTagNameL(list, KSenFacet);

   603 

   604     if ( list.Count() > 0 )

   605         {

   606         TXmlEngElement element;

   607         TPtrC8 value;

   608 

   609         while ( list.HasNext() )

   610             {

   611             element = list.Next();

   612             value.Set(element.AttributeValueL(KFacetAttrName));

   613             if ( value == ((CSenFacet&)aFacet).Name() )

   614                 {

   615                 retVal = KErrAlreadyExists;

   616                 }

   617             }

   618         }

   619 

   620     CleanupStack::PopAndDestroy(&list); // Close()

   621 

   622     if ( retVal != KErrAlreadyExists)

   623         {

   624         TXmlEngElement newElement = element.AddNewElementL(KSenFacet);

   625         newElement.SetAttributeL(KFacetAttrName, ((CSenFacet&)aFacet).Name());

   626         if(((CSenFacet&)aFacet).Type() != KNullDesC8)

   627             {

   628             newElement.SetAttributeL(KFacetAttrType,((CSenFacet&)aFacet).Type());

   629             }

   630         newElement.SetTextNoEncL(((CSenFacet&)aFacet).Value());

   631         retVal = KErrNone;

   632         }

   633 

   634     return retVal;

   635     }

   636 

   637 EXPORT_C TInt CSenCredentialProperties::SetFacetL(const CSenFacet& aFacet)

   638     {

   639     TInt retVal(KErrNotFound);

   640 

   641     TXmlEngElement element = AsElementL();

   642     RXmlEngNodeList<TXmlEngElement> list;

   643     CleanupClosePushL(list);

   644 

   645     element.GetElementsByTagNameL(list, KSenFacet);

   646 

   647     if ( list.Count() > 0 )

   648         {

   649         TXmlEngElement element;

   650         TPtrC8 value;

   651 

   652         while ( list.HasNext() && retVal == KErrNotFound )

   653             {

   654             element = list.Next();

   655             value.Set(element.AttributeValueL(KFacetAttrName));

   656             if ( value == ((CSenFacet&)aFacet).Name() )

   657                 {

   658                 if(((CSenFacet&)aFacet).Type() != KNullDesC8)

   659                     {

   660                     element.SetAttributeL(KFacetAttrType,((CSenFacet&)aFacet).Type());

   661                     }

   662                 element.SetTextNoEncL(((CSenFacet&)aFacet).Value());

   663                 retVal = KErrNone;

   664                 }

   665             }

   666         }

   667 

   668     CleanupStack::PopAndDestroy(&list); // Close()

   669 

   670     if ( retVal == KErrNotFound )

   671         {

   672         TXmlEngElement newElement = element.AddNewElementL(KSenFacet);

   673         newElement.SetAttributeL(KFacetAttrName, ((CSenFacet&)aFacet).Name());

   674         if(((CSenFacet&)aFacet).Type() != KNullDesC8)

   675             {

   676             newElement.SetAttributeL(KFacetAttrType,((CSenFacet&)aFacet).Type());

   677             }

   678         newElement.SetTextNoEncL(((CSenFacet&)aFacet).Value());

   679         retVal = KErrNone;

   680         }

   681 

   682     return retVal;

   683     }

   684 

   685 EXPORT_C void CSenCredentialProperties::SetValidUntilL(TTime aValidUntil)

   686     {

   687     TXmlEngElement element = AsElementL();

   688     RXmlEngNodeList<TXmlEngElement> list;

   689     CleanupClosePushL(list);

   690 

   691     element.GetElementsByTagNameL(list, KSenCredentialValidUntil);

   692 

   693     TXmlEngElement validUntilElement;

   694     if ( list.Count() > 0 )

   695         {

   696         validUntilElement = list.Next();

   697         }

   698     else

   699         {

   700         validUntilElement = element.AddNewElementL(KSenCredentialValidUntil);

   701         }

   702 

   703     HBufC8* pDateDes = HBufC8::NewLC(KCredIdBufSize);

   704     TPtr8 datePtr = pDateDes->Des();

   705     SenDateUtils::ToXmlDateTimeUtf82L(datePtr, aValidUntil);

   706     validUntilElement.SetTextL(*pDateDes);

   707     CleanupStack::PopAndDestroy(pDateDes);

   708 

   709     CleanupStack::PopAndDestroy(&list); // Close()

   710     }

   711         

   712 EXPORT_C TTime CSenCredentialProperties::ValidUntilL()

   713     {

   714     TTime retTime = Time::NullTTime();

   715 

   716     TXmlEngElement element = AsElementL();

   717     RXmlEngNodeList<TXmlEngElement> list;

   718     CleanupClosePushL(list);

   719 

   720     element.GetElementsByTagNameL(list, KSenCredentialValidUntil);

   721 

   722     if ( list.Count() > 0 )

   723         {

   724         TXmlEngElement validUntilElement = list.Next();

   725         retTime = SenDateUtils::FromXmlDateTimeL(validUntilElement.Text());

   726         }

   727 

   728     CleanupStack::PopAndDestroy(&list); // Close()

   729 

   730     return retTime;

   731     }

   732 

   733 EXPORT_C CSenCredentialIdentifier* CSenCredentialIdentifier::NewL()

   734     {

   735     CSenCredentialIdentifier* pNew = NewLC();

   736     CleanupStack::Pop(pNew);

   737     return pNew;

   738     }

   739 

   740 EXPORT_C CSenCredentialIdentifier* CSenCredentialIdentifier::NewLC()

   741     {

   742     CSenCredentialIdentifier* pNew = new (ELeave) CSenCredentialIdentifier;

   743     CleanupStack::PushL(pNew);

   744     pNew->BaseConstructL(KSenCredentialIdentifierLocalname);

   745     return pNew;

   746     }

   747 

   748 EXPORT_C CSenCredentialIdentifier* CSenCredentialIdentifier::NewL(

   749                                             const TDesC8& aNsUri,

   750                                             const TDesC8& aLocalName,

   751                                             const TDesC8& aQName,

   752                                             const RAttributeArray& aAttributes)

   753     {

   754     CSenCredentialIdentifier* pNew = NewLC(aNsUri, aLocalName, aQName, aAttributes);

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

   756     return pNew;

   757     }

   758 

   759 EXPORT_C CSenCredentialIdentifier* CSenCredentialIdentifier::NewLC(

   760                                             const TDesC8& aNsUri,

   761                                             const TDesC8& aLocalName,

   762                                             const TDesC8& aQName,

   763                                             const RAttributeArray& aAttributes)

   764     {

   765     CSenCredentialIdentifier* pNew = new (ELeave) CSenCredentialIdentifier;

   766     CleanupStack::PushL(pNew);

   767     pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes);

   768     return pNew;

   769     }

   770 

   771 EXPORT_C CSenCredentialIdentifier* CSenCredentialIdentifier::NewL(

   772                                             const TDesC8& aNsUri,

   773                                             const TDesC8& aLocalName,

   774                                             const TDesC8& aQName,

   775                                             const RAttributeArray& aAttributes,

   776                                             TXmlEngElement& aParent)

   777     {

   778     CSenCredentialIdentifier* pNew = NewLC(aNsUri, aLocalName,

   779                                            aQName, aAttributes, aParent);

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

   781     return pNew;

   782     }

   783 

   784 EXPORT_C CSenCredentialIdentifier* CSenCredentialIdentifier::NewLC(

   785                                             const TDesC8& aNsUri,

   786                                             const TDesC8& aLocalName,

   787                                             const TDesC8& aQName,

   788                                             const RAttributeArray& aAttributes,

   789                                             TXmlEngElement& aParent)

   790     {

   791     CSenCredentialIdentifier* pNew = new (ELeave) CSenCredentialIdentifier;

   792     CleanupStack::PushL(pNew);

   793     pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent);

   794     return pNew;

   795     }

   796 

   797 EXPORT_C CSenCredentialIdentifier* CSenCredentialIdentifier::NewL(

   798                                             const TDesC8& aNsUri,

   799                                             const TDesC8& aLocalName,

   800                                             const TDesC8& aQName,

   801                                             const RAttributeArray& aAttributes,

   802                                             TXmlEngElement& aParent,

   803                                             RSenDocument& aOwnerDocument)

   804     {

   805     CSenCredentialIdentifier* pNew = NewLC(aNsUri, aLocalName,

   806                                            aQName, aAttributes,

   807                                            aParent, aOwnerDocument);

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

   809     return pNew;

   810     }

   811 

   812 EXPORT_C CSenCredentialIdentifier* CSenCredentialIdentifier::NewLC(

   813                                             const TDesC8& aNsUri,

   814                                             const TDesC8& aLocalName,

   815                                             const TDesC8& aQName,

   816                                             const RAttributeArray& aAttributes,

   817                                             TXmlEngElement& aParent,

   818                                             RSenDocument& aOwnerDocument)

   819     {

   820     CSenCredentialIdentifier* pNew = new (ELeave) CSenCredentialIdentifier;

   821     CleanupStack::PushL(pNew);

   822     pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent,

   823                          aOwnerDocument);

   824     return pNew;

   825     }

   826 

   827 EXPORT_C CSenCredentialIdentifier::~CSenCredentialIdentifier()

   828     {

   829     }

   830 

   831 CSenCredentialIdentifier::CSenCredentialIdentifier()

   832     {

   833     }

   834 

   835 EXPORT_C void CSenCredentialIdentifier::SetIdL(TInt aId)

   836     {

   837     TXmlEngElement element = AsElementL();

   838     RXmlEngNodeList<TXmlEngElement> list;

   839     CleanupClosePushL(list);

   840 

   841     element.GetElementsByTagNameL(list, KSenCredentialId);

   842 

   843     TXmlEngElement idElement;

   844     if ( list.Count() > 0 )

   845         {

   846         idElement = list.Next();

   847         }

   848     else

   849         {

   850         idElement = element.AddNewElementL(KSenCredentialId);

   851         }

   852 

   853     TBuf8<KCredIdBufSize> buffer;

   854     buffer.Num(aId);

   855     idElement.SetTextL(buffer);

   856 

   857     CleanupStack::PopAndDestroy(&list); // Close()

   858     }

   859 

   860 EXPORT_C TInt CSenCredentialIdentifier::IdL()

   861     {

   862     TInt retVal(KErrNotFound);

   863 

   864     TXmlEngElement element = AsElementL();

   865     RXmlEngNodeList<TXmlEngElement> list;

   866     CleanupClosePushL(list);

   867 

   868     element.GetElementsByTagNameL(list, KSenCredentialId);

   869 

   870     if ( list.Count() > 0 )

   871         {

   872         TXmlEngElement idElement = list.Next();

   873         TLex8 lex;

   874         lex.Assign(idElement.Text());

   875         lex.Val( retVal );

   876         }

   877 

   878     CleanupStack::PopAndDestroy(&list); // Close()

   879 

   880     return retVal;

   881     }

   882     

   883 CSenCredentialData* CSenCredentialData::NewL()

   884     {

   885     CSenCredentialData* pNew = CSenCredentialData::NewLC();

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

   887     return pNew;

   888     }

   889 

   890 CSenCredentialData* CSenCredentialData::NewLC()

   891     {

   892     CSenCredentialData* pNew = new (ELeave) CSenCredentialData;

   893     CleanupStack::PushL(pNew);

   894     return pNew;

   895     }

   896 

   897 CSenCredentialData::~CSenCredentialData()

   898     {

   899     iObserverArray.Close();

   900     }

   901     

   902 CSenCredentialData::CSenCredentialData()

   903     {

   904     }

   905     

   906 EXPORT_C void RSenCredentialPtr::OpenL(CSenInternalCredential* apCredential)

   907     {

   908     CREDLOG_L(KSenCredsLogLevelMax,"CredentialPtr OPEN");

   909 

   910     ipCredentialData = CSenCredentialData::NewL();

   911     ipCredentialData->iCounter = 1;

   912     ipCredentialData->ipCredential = apCredential;

   913     CREDLOG_L(KSenCredsLogLevelMax,".....END");

   914     }

   915     

   916 EXPORT_C CSenInternalCredential* RSenCredentialPtr::Credential()

   917     {

   918     if ( ipCredentialData )

   919         {

   920         return ipCredentialData->ipCredential;

   921         }

   922     else

   923         {

   924         return NULL;

   925         }

   926     }

   927     

   928 EXPORT_C void RSenCredentialPtr::SetCredential(CSenInternalCredential* apCredential)

   929     {

   930     CREDLOG_L(KSenCredsLogLevelMax,"CredentialPtr SET");

   931     if ( ipCredentialData )

   932         {

   933         delete ipCredentialData->ipCredential;

   934         ipCredentialData->ipCredential = apCredential;

   935 

   936         TInt count = ipCredentialData->iObserverArray.Count();

   937         for (TInt i=0; i < count; i++)

   938             {

   939             ipCredentialData->iObserverArray[i]->CredentialChanged(MSenCredentialObserver::EReplaced);

   940             }

   941         }

   942     CREDLOG_L(KSenCredsLogLevelMax,".....END");

   943     }

   944     

   945 EXPORT_C RSenCredentialPtr RSenCredentialPtr::Clone()

   946     {

   947     if ( ipCredentialData )

   948         {

   949         CREDLOG_L(KSenCredsLogLevelMax,"CredentialPtr CLONE");

   950         (ipCredentialData->iCounter)++;

   951 #ifdef _SENDEBUG

   952 TRAP_IGNORE

   953     (

   954             _LIT8(KCredsLogLine, "....counter = %d");

   955             CREDLOG_FORMAT((KSenCredsLogChannel, KSenCredsLogLevelMax, KCredsLogLine,  ipCredentialData->iCounter));

   956             CREDLOG_L(KSenCredsLogLevelMax,"....ticket ");

   957             if (ipCredentialData->ipCredential)

   958                 {

   959                 HBufC8* ptr = ipCredentialData->ipCredential->AsXmlL();

   960                 CleanupStack::PushL(ptr);

   961                 CREDLOG_ALL(KSenCredsLogLevelMax, *ptr);

   962                 CleanupStack::PopAndDestroy(ptr);    

   963                 }

   964             else

   965                 {

   966                 CREDLOG_L(KSenCredsLogLevelMax,"....NULL");

   967                 }

   968         CREDLOG_L(KSenCredsLogLevelMax,"....END");

   969     )        

   970 #endif // _SENDEBUG

   971         }

   972     return *this;

   973     }

   974     

   975 EXPORT_C void RSenCredentialPtr::Close()

   976     {

   977     if ( ipCredentialData )

   978         {

   979         CREDLOG_L(KSenCredsLogLevelMax,"CredentialPtr CLOSE");

   980         (ipCredentialData->iCounter)--;

   981 #ifdef _SENDEBUG

   982 TRAP_IGNORE

   983     (

   984             _LIT8(KCredsLogLine, "....counter = %d");

   985             CREDLOG_FORMAT((KSenCredsLogChannel, KSenCredsLogLevelMax, KCredsLogLine, ipCredentialData->iCounter));

   986             CREDLOG_L(KSenCredsLogLevelMax,"....ticket ");

   987             if (ipCredentialData->ipCredential)

   988                 {

   989                 HBufC8* ptr = ipCredentialData->ipCredential->AsXmlL();

   990                 CleanupStack::PushL(ptr);

   991                 CREDLOG_ALL(KSenCredsLogLevelMax, *ptr);

   992                 CleanupStack::PopAndDestroy(ptr);    

   993                 }

   994             else

   995                 {

   996                 CREDLOG_L(KSenCredsLogLevelMax,"....NULL");

   997                 }

   998     )                

   999 #endif // _SENDEBUG

  1000         if ( ipCredentialData->iCounter == 0 )

  1001             {

  1002             CREDLOG_L(KSenCredsLogLevelMax,"....deleting Credential");

  1003             delete ipCredentialData->ipCredential;

  1004             ipCredentialData->ipCredential = NULL;

  1005             TInt count = ipCredentialData->iObserverArray.Count();

  1006             for (TInt i=0; i < count; i++)

  1007                 {

  1008                 ipCredentialData->iObserverArray[i]->CredentialChanged(MSenCredentialObserver::EDestroyed);

  1009                 }

  1010 

  1011             delete ipCredentialData;

  1012             }

  1013         ipCredentialData = NULL;

  1014         CREDLOG_L(KSenCredsLogLevelMax,"....END");

  1015         }

  1016     }

  1017 

  1018 EXPORT_C void RSenCredentialPtr::CloseAndDestroyCredential()

  1019     {

  1020     if ( ipCredentialData )

  1021         {

  1022         delete ipCredentialData->ipCredential;

  1023         ipCredentialData->ipCredential = NULL;

  1024         

  1025         TInt count = ipCredentialData->iObserverArray.Count();

  1026         for (TInt i=0; i < count; i++)

  1027             {

  1028             ipCredentialData->iObserverArray[i]->CredentialChanged(MSenCredentialObserver::EDestroyed);

  1029             }

  1030 CREDLOG_L(KSenCredsLogLevelMax,"CredentialPtr CLOSEANDDESTROY");

  1031         

  1032         (ipCredentialData->iCounter)--;

  1033         if ( ipCredentialData->iCounter == 0 )

  1034             {

  1035             CREDLOG_L(KSenCredsLogLevelMax,".....deleting");

  1036             delete ipCredentialData;

  1037             ipCredentialData = NULL;

  1038             }

  1039 CREDLOG_L(KSenCredsLogLevelMax,".....END");

  1040         }

  1041     }

  1042 

  1043 EXPORT_C void RSenCredentialPtr::AddCredentialObserverL(MSenCredentialObserver& aObserver)	//codescannerwarnings

  1044     {

  1045     if ( ipCredentialData )

  1046         {

  1047         TInt leaveCode( KErrNone );

  1048         TRAP( leaveCode, ipCredentialData->iObserverArray.AppendL(&aObserver); )

  1049 #ifdef _SENDEBUG        

  1050         if( leaveCode )

  1051             {

  1052             CREDLOG_L(KSenCredsLogLevelMin, "RSenCredentialPtr::AddCredentialObserverL:");

  1053             _LIT8(KCredsLogLine, "- ipCredentialData->iObserverArray.AppendL leaved (%d)!");

  1054             CREDLOG_FORMAT(( KSenCredsLogChannel, KSenCredsLogLevelMax, KCredsLogLine, leaveCode ));

  1055             }

  1056 #endif // _SENDEBUG

  1057         leaveCode = 0; // ignored in release builds

  1058         }

  1059     }

  1060 

  1061 EXPORT_C TInt RSenCredentialPtr::RemoveCredentialObserver(MSenCredentialObserver& aObserver)

  1062     {

  1063     if ( ipCredentialData )

  1064         {

  1065         TInt pos = ipCredentialData->iObserverArray.Find(&aObserver);

  1066         if ( pos != KErrNotFound )

  1067             {

  1068             ipCredentialData->iObserverArray.Remove(pos);

  1069             }

  1070         else

  1071             {

  1072             return pos;

  1073             }

  1074         }

  1075         

  1076     return KErrNone;

  1077     }

  1078 

  1079 EXPORT_C RSenCredentialPtr::RSenCredentialPtr()

  1080 : ipCredentialData(NULL)

  1081     {

  1082     }

  1083 

  1084 // END OF FILE