1 /*

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

    27 

    28 #include <s32strm.h> // RWriteStream

    29 #include <SenXmlReader.h>

    30 #include "senlayeredhttptransportproperties.h"

    31 #include <SenHttpTransportProperties.h>              // property keys (constants)

    32 #include <SenTransportProperties.h>                  // property keys (constants)

    33 #include "senpropertieselement.h"   // private: Utils\inc

    34 #include "senpropertiesfragment.h"  // private: Utils\inc

    35 

    36 EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewL()

    37     {

    38     CSenLayeredHttpTransportProperties* pNew = NewLC();

    39     CleanupStack::Pop(); // pNew

    40     return pNew;

    41     }

    42 

    43 EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewLC()

    44     {

    45     CSenLayeredHttpTransportProperties* pNew = new (ELeave) CSenLayeredHttpTransportProperties;

    46     CleanupStack::PushL(pNew);

    47 

    48     // omit parsing by passing zero-length descriptor

    49     pNew->BaseConstructL(KSenLayeredXmlPropertiesLocalname, KNullDesC8, NULL);

    50     return pNew;

    51     }

    52 

    53 EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewL(const TDesC8& aXmlUtf8, CSenXmlReader& aParser)

    54     {

    55     CSenLayeredHttpTransportProperties* pNew = NewLC(aXmlUtf8, aParser);

    56     CleanupStack::Pop(); // pNew

    57     return pNew;

    58     }

    59 

    60 EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewLC(const TDesC8& aXmlUtf8, CSenXmlReader& aParser)

    61     {

    62     CSenLayeredHttpTransportProperties* pNew = new (ELeave) CSenLayeredHttpTransportProperties;

    63     CleanupStack::PushL(pNew);

    64 

    65     // parse the XML document  descriptor into DOM fragment

    66     pNew->BaseConstructL(KSenLayeredXmlPropertiesLocalname, aXmlUtf8, &aParser);

    67     return pNew;

    68     }

    69 

    70 EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewL(const CSenElement& aElement)

    71     {

    72     CSenLayeredHttpTransportProperties* pNew = NewLC(aElement);

    73     CleanupStack::Pop(); // pNew

    74     return pNew;

    75     }

    76 

    77 EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewLC(const CSenElement& aElement)

    78     {

    79     CSenLayeredHttpTransportProperties* pNew = new (ELeave) CSenLayeredHttpTransportProperties;

    80     CleanupStack::PushL(pNew);

    81 

    82     // parse the XML document  descriptor into DOM fragment

    83     pNew->BaseConstructL(aElement);

    84     return pNew;

    85     }

    86 

    87 // RStringPool variants:

    88 EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewL(RStringPool& aStringPool)

    89     {

    90     CSenLayeredHttpTransportProperties* pNew = NewLC(aStringPool);

    91     CleanupStack::Pop(); // pNew

    92     return pNew;

    93     }

    94 

    95 EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewLC(RStringPool& aStringPool)

    96     {

    97     CSenLayeredHttpTransportProperties* pNew = new (ELeave) CSenLayeredHttpTransportProperties;

    98     CleanupStack::PushL(pNew);

    99 

   100     // omit parsing by passing zero-length descriptor

   101     pNew->BaseConstructL(KSenLayeredXmlPropertiesLocalname, KNullDesC8, NULL, &aStringPool);

   102     return pNew;

   103     }

   104 

   105 EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewL(const TDesC8& aXmlUtf8, CSenXmlReader& aParser, RStringPool& aStringPool)

   106     {

   107     CSenLayeredHttpTransportProperties* pNew = NewLC(aXmlUtf8, aParser, aStringPool);

   108     CleanupStack::Pop(); // pNew

   109     return pNew;

   110     }

   111 

   112 EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewLC(const TDesC8& aXmlUtf8, CSenXmlReader& aParser, RStringPool& aStringPool)

   113     {

   114     CSenLayeredHttpTransportProperties* pNew = new (ELeave) CSenLayeredHttpTransportProperties;

   115     CleanupStack::PushL(pNew);

   116 

   117     // parse the XML document  descriptor into DOM fragment

   118     pNew->BaseConstructL(KSenLayeredXmlPropertiesLocalname, aXmlUtf8, &aParser, &aStringPool);

   119     return pNew;

   120     }

   121 

   122 EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewL(const CSenElement& aElement, RStringPool& aStringPool)

   123     {

   124     CSenLayeredHttpTransportProperties* pNew = NewLC(aElement, aStringPool);

   125     CleanupStack::Pop(); // pNew

   126     return pNew;

   127     }

   128 

   129 EXPORT_C CSenLayeredHttpTransportProperties* CSenLayeredHttpTransportProperties::NewLC(const CSenElement& aElement, RStringPool& aStringPool)

   130     {

   131     CSenLayeredHttpTransportProperties* pNew = new (ELeave) CSenLayeredHttpTransportProperties;

   132     CleanupStack::PushL(pNew);

   133 

   134     // parse the XML document  descriptor into DOM fragment

   135     pNew->BaseConstructL(aElement, &aStringPool);

   136     return pNew;

   137     }

   138 

   139     

   140 void CSenLayeredHttpTransportProperties::SetReader(CSenXmlReader& aReader)

   141     {

   142     CSenLayeredTransportProperties::SetReader(aReader);

   143     }    

   144     

   145 

   146 MSenProperties::TSenPropertiesClassType CSenLayeredHttpTransportProperties::PropertiesClassType() 

   147     {

   148     return ESenLayeredHttpTransportProperties;

   149     }

   150 

   151 void CSenLayeredHttpTransportProperties::WriteToL(RWriteStream& aWriteStream)

   152     {

   153     CSenLayeredTransportProperties::WriteToL(aWriteStream);

   154     }

   155 

   156 void CSenLayeredHttpTransportProperties::ReadFromL(const TDesC8& aBuffer)

   157     {

   158     CSenLayeredTransportProperties::ReadFromL(aBuffer);

   159     }

   160     

   161 HBufC8* CSenLayeredHttpTransportProperties::AsUtf8L()

   162     {

   163     return CSenLayeredTransportProperties::AsUtf8L();

   164     }

   165 

   166 HBufC8* CSenLayeredHttpTransportProperties::AsUtf8LC()

   167     {

   168     return CSenLayeredTransportProperties::AsUtf8LC();

   169     }

   170     

   171 TBool CSenLayeredHttpTransportProperties::IsSafeToCast(TSenPropertiesClassType aClass)

   172     {

   173     if ( aClass == MSenProperties::ESenLayeredHttpTransportProperties )

   174         {

   175         return ETrue;

   176         }

   177     else

   178         {

   179         return CSenLayeredTransportProperties::IsSafeToCast( aClass );

   180         }

   181     }

   182 

   183 TInt CSenLayeredHttpTransportProperties::SetPropertyL(const TDesC8& aName, const TDesC8& aValue)

   184     {

   185     return CSenLayeredTransportProperties::SetPropertyL(aName, aValue);

   186     }

   187     

   188 TInt CSenLayeredHttpTransportProperties::PropertyL(const TDesC8& aName, TPtrC8& aValue)

   189     {

   190     return CSenLayeredTransportProperties::PropertyL(aName, aValue);

   191     }

   192     

   193 TInt CSenLayeredHttpTransportProperties::PropertyL(const TDesC8& aName, MSenProperty*& aValue, TSenPropertiesLayer aLayer)

   194     {

   195     return CSenLayeredTransportProperties::PropertyL(aName, aValue, aLayer);

   196     }

   197         

   198 TInt CSenLayeredHttpTransportProperties::PropertyL(const TDesC8& aName, MSenProperty*& aValue)

   199     {

   200     return CSenLayeredTransportProperties::PropertyL(aName, aValue);

   201     }

   202 

   203 TInt CSenLayeredHttpTransportProperties::PropertiesByTypeL(const TDesC8& aType, RPointerArray<MSenProperty>& aArray)

   204     {

   205     return CSenLayeredTransportProperties::PropertiesByTypeL(aType, aArray);

   206     }

   207 

   208 TInt CSenLayeredHttpTransportProperties::SetIntPropertyL(const TDesC8& aName, const TInt aValue)

   209     {

   210     return CSenLayeredTransportProperties::SetIntPropertyL(aName, aValue);

   211     }

   212     

   213 TInt CSenLayeredHttpTransportProperties::IntPropertyL(const TDesC8& aName, TInt& aValue)

   214     {

   215     return CSenLayeredTransportProperties::IntPropertyL(aName, aValue);

   216     }

   217     

   218 TInt CSenLayeredHttpTransportProperties::SetBoolPropertyL(const TDesC8& aName, const TBool aValue)

   219     {

   220     return CSenLayeredTransportProperties::SetBoolPropertyL(aName, aValue);

   221     }

   222     

   223 TInt CSenLayeredHttpTransportProperties::BoolPropertyL(const TDesC8& aName, TBool& aValue)

   224     {

   225     return CSenLayeredTransportProperties::BoolPropertyL(aName, aValue);

   226     }   

   227 

   228 void CSenLayeredHttpTransportProperties::WriteToL(RWriteStream& aWriteStream, TSenPropertiesLayer aLayer)

   229     {

   230     CSenLayeredTransportProperties::WriteToL(aWriteStream, aLayer);

   231     }

   232 

   233 void CSenLayeredHttpTransportProperties::ReadFromL(const TDesC8& aBuffer, TSenPropertiesLayer aLayer)

   234     {

   235     CSenLayeredTransportProperties::ReadFromL(aBuffer, aLayer);

   236     }

   237     

   238 HBufC8* CSenLayeredHttpTransportProperties::AsUtf8L(TSenPropertiesLayer aLayer)

   239     {

   240     return CSenLayeredTransportProperties::AsUtf8L(aLayer);

   241     }

   242 

   243 HBufC8* CSenLayeredHttpTransportProperties::AsUtf8LC(TSenPropertiesLayer aLayer)

   244     {

   245     return CSenLayeredTransportProperties::AsUtf8LC(aLayer);

   246     }

   247 

   248 TInt CSenLayeredHttpTransportProperties::ShrinkTo(TSenPropertiesLayer aLayer)

   249     {

   250     return CSenLayeredTransportProperties::ShrinkTo(aLayer);

   251     }

   252     

   253 void CSenLayeredHttpTransportProperties::ExpandToL(TSenPropertiesLayer aLayer)

   254     {

   255     CSenLayeredTransportProperties::ExpandToL(aLayer);

   256     }

   257     

   258 MSenLayeredProperties::TSenPropertiesLayer CSenLayeredHttpTransportProperties::TopLayer()

   259     {

   260     return CSenLayeredTransportProperties::TopLayer();

   261     }

   262     

   263 TInt CSenLayeredHttpTransportProperties::SetPropertyL(const TDesC8& aName, const TDesC8& aValue, TSenPropertiesLayer aLayer)

   264     {

   265     return CSenLayeredTransportProperties::SetPropertyL(aName, aValue, aLayer);

   266     }

   267     

   268 TInt CSenLayeredHttpTransportProperties::PropertyL(const TDesC8& aName,

   269                                                      TPtrC8& aValue,

   270                                                      TSenPropertiesLayer aLayer)

   271     {

   272     return CSenLayeredTransportProperties::PropertyL(aName, aValue, aLayer);

   273     }

   274 

   275 TInt CSenLayeredHttpTransportProperties::SetIntPropertyL(const TDesC8& aName,

   276                                                             const TInt aValue,

   277                                                             TSenPropertiesLayer aLayer)

   278     {

   279     return CSenLayeredTransportProperties::SetIntPropertyL(aName, aValue, aLayer);

   280     }

   281     

   282 TInt CSenLayeredHttpTransportProperties::IntPropertyL(const TDesC8& aName,

   283                                                            TInt& aValue,

   284                                                            TSenPropertiesLayer aLayer)

   285     {

   286     return CSenLayeredTransportProperties::IntPropertyL(aName, aValue, aLayer);

   287     }

   288     

   289 TInt CSenLayeredHttpTransportProperties::SetBoolPropertyL(const TDesC8& aName,

   290                                                                const TBool aValue,

   291                                                                TSenPropertiesLayer aLayer)

   292     {

   293     return CSenLayeredTransportProperties::SetBoolPropertyL(aName, aValue, aLayer);

   294     }

   295     

   296 TInt CSenLayeredHttpTransportProperties::BoolPropertyL(const TDesC8& aName,

   297                                                             TBool& aValue,

   298                                                             TSenPropertiesLayer aLayer)

   299     {

   300     return CSenLayeredTransportProperties::BoolPropertyL(aName, aValue, aLayer);

   301     }    

   302 

   303 TInt CSenLayeredHttpTransportProperties::IapIdL(TUint32& aCurrentIapId)

   304     {

   305     return CSenLayeredTransportProperties::IapIdL(aCurrentIapId);

   306     }

   307 

   308 TInt CSenLayeredHttpTransportProperties::SnapIdL(TUint32& aCurrentSnapId)

   309     {

   310     return CSenLayeredTransportProperties::SnapIdL(aCurrentSnapId);

   311     }

   312 

   313 TInt CSenLayeredHttpTransportProperties::ProxyPortL(TInt& aProxyPort)

   314     {

   315     return CSenLayeredTransportProperties::ProxyPortL(aProxyPort);

   316     }

   317 

   318 TInt CSenLayeredHttpTransportProperties::ProxyHostL(TPtrC8& aProxyHost)

   319     {

   320     return CSenLayeredTransportProperties::ProxyHostL(aProxyHost);

   321     }

   322 

   323 TInt CSenLayeredHttpTransportProperties::ProxyUsageL(TBool& aValue)

   324     {

   325     return CSenLayeredTransportProperties::ProxyUsageL(aValue);

   326     }

   327 

   328 TInt CSenLayeredHttpTransportProperties::IAPDialogL(TBool& aValue)

   329     {

   330     return CSenLayeredTransportProperties::IAPDialogL(aValue);

   331     }

   332 

   333 TInt CSenLayeredHttpTransportProperties::SnapDialogL(TBool& aValue)

   334 	{

   335 	return CSenLayeredTransportProperties::SnapDialogL(aValue);

   336 	}

   337 TInt CSenLayeredHttpTransportProperties::ContentTypeL(TPtrC8& aContentType)

   338     {

   339     return PropertyL(KContentTypeLocalName, aContentType);

   340     }

   341 

   342 TInt CSenLayeredHttpTransportProperties::UserAgentL(TPtrC8& aUserAgent)

   343     {

   344     return CSenLayeredTransportProperties::UserAgentL(aUserAgent);

   345     }

   346 

   347 TInt CSenLayeredHttpTransportProperties::AcceptL(MSenProperty*& aAccept)

   348     {

   349     return CSenLayeredXmlProperties::PropertyL(KAcceptLocalName, aAccept);

   350     }

   351 

   352 TInt CSenLayeredHttpTransportProperties::HttpMethodL(TSenHttpMethod& aMethod)

   353     {

   354     TPtrC8 method;

   355     TInt retVal = PropertyL(KHttpMethodLocalName, method);

   356     if (retVal == KErrNone)

   357         {

   358         if (method == KHttpGet)

   359             {

   360             aMethod = ESenHttpGet;

   361             return KErrNone;

   362             }

   363         else if (method == KHttpPost)

   364             {

   365             aMethod = ESenHttpPost;

   366             return KErrNone;

   367             }

   368         else if (method == KHttpPut)

   369             {

   370             aMethod = ESenHttpPut;

   371             return KErrNone;

   372             }

   373         else if (method == KHttpDelete)

   374             {

   375             aMethod = ESenHttpDelete;

   376             return KErrNone;

   377             }

   378         else

   379             {

   380             return KErrUnknown;

   381             }

   382         }

   383     else

   384         {

   385         return retVal;

   386         }

   387     }

   388 

   389 TInt CSenLayeredHttpTransportProperties::HttpVersionL(TSenHttpVersion& aHttpVersion)

   390     {

   391     TPtrC8 method;

   392     TInt retVal = PropertyL(KHttpVersionLocalName, method);

   393     if (retVal == KErrNone)

   394         {

   395         if (method == KHttp10)

   396             {

   397             aHttpVersion = ESenHttp10;

   398             return KErrNone;

   399             }

   400         else if (method == KHttp11)

   401             {

   402             aHttpVersion = ESenHttp11;

   403             return KErrNone;

   404             }

   405         else

   406             {

   407             return KErrUnknown;

   408             }

   409         }

   410     else

   411         {

   412         return retVal;

   413         }

   414     }

   415     

   416 TInt CSenLayeredHttpTransportProperties::HttpHeadersL(

   417                                         RPointerArray<MSenProperty>& aArray)

   418     {

   419     return PropertiesByTypeL(KHttpHeaderType, aArray);

   420     }

   421 

   422 TInt CSenLayeredHttpTransportProperties::SetPropertyL(const TDesC8& aName, 

   423                                                       const TDesC8& aValue,

   424                                                       const TDesC8& aType)

   425     {

   426     return CSenLayeredTransportProperties::SetPropertyL(aName, aValue, aType);

   427     }

   428 

   429 TInt CSenLayeredHttpTransportProperties::PropertyL(const TDesC8& aName, 

   430                                                    TPtrC8& aValue,

   431                                                    TPtrC8& aType)

   432     {

   433     return CSenLayeredTransportProperties::PropertyL(aName, aValue, aType);

   434     }

   435 MSenProperties* CSenLayeredHttpTransportProperties::CloneL() const

   436     {

   437     CSenElement& element = ipFragment->AsElement();

   438     

   439     CSenLayeredHttpTransportProperties* pProperties = NewLC(element);

   440     if ( ipChildProperties )

   441         {

   442         CSenLayeredHttpTransportProperties* pChildProperties =

   443                                 (CSenLayeredHttpTransportProperties*)ipChildProperties->CloneL();

   444         pProperties->ipChildProperties = pChildProperties;

   445         }

   446     

   447     CleanupStack::Pop(pProperties);

   448     return pProperties;

   449     }

   450 

   451 void CSenLayeredHttpTransportProperties::BaseConstructL(const TDesC8& aLocalname, 

   452                                                  const TDesC8& aXml,

   453                                                  CSenXmlReader* aParser,

   454                                                  RStringPool* aStringPool)

   455     {

   456     CSenLayeredTransportProperties::BaseConstructL(aLocalname, aXml, aParser, aStringPool);

   457     }

   458 

   459 void CSenLayeredHttpTransportProperties::BaseConstructL(const TDesC8& aNamespace, 

   460                                                  const TDesC8& aLocalname, 

   461                                                  const TDesC8& aXml,

   462                                                  CSenXmlReader* aParser,

   463                                                  RStringPool* aStringPool)

   464     {

   465     CSenLayeredTransportProperties::BaseConstructL(aNamespace, aLocalname, aXml, aParser, aStringPool);

   466     }

   467 

   468 void CSenLayeredHttpTransportProperties::BaseConstructL(const TDesC8& aNamespace, 

   469                                                  const TDesC8& aLocalname, 

   470                                                  const TDesC8& aQualifiedName, 

   471                                                  const TDesC8& aXml,

   472                                                  CSenXmlReader* aParser,

   473                                                  RStringPool* aStringPool)

   474     {

   475     CSenLayeredTransportProperties::BaseConstructL(aNamespace, aLocalname, aQualifiedName, 

   476                                                    aXml, aParser, aStringPool);

   477     }

   478 

   479 void CSenLayeredHttpTransportProperties::BaseConstructL(const CSenElement& aElement, RStringPool* aStringPool)

   480     {

   481     CSenLayeredTransportProperties::BaseConstructL(aElement, aStringPool);

   482     }

   483 

   484 CSenLayeredHttpTransportProperties::CSenLayeredHttpTransportProperties()

   485     {

   486     }

   487 

   488 CSenLayeredHttpTransportProperties::~CSenLayeredHttpTransportProperties()

   489     {

   490     }

   491 

   492 TInt CSenLayeredHttpTransportProperties::DeviceIDL(TPtrC8& aDeviceID)

   493     {

   494     return CSenLayeredTransportProperties::DeviceIDL(aDeviceID);

   495     }

   496 

   497 TInt CSenLayeredHttpTransportProperties::SoapActionL(TPtrC8& aAction)

   498     {

   499     return CSenLayeredTransportProperties::SoapActionL(aAction);

   500     }

   501 TInt CSenLayeredHttpTransportProperties::DownloadFolderL(TPtrC8& aDownloadFolder)

   502     {

   503     return CSenLayeredTransportProperties::DownloadFolderL(aDownloadFolder);

   504     }

   505     

   506 TInt CSenLayeredHttpTransportProperties::FileAttachmentL(const TDesC8& aCid, HBufC8*& aFileName)

   507     {

   508     return CSenLayeredTransportProperties::FileAttachmentL(aCid, aFileName);

   509     }

   510 

   511 TInt CSenLayeredHttpTransportProperties::MwsNamespaceL(TPtrC8& aMwsNamespace)

   512     {

   513     return CSenLayeredTransportProperties::MwsNamespaceL(aMwsNamespace);

   514     }

   515 // END OF FILE

   516 

   517