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 <SenXmlUtils.h>

    31 #include <SenTransportProperties.h>

    32 #include "senpropertiesfragment.h"

    33 #include "SenBaseAttribute.h"

    34 #include <xml/attribute.h> // From syslibs, needed for RAttributeArray

    35 

    36 #include "senlogger.h"

    37 //#include "senxmldebug.h"

    38 

    39 namespace

    40     {

    41     _LIT8(KCid,"cid");

    42     }

    43 

    44 EXPORT_C CSenTransportProperties* CSenTransportProperties::NewL()

    45     {

    46     CSenTransportProperties* pNew = NewLC();

    47     CleanupStack::Pop(); // pNew

    48     return pNew;

    49     }

    50 

    51 EXPORT_C CSenTransportProperties* CSenTransportProperties::NewLC()

    52     {

    53     CSenTransportProperties* pNew = new (ELeave) CSenTransportProperties;

    54     CleanupStack::PushL(pNew);

    55 

    56     // omit parsing by passing zero-length descriptor

    57     pNew->BaseConstructL(KSenXmlPropertiesLocalname,

    58                          KNullDesC8,

    59                          NULL);

    60     return pNew;

    61     }

    62 

    63 EXPORT_C CSenTransportProperties* CSenTransportProperties::NewL(const TDesC8& aXmlUtf8,

    64                                                                CSenXmlReader& aParser)

    65     {

    66     CSenTransportProperties* pNew = NewLC(aXmlUtf8, aParser);

    67     CleanupStack::Pop(); // pNew

    68     return pNew;

    69     }

    70 

    71 EXPORT_C CSenTransportProperties* CSenTransportProperties::NewLC(const TDesC8& aXmlUtf8,

    72                                                                 CSenXmlReader& aParser)

    73     {

    74     CSenTransportProperties* pNew = new (ELeave) CSenTransportProperties;

    75     CleanupStack::PushL(pNew);

    76 

    77     // parse the XML document  descriptor into DOM fragment

    78     pNew->BaseConstructL(KSenXmlPropertiesLocalname,

    79                          aXmlUtf8,

    80                          &aParser);

    81     return pNew;

    82     }

    83 

    84 EXPORT_C CSenTransportProperties* CSenTransportProperties::NewL(const CSenElement& aElement)

    85     {

    86     CSenTransportProperties* pNew = NewLC(aElement);

    87     CleanupStack::Pop(); // pNew

    88     return pNew;

    89     }

    90 

    91 EXPORT_C CSenTransportProperties* CSenTransportProperties::NewLC(const CSenElement& aElement)

    92     {

    93     CSenTransportProperties* pNew = new (ELeave) CSenTransportProperties;

    94     CleanupStack::PushL(pNew);

    95 

    96     // parse the XML document  descriptor into DOM fragment

    97     pNew->BaseConstructL(aElement);

    98     return pNew;

    99     }

   100     

   101 EXPORT_C void CSenTransportProperties::SetReader(CSenXmlReader& aReader)

   102     {

   103     CSenXmlProperties::SetReader(aReader);

   104     }      

   105 

   106 EXPORT_C MSenProperties::TSenPropertiesClassType CSenTransportProperties::PropertiesClassType() 

   107     {

   108     return ESenTransportProperties;

   109     }

   110 

   111 EXPORT_C void CSenTransportProperties::WriteToL(RWriteStream& aWriteStream)

   112     {

   113     CSenXmlProperties::WriteToL(aWriteStream);

   114     }

   115     

   116 EXPORT_C void CSenTransportProperties::ReadFromL(const TDesC8& aBuffer)

   117     {

   118     CSenXmlProperties::ReadFromL(aBuffer);

   119     }    

   120 

   121 EXPORT_C HBufC8* CSenTransportProperties::AsUtf8L()

   122     {

   123     return CSenXmlProperties::AsUtf8L();

   124     }

   125 

   126 EXPORT_C HBufC8* CSenTransportProperties::AsUtf8LC()

   127     {

   128     return CSenXmlProperties::AsUtf8LC();

   129     }

   130     

   131 EXPORT_C TBool CSenTransportProperties::IsSafeToCast(TSenPropertiesClassType aClass)

   132     {

   133     if ( aClass == MSenProperties::ESenTransportProperties )

   134         {

   135         return ETrue;

   136         }

   137     else

   138         {

   139         return CSenXmlProperties::IsSafeToCast(aClass);

   140         }

   141     }      

   142     

   143 EXPORT_C TInt CSenTransportProperties::SetPropertyL(const TDesC8& aName,

   144                                                        const TDesC8& aValue)

   145     {

   146     return CSenXmlProperties::SetPropertyL(aName, aValue);

   147     }

   148     

   149 EXPORT_C TInt CSenTransportProperties::PropertyL(const TDesC8& aName,

   150                                                    TPtrC8& aValue)

   151     {

   152     return CSenXmlProperties::PropertyL(aName, aValue);

   153     }

   154     

   155 EXPORT_C TInt CSenTransportProperties::SetIntPropertyL(const TDesC8& aName,

   156                                                        const TInt aValue)

   157     {

   158     return CSenXmlProperties::SetIntPropertyL(aName, aValue);

   159     }

   160 

   161 EXPORT_C TInt CSenTransportProperties::IntPropertyL(const TDesC8& aName,

   162                                                     TInt& aValue)

   163     {

   164     return CSenXmlProperties::IntPropertyL(aName, aValue);

   165     }

   166 

   167 EXPORT_C TInt CSenTransportProperties::SetBoolPropertyL(const TDesC8& aName,

   168                                                         const TBool aValue)

   169     {

   170     return CSenXmlProperties::SetBoolPropertyL(aName, aValue);

   171     }

   172 

   173 EXPORT_C TInt CSenTransportProperties::BoolPropertyL(const TDesC8& aName,

   174                                                      TBool& aValue)

   175     {

   176     return CSenXmlProperties::BoolPropertyL(aName, aValue);

   177     }

   178 EXPORT_C TInt CSenTransportProperties::SetOmittedL(const TDesC8& aName, TBool aValue)

   179     {

   180     return CSenXmlProperties::SetOmittedL(aName, aValue);

   181     }

   182 

   183 EXPORT_C TInt CSenTransportProperties::RemovePropertyL(const TDesC8& aName)

   184     {

   185     return CSenXmlProperties::RemovePropertyL(aName);

   186     }

   187 

   188 

   189 EXPORT_C CSenTransportProperties::~CSenTransportProperties()

   190     {

   191     }

   192 

   193 EXPORT_C void CSenTransportProperties::BaseConstructL(const TDesC8& aLocalname, 

   194                                                  const TDesC8& aXml,

   195                                                  CSenXmlReader* aParser)

   196     {

   197     CSenXmlProperties::BaseConstructL(aLocalname, aXml, aParser);

   198     }

   199 

   200 EXPORT_C void CSenTransportProperties::BaseConstructL(const TDesC8& aNamespace, 

   201                                                  const TDesC8& aLocalname, 

   202                                                  const TDesC8& aXml,

   203                                                  CSenXmlReader* aParser)

   204     {

   205     CSenXmlProperties::BaseConstructL(aNamespace, aLocalname, aXml, aParser);

   206     }

   207 

   208 void CSenTransportProperties::BaseConstructL(const TDesC8& aNamespace, 

   209                                                  const TDesC8& aLocalname, 

   210                                                  const TDesC8& aQualifiedName, 

   211                                                  const TDesC8& aXml,

   212                                                  CSenXmlReader* aParser)

   213     {

   214     CSenXmlProperties::BaseConstructL(aNamespace, aLocalname, aQualifiedName, aXml, aParser);

   215     }

   216 

   217 EXPORT_C void CSenTransportProperties::BaseConstructL(const CSenElement& aElement)

   218     {

   219     CSenXmlProperties::BaseConstructL(aElement);

   220     }

   221 

   222 EXPORT_C CSenTransportProperties::CSenTransportProperties()

   223 : iFileAttachmentNum(0)

   224     {

   225     }

   226     

   227 EXPORT_C TInt CSenTransportProperties::SetPropertyL(const TDesC8& aName,

   228                                                     const TDesC8& aValue,

   229                                                     const TDesC8& aType)

   230     {

   231     return CSenXmlProperties::SetPropertyL(aName, aValue, aType);

   232     }

   233 

   234 EXPORT_C TInt CSenTransportProperties::PropertyL(const TDesC8& aName,

   235                                                     TPtrC8& aValue,

   236                                                     TPtrC8& aType)

   237     {

   238     return CSenXmlProperties::PropertyL(aName, aValue, aType);

   239     }

   240 //common properties

   241 EXPORT_C TInt CSenTransportProperties::IapIdL(TUint32& aCurrentIapId)

   242     {

   243     TPtrC8 value;

   244     TInt retVal = PropertyL(KIapIdLocalName, value);

   245     

   246     if ( retVal == KErrNone )

   247         {

   248         TLex8 lex(value);

   249         retVal = lex.Val(aCurrentIapId, EDecimal);

   250         }

   251         

   252     if(aCurrentIapId > 0) return retVal;

   253     else return KErrNotFound;

   254     }

   255 

   256 EXPORT_C void CSenTransportProperties::SetIapIdL(TUint32 aIapId)

   257     {

   258     TBuf8<128> buf;

   259     buf.AppendFormat(_L8("%u"), aIapId);

   260     SetPropertyL(KIapIdLocalName, buf);

   261     }

   262 

   263 // Setter for Service Network Access Point (SNAP) ID

   264 EXPORT_C void CSenTransportProperties::SetSnapIdL(TUint32 aSnapId)

   265     {

   266 	TBuf8<128> buf;

   267     buf.AppendFormat(_L8("%u"), aSnapId);

   268     SetPropertyL(KSnapIdLocalName, buf);

   269     }

   270 

   271 // Getter for SNAP ID

   272 EXPORT_C TInt CSenTransportProperties::SnapIdL(TUint32& aCurrentSnapId)

   273     {

   274     TPtrC8 value;

   275     TInt retVal = PropertyL(KSnapIdLocalName, value);

   276     

   277     if ( retVal == KErrNone )

   278         {

   279         TLex8 lex(value);

   280         retVal = lex.Val(aCurrentSnapId, EDecimal);

   281         }

   282         

   283     if(aCurrentSnapId > 0) return retVal;

   284     else return KErrNotFound;

   285     }

   286 EXPORT_C TInt CSenTransportProperties::ProxyPortL(TInt& aProxyPort)

   287     {

   288     TPtrC8 value;

   289     TInt retVal = PropertyL(KProxyPortLocalName, value);

   290     if ( retVal == KErrNone )

   291         {

   292         TLex8 lex(value);

   293         TUint proxyPort;

   294         retVal = lex.Val(proxyPort, EDecimal);

   295         if ( retVal == KErrNone )

   296             {

   297             aProxyPort = proxyPort;

   298             }

   299         }

   300 

   301     return retVal;

   302     }

   303 

   304 EXPORT_C void CSenTransportProperties::SetProxyPortL(TInt aProxyPort)

   305     {

   306     SetIntPropertyL(KProxyPortLocalName, aProxyPort);

   307     }

   308 

   309 EXPORT_C TInt CSenTransportProperties::ProxyHostL(TPtrC8& aProxyHost)

   310     {

   311     return PropertyL(KProxyHostLocalName, aProxyHost);

   312     }

   313 

   314 EXPORT_C void CSenTransportProperties::SetProxyHostL(const TDesC8& aProxyHost)

   315     {

   316     SetPropertyL(KProxyHostLocalName, aProxyHost);

   317     }

   318 

   319 EXPORT_C TInt CSenTransportProperties::ProxyUsageL(TBool& aValue)

   320     {

   321     return BoolPropertyL(KProxyUsageLocalName, aValue);

   322     }

   323 

   324 EXPORT_C void CSenTransportProperties::SetProxyUsageL(TBool aProxyUsage)

   325     {

   326     SetBoolPropertyL(KProxyUsageLocalName, aProxyUsage);

   327     }

   328     

   329 EXPORT_C TInt CSenTransportProperties::SecureDialogL(TBool& aValue)

   330     {

   331     return BoolPropertyL(KSecureDialogLocalName, aValue);

   332     }

   333 

   334 EXPORT_C void CSenTransportProperties::SetSecureDialogL(TBool aSecureDialog)

   335     {

   336     SetBoolPropertyL(KSecureDialogLocalName, aSecureDialog);

   337     }

   338 /*

   339 EXPORT_C TInt CSenTransportProperties::IAPDialogL(TBool& aValue)

   340     {

   341     return BoolPropertyL(KSenIAPDoNotPrompt, aValue);

   342     }

   343 

   344 EXPORT_C void CSenTransportProperties::SetIapDialogL(TBool aIapDialog)

   345     {

   346     SetBoolPropertyL(KSenIAPDoNotPrompt, aIapDialog);

   347     }

   348 */

   349 EXPORT_C TInt CSenTransportProperties::UserAgentL(TPtrC8& aUserAgent)

   350     {

   351     return PropertyL(KUserAgentLocalName, aUserAgent);

   352     }

   353 

   354 EXPORT_C void CSenTransportProperties::SetUserAgentL(const TDesC8& aUserAgent)

   355     {

   356     SetPropertyL(KUserAgentLocalName, aUserAgent);

   357     }

   358 

   359 EXPORT_C TInt CSenTransportProperties::DeviceIDL(TPtrC8& aDeviceID)

   360     {

   361     return PropertyL(KDeviceIDLocalName, aDeviceID);

   362     }

   363 

   364 EXPORT_C void CSenTransportProperties::SetDeviceIDL(const TDesC8& aDeviceID)

   365     {

   366     SetPropertyL(KDeviceIDLocalName, aDeviceID);

   367     }    

   368 

   369 EXPORT_C TInt CSenTransportProperties::SoapActionL(TPtrC8& aAction)

   370     {

   371     return PropertyL(KSoapActionLocalName, aAction);

   372     }

   373 

   374 EXPORT_C void CSenTransportProperties::SetSoapActionL(const TDesC8& aAction)

   375     {

   376     SetPropertyL(KSoapActionLocalName, aAction);

   377     }    

   378 

   379 EXPORT_C void CSenTransportProperties::ApplyBindingL(TSOAPVersion /*aSoapVersion*/)

   380     {

   381     }

   382 

   383 EXPORT_C TInt CSenTransportProperties::DownloadFolderL(TPtrC8& aDownloadFolder)

   384     {

   385     return PropertyL(KDownloadFolderLocalName, aDownloadFolder);

   386     }

   387 EXPORT_C void CSenTransportProperties::SetDownloadFolderL(const TDesC8& aDownloadFolder)

   388     {

   389     SetPropertyL(KDownloadFolderLocalName, aDownloadFolder);

   390     }

   391 

   392 EXPORT_C TInt CSenTransportProperties::FileAttachmentL(const TDesC8& aCid, HBufC8*& aFileName)

   393     {

   394     TLSLOG_L(KSenUtilsLogChannel, KMinLogLevel, "CSenTransportProperties::FileAttachmentL:");

   395     TLSLOG_FORMAT((KSenUtilsLogChannel, KMinLogLevel, _L8("- CID: '%S'"), &aCid));        

   396     

   397 //    _LIT8(KAttachment, "Attachment");

   398     TPtrC8 pFileAttachments;

   399     TInt retVal( KErrNotFound );

   400     retVal = PropertyL( KFileAttachmentsLocalName, pFileAttachments );    

   401     if ( retVal == KErrNone )

   402         {

   403         CSenXmlReader* reader = CSenXmlReader::NewL(KXmlParserMimeType); // use libxml2 sax parser

   404         CleanupStack::PushL( reader );

   405         CSenDomFragment* pFragment = CSenDomFragment::NewL();

   406         CleanupStack::PushL( pFragment );

   407         pFragment->SetReader( *reader );    

   408         pFragment->BuildFrom( pFileAttachments );  

   409         

   410         if (aFileName)

   411             {

   412             delete aFileName;

   413             aFileName = NULL;

   414             }

   415         

   416         RPointerArray<CSenElement>& elements = pFragment->AsElement().ElementsL();

   417         TInt count(elements.Count());

   418         for ( TInt i=0; i<count && !aFileName; i++ )

   419             {

   420             CSenElement* pElement = elements[i];

   421             TLSLOG_FORMAT((KSenUtilsLogChannel, KNormalLogLevel, _L8("- Processing file attachment element: '%S'"), &pElement->LocalName()));        

   422 

   423             RPointerArray<CSenBaseAttribute>& attributes = pElement->AttributesL();

   424             TInt attrCount(attributes.Count());

   425             for ( TInt j=0; j<attrCount; j++ )            

   426                 {

   427                 TPtrC8 name = attributes[j]->Name();

   428                 TPtrC8 value = attributes[j]->Value();

   429 

   430                 TLSLOG_FORMAT((KSenUtilsLogChannel, KNormalLogLevel, _L8("- Processing file attachment attribute, name: '%S', value: '%S'"), &name, &value));        

   431                 if ( name == KCid && value == aCid )

   432                     {

   433                     TLSLOG_L(KSenUtilsLogChannel, KNormalLogLevel, "- Filename for CID found.");

   434                     aFileName = HBufC8::NewL( pElement->Content().Length() );

   435                     TPtr8 aFileNameDes = aFileName->Des();                

   436                     aFileNameDes.Append( pElement->Content() );

   437                     retVal = KErrNone;

   438                     break; // no need to check rest of the attributes

   439                     }

   440                 }

   441                 // if ( aFileName ) break; // no need to check rest of the child elements

   442             }

   443             

   444         CleanupStack::PopAndDestroy(pFragment);

   445         CleanupStack::PopAndDestroy(reader);

   446         }

   447     return retVal;

   448         /*

   449         HBufC8* pLocalName = HBufC8::NewLC(KAttachment().Length()+aCid.Length());

   450         TPtr8 localNameDes = pLocalName->Des();

   451         localNameDes.Append(KAttachment);

   452         localNameDes.Append(aCid);

   453         CSenElement* pElement = pFragment->AsElement().Element(*pLocalName);

   454         if(pElement)

   455             {

   456             if (aFileName)

   457                 {

   458                 delete aFileName;

   459                 aFileName = NULL;

   460                 }

   461             aFileName = HBufC8::NewL(pElement->Content().Length());

   462             TPtr8 aFileNameDes = aFileName->Des();                

   463             aFileNameDes.Append(pElement->Content());

   464             CleanupStack::PopAndDestroy(pLocalName);

   465             CleanupStack::PopAndDestroy(pFragment);

   466             CleanupStack::PopAndDestroy(reader);

   467             return KErrNone;

   468             }

   469         else

   470             {

   471             CleanupStack::PopAndDestroy(pLocalName);

   472             CleanupStack::PopAndDestroy(pFragment);

   473             CleanupStack::PopAndDestroy(reader);

   474             return KErrNotFound;

   475             }

   476         }

   477             

   478         */            

   479     }

   480 

   481 EXPORT_C TInt CSenTransportProperties::SetFileAttachmentL(const TDesC8& aCid, const TDesC8& aFileName)

   482     {

   483     TLSLOG_L(KSenUtilsLogChannel, KMinLogLevel, "CSenTransportProperties::SetFileAttachmentL:");

   484     TLSLOG_FORMAT((KSenUtilsLogChannel, KMinLogLevel, _L8("- CID: '%S'"), &aCid));        

   485     

   486     TBuf<32> num;

   487     num.AppendNum( iFileAttachmentNum );

   488 

   489     _LIT8(KAttachments,"Attachments");

   490     _LIT8(KAttachment,"Attachment");

   491     TPtrC8 pFileAttachments;

   492     TInt err(KErrNone);

   493     err = PropertyL(KFileAttachmentsLocalName, pFileAttachments);

   494     if (err != KErrNotFound)

   495         {

   496         // Add to existing <Attachements/> fragment:

   497         CSenXmlReader* reader = CSenXmlReader::NewL(KXmlParserMimeType); // use libxml2 sax parser

   498         CleanupStack::PushL(reader);

   499         CSenDomFragment* pFragment = CSenDomFragment::NewL();

   500         CleanupStack::PushL(pFragment);

   501         pFragment->SetReader(*reader);    

   502         pFragment->BuildFrom(pFileAttachments);  

   503         

   504         // --- //

   505         HBufC8* pLocalName = HBufC8::NewLC( KAttachment().Length() + num.Length() );

   506         TPtr8 localNameDes = pLocalName->Des();

   507         localNameDes.Append( KAttachment );

   508         localNameDes.Append( num );

   509         CSenElement* pElement = pFragment->AsElement().Element(*pLocalName);

   510         if (pElement)  

   511             {

   512             CleanupStack::PopAndDestroy(pLocalName);

   513             CleanupStack::PopAndDestroy(pFragment);

   514             CleanupStack::PopAndDestroy(reader);

   515             return KErrAlreadyExists; 

   516             }

   517         else

   518             {

   519             CSenElement& pElement = pFragment->AsElement().AddElementL(*pLocalName);

   520             pElement.SetContentL(aFileName);

   521             SenXmlUtils::AddAttributeL(pElement, KCid, aCid );	//CodeScannerWarnings

   522             HBufC8* pFragmentAsXml = pFragment->AsXmlL();

   523             CleanupStack::PushL(pFragmentAsXml);

   524             SetPropertyL( KFileAttachmentsLocalName, *pFragmentAsXml );

   525             CleanupStack::PopAndDestroy( pFragmentAsXml );

   526             }

   527         CleanupStack::PopAndDestroy(pLocalName);

   528         CleanupStack::PopAndDestroy(pFragment);

   529         CleanupStack::PopAndDestroy(reader);

   530         }

   531     else

   532         {

   533         

   534         // Create new <Attachements/> -fragment (container) for fileattachent properties

   535         

   536         CSenDomFragment* pFragment = CSenDomFragment::NewL( KAttachments );

   537         CleanupStack::PushL(pFragment);

   538         

   539         // --- //        

   540         //HBufC8* pLocalName = HBufC8::NewLC(KAttachment().Length()+aCid.Length());

   541         HBufC8* pLocalName = HBufC8::NewLC( KAttachment().Length() + num.Length() );

   542         TPtr8 localNameDes = pLocalName->Des();

   543         localNameDes.Append(KAttachment);

   544         localNameDes.Append( num );

   545         CSenElement& pElement = pFragment->AsElement().AddElementL(*pLocalName);

   546         pElement.SetContentL( aFileName );

   547         SenXmlUtils::AddAttributeL(pElement, KCid, aCid );

   548         HBufC8* pFragmentAsXml = pFragment->AsXmlL();

   549         CleanupStack::PushL(pFragmentAsXml);

   550         SetPropertyL( KFileAttachmentsLocalName, *pFragmentAsXml );

   551         CleanupStack::PopAndDestroy(pFragmentAsXml);

   552         

   553         CleanupStack::PopAndDestroy(pLocalName);

   554         CleanupStack::PopAndDestroy(pFragment);

   555         }  

   556         

   557     // Increase internal count of file attachements ONLY if method is successful:         

   558     iFileAttachmentNum++; 

   559     return KErrNone;    

   560     }

   561     

   562    

   563 EXPORT_C MSenProperties* CSenTransportProperties::CloneL() const

   564     {

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

   566     

   567     CSenTransportProperties* pProperties = NewLC(element);

   568     CleanupStack::Pop(pProperties);

   569     return pProperties;

   570     }

   571 

   572 EXPORT_C MSenProperties* CSenTransportProperties::Clone(TInt& aOkOrError) const

   573     {

   574     MSenProperties* pClone = NULL;

   575     TRAP( aOkOrError, pClone = CloneL(); )

   576     return pClone;

   577     }

   578         

   579 EXPORT_C TInt CSenTransportProperties::MwsNamespaceL( TPtrC8& aMwsNamespace )

   580     {

   581     return PropertyL( KMwsNamespaceLocalName, aMwsNamespace );

   582     }

   583     

   584 EXPORT_C void CSenTransportProperties::SetMwsNamespaceL( const TDesC8& aMwsNamespace )

   585     {

   586     SetPropertyL( KMwsNamespaceLocalName, aMwsNamespace );

   587     }

   588 

   589 EXPORT_C TInt CSenTransportProperties::MessageIdL( TPtrC8& aMessageId )

   590     {

   591     return PropertyL( KSenClientGeneratedMessageId, aMessageId );

   592     }      

   593 

   594 EXPORT_C void CSenTransportProperties::SetMessageIdL( const TDesC8& aMessageId )

   595     {

   596     SetPropertyL( KSenClientGeneratedMessageId, aMessageId );

   597     }      

   598 

   599 EXPORT_C TInt CSenTransportProperties::OnewayMessageOnOffL( TBool& aOnewayMessageOnOff )

   600     {

   601     return BoolPropertyL( KSenOnewayMessageOnOff, aOnewayMessageOnOff );

   602     }

   603 

   604 EXPORT_C void CSenTransportProperties::SetOnewayMessageOnOffL( TBool aOnewayMessageOnOff )

   605     {

   606     SetBoolPropertyL( KSenOnewayMessageOnOff, aOnewayMessageOnOff );

   607     }

   608     

   609 EXPORT_C TInt CSenTransportProperties::HeartbeatL(TInt& aHeartbeat) 

   610     { 

   611     return IntPropertyL( KSenConnectionHeartbeat, aHeartbeat ); 

   612     }

   613     

   614 EXPORT_C TInt CSenTransportProperties::SetHeartbeatL(TInt aHeartbeat) 

   615     { 

   616     return SetIntPropertyL( KSenConnectionHeartbeat, aHeartbeat ); 

   617     }

   618     

   619 

   620 EXPORT_C TInt CSenTransportProperties::SetMaxTimeToLiveL(TInt aMaxTTL) 

   621     { 

   622     return SetIntPropertyL( KSenConnectionHeartbeatMaxTTL, aMaxTTL ); 

   623     }

   624 

   625 EXPORT_C TInt CSenTransportProperties::MaxTimeToLiveL(TInt& aMaxTTL) 

   626     { 

   627     return IntPropertyL( KSenConnectionHeartbeatMaxTTL, aMaxTTL ); 

   628     }

   629 

   630 EXPORT_C TInt CSenTransportProperties::SetMinTimeToLiveL(TInt aMinTTL) 

   631     { 

   632     return SetIntPropertyL( KSenConnectionHeartbeatMinTTL, aMinTTL ); 

   633     }

   634 

   635 EXPORT_C TInt CSenTransportProperties::MinTimeToLiveL(TInt& aMinTTL) 

   636     { 

   637     return IntPropertyL( KSenConnectionHeartbeatMinTTL, aMinTTL ); 

   638     }

   639 

   640 EXPORT_C TInt CSenTransportProperties::SetEndpointResourceL(const TDesC8& aEndpointResource)

   641     {

   642     return SetPropertyL(KSenEndpointResource, aEndpointResource);

   643     }

   644 

   645 EXPORT_C TInt CSenTransportProperties::EndpointResourceL(TPtrC8& aEndpointResource)

   646     {

   647     return PropertyL(KSenEndpointResource, aEndpointResource);

   648     }

   649 

   650 

   651 // END OF FILE

   652 

   653