--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerprotocols/httpservice/test/httpservicetest/chttpclienttestparams.cpp Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,704 @@
+// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include "chttpclienttestparams.h"
+#include <testexecuteserverbase.h>
+#include "thttpheadervaluevariant.h"
+#include <escapeutils.h>
+#include <tinternetdate.h>
+
+_LIT(KMethod, "Method");
+_LIT(KUri, "Uri");
+_LIT(KRawRequest, "RawRequest");
+_LIT(KRawResponse, "RawResponse");
+_LIT(KResponseBody, "ResponseBody");
+_LIT(KStatusCode, "StatusCode");
+_LIT(KResponseFieldCount, "ResponseFieldCount");
+_LIT(KHeader, "ResponseHeader%d");
+_LIT(KHeaderValue, "ResponseHeader%d.Value%d");
+_LIT(KHeaderValueCount, "ResponseHeader%dValueCount");
+_LIT(KFieldParamCount, "ResponseHeader%d.Field%dParamCount");
+_LIT(KFieldParamName, "ResponseHeader%d.Field%d.ParamName%d");
+_LIT(KFieldParamValue, "ResponseHeader%d.Field%d.ParamValue%d");
+_LIT(KHeaderParamCount, "ResponseHeader%dParamCount");
+_LIT(KHeaderParamName, "ResponseHeader%d.ParamName%d");
+_LIT(KHeaderParamValue, "ResponseHeader%d.ParamValue%d");
+_LIT(KResponseFileName, "ResponseFileName");
+_LIT(KResponseFileNameStore, "ResponseFileNameStore");
+_LIT(KRequestFileName, "RequestFileName");
+_LIT(KRequestFileNameStore, "RequestFileNameStore");
+
+
+_LIT(KRequestFieldCount, "RequestFieldCount");
+_LIT(KRequestHeader, "RequestHeader%d");
+_LIT(KRequestHeaderValueCount, "RequestHeader%dValueCount");
+_LIT(KRequestHeaderValue, "RequestHeader%d.Value%d");
+_LIT(KRequestHeaderValueParamCount, "RequestHeader%d.Value%dParamCount");
+_LIT(KRequestHeaderValueParamName, "RequestHeader%d.Value%d.ParamName%d");
+_LIT(KRequestHeaderValueParamValue, "RequestHeader%d.Value%d.ParamValue%d");
+
+_LIT(KRequestBody, "RequestBody");
+_LIT(KConnDisconnect, "ConnDisconnect");
+_LIT(KExpectedError, "ExpectedError");
+_LIT(KNoRetryOnDisconnect, "NoRetryOnDisconnect");
+_LIT(KResponseDynamicAndStatic, "ResponseDynamicAndStatic");
+_LIT(KOnlineTest, "OnlineTest");
+_LIT(KProxyAddress, "ProxyAddress");
+_LIT(KResponseTimeout, "ResponseTimeout");
+_LIT(KRedirection, "Redirection");
+_LIT(KNotifyTransferProgress, "NotifyTransferProgress");
+
+_LIT8(KScriptLF8, "\\n");
+_LIT8(KReplaceLF8, "\n");
+_LIT8(KScriptCR8, "\\r");
+_LIT8(KReplaceCR8, "\r");
+
+
+void ParseAndReplaceCRLF(HBufC8* aHBufPtr)
+ {
+ TInt crPos = 0;
+ TInt lfPos = 0;
+ do
+ {
+ crPos = ((aHBufPtr->Des()).Find(KScriptCR8()));
+ if (crPos != KErrNotFound)
+ {
+ (aHBufPtr->Des()).Replace(crPos,2, KReplaceCR8());
+ }
+ }while (crPos != KErrNotFound );
+
+
+ do
+ {
+ lfPos = ((aHBufPtr->Des()).Find(KScriptLF8()));
+ if (lfPos != KErrNotFound)
+ {
+ (aHBufPtr->Des()).Replace(lfPos,2, KReplaceLF8());
+ }
+ }while (lfPos != KErrNotFound );
+ }
+
+CHttpClientTestParams* CHttpClientTestParams::NewL(CTestStep& aTestCase)
+ {
+ CHttpClientTestParams* self = new(ELeave) CHttpClientTestParams;
+ CleanupStack::PushL(self);
+ self->ConstructL(aTestCase);
+ CleanupStack::Pop();
+ return self;
+ }
+
+
+
+void CHttpClientTestParams::ConstructL(CTestStep& aTestCase)
+ {
+ TPtrC method;
+ TPtrC uri;
+ TPtrC rawRequest;
+ TPtrC rawResponse;
+ if(!aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), KMethod(), method) ||
+ !aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), KUri(), uri) ||
+ !aTestCase.GetIntFromConfig(aTestCase.ConfigSection(), KStatusCode(), iStatusCode))
+ {
+ User::Leave(KErrCorrupt);
+ }
+ aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), KRawRequest(), rawRequest);
+ aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), KRawResponse(), rawResponse);
+
+ iMethod = EscapeUtils::ConvertFromUnicodeToUtf8L(method);
+ iUri = EscapeUtils::ConvertFromUnicodeToUtf8L(uri);
+ iRawRequest = EscapeUtils::ConvertFromUnicodeToUtf8L(rawRequest);
+ iRawResponse = EscapeUtils::ConvertFromUnicodeToUtf8L(rawResponse);
+ ParseAndReplaceCRLF(iRawRequest);
+ ParseAndReplaceCRLF(iRawResponse);
+
+
+ TPtrC responseBody;
+ if(aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), KResponseBody(), responseBody))
+ {
+ iResponseBody = EscapeUtils::ConvertFromUnicodeToUtf8L(responseBody);
+ }
+
+ TPtrC requestBody;
+ if(aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), KRequestBody(), requestBody))
+ {
+ iRequestBody = EscapeUtils::ConvertFromUnicodeToUtf8L(requestBody);
+ }
+
+
+ // Now read the headers
+ // Read the number of headers
+ TInt responseHeaderCount = 0;
+ aTestCase.GetIntFromConfig(aTestCase.ConfigSection(), KResponseFieldCount(), responseHeaderCount);
+ for(TInt i = 0; i < responseHeaderCount; ++i)
+ {
+ CHeaderInfo* headerInfo = new(ELeave) CHeaderInfo;
+ CleanupStack::PushL(headerInfo);
+ TBuf<32> headerFormat;
+ headerFormat.Format(KHeader(), i + 1);
+ TPtrC headerName;
+ aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), headerFormat, headerName);
+ headerInfo->iFieldName = EscapeUtils::ConvertFromUnicodeToUtf8L(headerName);
+ TInt headerValueCount = 0;
+ TBuf<32> headerValueCountStr;
+ headerValueCountStr.Format(KHeaderValueCount(), i + 1);
+ aTestCase.GetIntFromConfig(aTestCase.ConfigSection(), headerValueCountStr, headerValueCount);
+ for(TInt j = 0; j < headerValueCount; ++j)
+ {
+ TBuf<32> headerValueFormat;
+ headerValueFormat.Format(KHeaderValue(), i + 1, j+ 1);
+ TPtrC headerValue;
+ aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), headerValueFormat, headerValue);
+ CHeaderFieldInfo* fieldInfo = new(ELeave) CHeaderFieldInfo;
+ CleanupStack::PushL(fieldInfo);
+ fieldInfo->iFieldValue = EscapeUtils::ConvertFromUnicodeToUtf8L(headerValue);
+
+ // Check this field has params.
+ TBuf<32> headerFieldParamCount;
+ headerFieldParamCount.Format(KFieldParamCount(), i + 1, j + 1);
+ TInt paramCount = 0;
+ aTestCase.GetIntFromConfig(aTestCase.ConfigSection(), headerFieldParamCount, paramCount);
+ for(TInt k = 0; k < paramCount; ++k)
+ {
+ TBuf<48> fieldParamName;
+ TBuf<48> fieldParamValue;
+ fieldParamName.Format(KFieldParamName, i + 1, j + 1, k + 1);
+ fieldParamValue.Format(KFieldParamValue, i + 1, j + 1, k + 1);
+ TPtrC paramName;
+ TPtrC paramValue;
+ aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), fieldParamName, paramName);
+ aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), fieldParamValue, paramValue);
+ CHeaderFieldParamInfo* paramInfo = new(ELeave) CHeaderFieldParamInfo;
+ CleanupStack::PushL(paramInfo);
+ paramInfo->iParamName = EscapeUtils::ConvertFromUnicodeToUtf8L(paramName);
+ paramInfo->iParamValue = EscapeUtils::ConvertFromUnicodeToUtf8L(paramValue);
+ fieldInfo->iFieldParamInfos.AppendL(paramInfo);
+ CleanupStack::Pop(); // paramInfo
+ }
+
+ headerInfo->iFieldInfos.AppendL(fieldInfo);
+ CleanupStack::Pop(); // fieldInfo
+ }
+ // Check if the header has some params
+ TBuf<48> headerParamCount;
+ headerParamCount.Format(KHeaderParamCount(), i + 1);
+ TInt hdrParamCount = 0;
+ aTestCase.GetIntFromConfig(aTestCase.ConfigSection(), headerParamCount, hdrParamCount);
+ for(TInt x = 0; x < hdrParamCount; ++x)
+ {
+ TBuf<48> headerParamName;
+ TBuf<48> headerParamValue;
+ headerParamName.Format(KHeaderParamName(), i + 1, x + 1);
+ headerParamValue.Format(KHeaderParamValue(), i + 1, x + 1);
+ TPtrC paramName;
+ TPtrC paramValue;
+ aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), headerParamName, paramName);
+ aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), headerParamValue, paramValue);
+ CHeaderFieldParamInfo* paramInfo = new (ELeave) CHeaderFieldParamInfo;
+ CleanupStack::PushL(paramInfo);
+ paramInfo->iParamName = EscapeUtils::ConvertFromUnicodeToUtf8L(paramName);
+ paramInfo->iParamValue = EscapeUtils::ConvertFromUnicodeToUtf8L(paramValue);
+ headerInfo->iParamInfos.AppendL(paramInfo);
+ CleanupStack::Pop(); // paramInfo
+ }
+ iResponseHeaderInfos.AppendL(headerInfo);
+ CleanupStack::Pop(); // headerInfo
+ }
+
+ TPtrC fileName;
+ aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), KResponseFileName(), fileName);
+ if(fileName.Length() > 0)
+ {
+ iFileSender = CFileSender::NewL(fileName);
+ aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), KResponseFileNameStore(), fileName);
+ if(fileName.Length() == 0)
+ {
+ User::Leave(KErrCorrupt);
+ }
+ iFileReceiver = CFileReceiver::NewL(fileName);
+ }
+
+
+ TPtrC ulFileName;
+ aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), KRequestFileName(), ulFileName);
+ if(ulFileName.Length() > 0)
+ {
+ iFileSender = CFileSender::NewL(ulFileName);
+ aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), KRequestFileNameStore(), ulFileName);
+ if(ulFileName.Length() == 0)
+ {
+ User::Leave(KErrCorrupt);
+ }
+ iFileReceiver = CFileReceiver::NewL(ulFileName);
+ }
+
+ // Read request headers
+ TInt reqFieldCount = 0;
+ aTestCase.GetIntFromConfig(aTestCase.ConfigSection(), KRequestFieldCount(), reqFieldCount);
+
+ for(TInt ii = 0; ii < reqFieldCount; ++ii)
+ {
+ // Read the request header
+ TBuf<64> reqHeaderStr;
+ reqHeaderStr.Format(KRequestHeader(), ii + 1);
+ TPtrC reqHeaderName;
+ aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), reqHeaderStr, reqHeaderName);
+ CHeaderInfo* headerInfo = new(ELeave) CHeaderInfo;
+ CleanupStack::PushL(headerInfo);
+ headerInfo->iFieldName = EscapeUtils::ConvertFromUnicodeToUtf8L(reqHeaderName);
+
+ // Now read how many fields are present
+ reqHeaderStr.Format(KRequestHeaderValueCount(), ii + 1);
+ TInt reqHdrValueCount = 0;
+ aTestCase.GetIntFromConfig(aTestCase.ConfigSection(), reqHeaderStr, reqHdrValueCount);
+ for(TInt jj = 0; jj < reqHdrValueCount; ++jj)
+ {
+ TPtrC reqHeaderVal;
+ reqHeaderStr.Format(KRequestHeaderValue(), ii + 1, jj + 1);
+ aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), reqHeaderStr, reqHeaderVal);
+ CHeaderFieldInfo* info = new (ELeave) CHeaderFieldInfo;
+ CleanupStack::PushL(info);
+ info->iFieldValue = EscapeUtils::ConvertFromUnicodeToUtf8L(reqHeaderVal);
+ reqHeaderStr.Format(KRequestHeaderValueParamCount, ii + 1, jj + 1);
+ TInt paramCount = 0;
+ aTestCase.GetIntFromConfig(aTestCase.ConfigSection(), reqHeaderStr, paramCount);
+ for(TInt kk = 0; kk < paramCount; ++kk)
+ {
+ reqHeaderStr.Format(KRequestHeaderValueParamName(), ii + 1, jj + 1, kk + 1);
+ TPtrC name;
+ TPtrC value;
+ aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), reqHeaderStr, name);
+ reqHeaderStr.Format(KRequestHeaderValueParamValue(), ii + 1, jj + 1, kk + 1);
+ aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), reqHeaderStr, value);
+
+ CHeaderFieldParamInfo* paramInfo = new (ELeave) CHeaderFieldParamInfo;
+ CleanupStack::PushL(paramInfo);
+ paramInfo->iParamName = EscapeUtils::ConvertFromUnicodeToUtf8L(name);
+ paramInfo->iParamValue = EscapeUtils::ConvertFromUnicodeToUtf8L(value);
+ info->iFieldParamInfos.AppendL(paramInfo);
+ CleanupStack::Pop(); // CHeaderFieldParamInfo
+ }
+ headerInfo->iFieldInfos.AppendL(info);
+ CleanupStack::Pop(); // info
+ }
+
+ iRequestHeaderInfos.AppendL(headerInfo);
+ CleanupStack::Pop();
+ }
+
+ iConnDisconnect = EFalse;
+ aTestCase.GetBoolFromConfig(aTestCase.ConfigSection(), KConnDisconnect(), iConnDisconnect);
+
+ iExpectedError = KErrNone;
+ aTestCase.GetIntFromConfig(aTestCase.ConfigSection(), KExpectedError(), iExpectedError);
+
+ iNoRetryOnDisconnect = EFalse;
+ aTestCase.GetBoolFromConfig(aTestCase.ConfigSection(), KNoRetryOnDisconnect(), iNoRetryOnDisconnect);
+
+ iResponseDynamicAndStatic = EFalse;
+ aTestCase.GetBoolFromConfig(aTestCase.ConfigSection(), KResponseDynamicAndStatic(), iResponseDynamicAndStatic);
+
+ iOnlineTest = EFalse;
+ aTestCase.GetBoolFromConfig(aTestCase.ConfigSection(), KOnlineTest(), iOnlineTest);
+
+ iRedirection = EFalse;
+ aTestCase.GetBoolFromConfig(aTestCase.ConfigSection(), KRedirection(), iRedirection);
+
+ iResponseTimeout = EFalse;
+ aTestCase.GetBoolFromConfig(aTestCase.ConfigSection(), KResponseTimeout(), iResponseTimeout);
+
+ iNotifyTransferProgress = EFalse;
+ aTestCase.GetBoolFromConfig(aTestCase.ConfigSection(), KNotifyTransferProgress(), iNotifyTransferProgress);
+
+ TPtrC proxyAddress;
+ if(aTestCase.GetStringFromConfig(aTestCase.ConfigSection(), KProxyAddress, proxyAddress))
+ {
+ iProxyAddress = EscapeUtils::ConvertFromUnicodeToUtf8L(proxyAddress);
+ }
+ }
+
+
+CHttpClientTestParams::~CHttpClientTestParams()
+ {
+ delete iFileSender;
+ delete iMethod;
+ delete iUri;
+ delete iRawRequest;
+ delete iRawResponse;
+ delete iResponseBody;
+ iResponseHeaderInfos.ResetAndDestroy();
+ }
+
+TInt CHttpClientTestParams::StatusCode() const
+ {
+ return iStatusCode;
+ }
+
+const TDesC8& CHttpClientTestParams::Method() const
+ {
+ return *iMethod;
+ }
+
+const TDesC8& CHttpClientTestParams::Uri() const
+ {
+ return *iUri;
+ }
+
+const TDesC8& CHttpClientTestParams::RawRequest() const
+ {
+ return *iRawRequest;
+ }
+
+const TDesC8& CHttpClientTestParams::RawResponse() const
+ {
+ return *iRawResponse;
+ }
+
+const TDesC8& CHttpClientTestParams::ResponseBody() const
+ {
+ if(iResponseBody)
+ return *iResponseBody;
+ return KNullDesC8();
+ }
+
+TBool CHttpClientTestParams::IsFileSending() const
+ {
+ return (iFileSender != NULL);
+ }
+
+const TDesC8& CHttpClientTestParams::ReadFromFile()
+ {
+ return iFileSender->Read();
+ }
+
+TBool CHttpClientTestParams::IsPendingRead() const
+ {
+ return iFileSender->MoreToRead();
+ }
+
+TInt CHttpClientTestParams::WriteToFile(const TDesC8& aData)
+ {
+ return iFileReceiver->Write(aData);
+ }
+
+RFile& CHttpClientTestParams::SourceFile()
+ {
+ return iFileSender->iFile;
+ }
+
+RFile& CHttpClientTestParams::SinkFile()
+ {
+ return iFileReceiver->iFile;
+ }
+
+TBool CHttpClientTestParams::NeedDisconnection() const
+ {
+ return iConnDisconnect;
+ }
+
+TInt CHttpClientTestParams::ExpectedError() const
+ {
+ return iExpectedError;
+ }
+
+TBool CHttpClientTestParams::NoRetryOnDisconnect() const
+ {
+ return iNoRetryOnDisconnect;
+ }
+
+TBool CHttpClientTestParams::ResponseTimeoutEnable() const
+ {
+ return iResponseTimeout;
+ }
+
+TBool CHttpClientTestParams::IsRedirecting() const
+ {
+ return iRedirection;
+ }
+
+TBool CHttpClientTestParams::TransferProgress() const
+ {
+ return iNotifyTransferProgress;
+ }
+
+TBool CHttpClientTestParams::CheckVariantValue(const THttpHeaderValueVariant& aVariant, const TDesC8& aValueToMatch)
+ {
+ TBool ret = EFalse;
+ switch(aVariant.Type())
+ {
+ case THttpHeaderValueVariant::EIntType:
+ {
+ _LIT8(KIntType, "%d");
+ TBuf8<16> buf;
+ buf.Format(KIntType(), aVariant.Int());
+ ret = (buf.CompareF(aValueToMatch) == 0);
+ }
+ break;
+
+ case THttpHeaderValueVariant::EStrType:
+ {
+ ret = (aVariant.Str().CompareF(aValueToMatch) == 0);
+ }
+ break;
+
+ case THttpHeaderValueVariant::EDateTimeType:
+ {
+ TInternetDate internetDate(aVariant.DateTime());
+ HBufC8* dateTimeStr = internetDate.InternetDateTimeL(TInternetDate::ERfc1123Format);
+ ret = aValueToMatch.CompareF(*dateTimeStr) == 0;
+ delete dateTimeStr;
+ }
+ break;
+
+ default:
+ User::Invariant();
+ }
+ return ret;
+ }
+
+CHeaderInfo* CHttpClientTestParams::FindHeaderInfo(const TDesC8& aHeaderName)
+ {
+ const TUint count = iResponseHeaderInfos.Count();
+ for(TInt i = 0; i < count; ++i)
+ {
+ if(aHeaderName.CompareF(*iResponseHeaderInfos[i]->iFieldName) == 0)
+ {
+ return iResponseHeaderInfos[i];
+ }
+ }
+ return NULL;
+ }
+
+TBool CHttpClientTestParams::MatchPostFileContent()
+ {
+ CFileSender* sender = CFileSender::NewL(iFileSender->FileName());
+ CleanupStack::PushL(sender);
+ CFileSender* sender2 = CFileSender::NewL(iFileReceiver->FileName());
+ CleanupStack::PushL(sender2);
+ sender2->Read(RawRequest().Length());
+ TBool ret = ETrue;
+ while(sender->MoreToRead())
+ {
+ if(!sender2->MoreToRead())
+ {
+ ret = EFalse;
+ break;
+ }
+
+ if(sender->Read().CompareF(sender2->Read()) != 0)
+ {
+ ret = EFalse;
+ break;
+ }
+ }
+ CleanupStack::Pop(2); // sender/sender2
+ return ret;
+ }
+
+TBool CHttpClientTestParams::MatchFileContent()
+ {
+ CFileSender* sender = CFileSender::NewL(iFileSender->FileName());
+ CleanupStack::PushL(sender);
+ CFileSender* sender2 = CFileSender::NewL(iFileReceiver->FileName());
+ CleanupStack::PushL(sender2);
+ TBool ret = ETrue;
+ while(sender->MoreToRead())
+ {
+ if(!sender2->MoreToRead())
+ {
+ ret = EFalse;
+ break;
+ }
+
+ if(sender->Read().CompareF(sender2->Read()) != 0)
+ {
+ ret = EFalse;
+ break;
+ }
+ }
+ CleanupStack::Pop(2); // sender/sender2
+ return ret;
+ }
+
+CHttpClientTestParamArray::CHttpClientTestParamArray()
+ {
+
+ }
+
+CHttpClientTestParamArray::~CHttpClientTestParamArray()
+ {
+ iTestParamArray.ResetAndDestroy();
+ }
+
+void CHttpClientTestParamArray::AddTestParams(CHttpClientTestParams* aParams)
+ {
+ iTestParamArray.Append(aParams);
+ }
+
+CHttpClientTestParams* CHttpClientTestParamArray::MatchingParam(const TDesC8& aData)
+ {
+ CHttpClientTestParams* param = NULL;
+ TInt count = iTestParamArray.Count();
+ for(TUint i = 0; i < count; ++i)
+ {
+ TInt startPos = aData.Locate(' ');
+ TInt reversePos = aData.LocateReverse(' ') - 1;
+ TPtrC8 ptr = aData.Mid(startPos + 1, reversePos - startPos);
+ if (iTestParamArray[i]->Uri().FindF(ptr) != KErrNotFound)
+ {
+ param = iTestParamArray[i];
+ break;
+ }
+ }
+ return param;
+ }
+
+//Parse Replace \n & \r
+void ParseReplaceCRLF(HBufC8* aHBufPtr)
+ {
+ TInt crPos = 0;
+ TInt lfPos = 0;
+ do
+ {
+
+ crPos = ((aHBufPtr->Des()).Find(KScriptCR8()));
+ if (crPos != KErrNotFound)
+ {
+ (aHBufPtr->Des()).Replace(crPos,2, KReplaceCR8());
+ }
+
+ }
+ while (crPos != KErrNotFound );
+
+
+ do
+ {
+
+ lfPos = ((aHBufPtr->Des()).Find(KScriptLF8()));
+ if (lfPos != KErrNotFound)
+ {
+ (aHBufPtr->Des()).Replace(lfPos,2, KReplaceLF8());
+ }
+
+ }
+ while (lfPos != KErrNotFound );
+
+ }
+
+
+CFileSender* CFileSender::NewL(const TDesC& aFileName)
+ {
+ CFileSender* self = new(ELeave) CFileSender;
+ CleanupStack::PushL(self);
+ self->ConstructL(aFileName);
+ CleanupStack::Pop(); // self
+ return self;
+ }
+
+
+void CFileSender::ConstructL(const TDesC& aFileName)
+ {
+ iFileName = aFileName.AllocL();
+ User::LeaveIfError(iFs.Connect());
+ iBuffer.CreateL(16 * 1024);
+ User::LeaveIfError(iFile.Open(iFs, aFileName, EFileShareReadersOnly));
+ User::LeaveIfError(iFile.Size(iFileSize));
+ }
+
+CFileSender::~CFileSender()
+ {
+ delete iFileName;
+ iBuffer.Close();
+ iFile.Close();
+ iFs.Close();
+ }
+
+const TDesC8& CFileSender::Read(TInt aSize)
+ {
+ iBuffer.Zero();
+ iFile.Read(iBuffer, aSize);
+ iFileSize -= iBuffer.Length();
+ return iBuffer;
+ }
+
+const TDesC8& CFileSender::Read()
+ {
+ iBuffer.Zero();
+ iFile.Read(iBuffer);
+ iFileSize -= iBuffer.Length();
+ return iBuffer;
+ }
+
+TInt CFileSender::Size()
+ {
+ TInt size;
+ iFile.Size(size);
+ return size;
+ }
+
+TBool CFileSender::MoreToRead() const
+ {
+ return iFileSize > 0;
+ }
+
+CFileSender::CFileSender()
+ {
+
+ }
+
+const TDesC& CFileSender::FileName() const
+ {
+ return *iFileName;
+ }
+
+CFileReceiver* CFileReceiver::NewL(const TDesC& aFileName)
+ {
+ CFileReceiver* self = new(ELeave) CFileReceiver;
+ CleanupStack::PushL(self);
+ self->ConstructL(aFileName);
+ CleanupStack::Pop(); // self
+ return self;
+ }
+
+ TInt CFileReceiver::Write(const TDesC8& aData)
+ {
+ return iFile.Write(aData);
+ }
+
+ CFileReceiver::~CFileReceiver()
+ {
+ iFile.Close();
+ iFs.Close();
+ delete iFileName;
+ }
+
+ void CFileReceiver::ConstructL(const TDesC& aFileName)
+ {
+ iFileName = aFileName.AllocL();
+ User::LeaveIfError(iFs.Connect());
+ if(iFile.Open(iFs, aFileName, EFileWrite) != KErrNone)
+ {
+ User::LeaveIfError(iFile.Create(iFs, aFileName, EFileWrite));
+ }
+ }
+
+ RFile& CFileReceiver::File()
+ {
+ return iFile;
+ }
+
+ const TDesC& CFileReceiver::FileName() const
+ {
+ return *iFileName;
+ }