void CTextModeTestMultiTrans::MHFRunL(RHTTPTransaction aTransaction,
const THTTPEvent& aEvent)
{
switch (aEvent.iStatus)
{
case THTTPEvent::EGotResponseHeaders:
{
// HTTP response headers have been received
iEngine->Utils().LogIt(_L("<Got response headers>"));
}
break;
case THTTPEvent::ESubmit:
{
} break;
case THTTPEvent::EGotResponseBodyData:
{
// Some (more) body data has been received (in the HTTP response)
iEngine->Utils().LogIt(_L("<Got a chunk of data>"));
ValidateBodyL(aTransaction);
}
break;
case THTTPEvent::EResponseComplete:
{
// The transaction's response is complete
iEngine->Utils().LogIt(_L("<Transaction Complete>"));
}
break;
case THTTPEvent::ESucceeded:
{
iEngine->Utils().LogIt(_L("<Transaction validated successfully>"));
aTransaction.Close();
if (--iOpenTransactionCount == 0)
CActiveScheduler::Stop();
}
break;
case THTTPEvent::EFailed:
{
iEngine->Utils().LogIt(_L("<Transaction NOT validated successfully>"));
aTransaction.Close();
if (--iOpenTransactionCount == 0)
{
CActiveScheduler::Stop();
}
iFailureError = KErrTestFailed;
}
break;
default:
{
iEngine->Utils().LogIt(_L("<unrecognised event> %d"),aEvent.iStatus);
if (aEvent.iStatus < 0)
{
iFailureError = aEvent.iStatus;
CActiveScheduler::Stop();
}
}
break;
}
}
void CRecvBufSizeTest1::MHFRunL(RHTTPTransaction aTransaction, const THTTPEvent& aEvent)
{
switch (aEvent.iStatus)
{
case THTTPEvent::EGotResponseHeaders:
{
iEngine->Utils().LogIt(_L("<Got response headers>"));
} break;
case THTTPEvent::EGotResponseBodyData:
{
iEngine->Utils().LogIt(_L("<Got a chunk of data>"));
MHTTPDataSupplier* iRespBody = aTransaction.Response().Body();
TPtrC8 bodyData;
TBool lastChunk = iRespBody->GetNextDataPart( bodyData );
iRespBody->ReleaseData();
} break;
case THTTPEvent::EResponseComplete:
{
iEngine->Utils().LogIt(_L("<Transaction Complete>"));
} break;
case THTTPEvent::ESucceeded:
{
iEngine->Utils().LogIt(_L("<Transaction succeeded>"));
aTransaction.Close();
CActiveScheduler::Stop();
}
break;
case THTTPEvent::EFailed:
{
iEngine->Utils().LogIt(_L("<Transaction failed>"));
aTransaction.Close();
CActiveScheduler::Stop();
} break;
default:
{
_LIT(KLogDescription, "<unrecognised event> %d");
iEngine->Utils().LogIt(KLogDescription,aEvent.iStatus);
if (aEvent.iStatus < 0)
{
iFailureError = aEvent.iStatus;
CActiveScheduler::Stop();
}
}
break;
}
return;
}
void CHttpController::CloseTransaction( RHTTPTransaction& aTransaction )
{
aTransaction.Close();
delete iResponseData;
iResponseData = NULL;
if ( iOutputStream )
{
iOutputStream->Close();
iOutputStream = NULL;
}
iState = EHttpFinished;
}
void CHttpTestCase8::DoRunL()
{
// Literals used in the function
_LIT8(KWapTestUrl, "http://WapTestIP/perl/protected/dumpform.pl");
// Replace the host name in the URL
HBufC8* newUrl8 = TSrvAddrVal::ReplaceHostNameL(KWapTestUrl(), iIniSettingsFile);
CleanupStack::PushL(newUrl8);
TPtr8 newUrlPtr8 = newUrl8->Des();
TUriParser8 testURI;
testURI.Parse(newUrlPtr8);
//open a Session
RHTTPSession mySession;
mySession.OpenL();
CleanupClosePushL(mySession);
iEngine->Utils().LogIt(_L("Session Created(TC8)"));
iEngine->Utils().LogIt(_L("Session parameters: Default"));
// Install the authorisation plugin.
InstallAuthenticationL(mySession);
//Get the mySession'string pool handle;
iMyStrP = mySession.StringPool();
//Create , open and push in the CS a Transaction in mySession
RHTTPTransaction myTransaction;
myTransaction = mySession.OpenTransactionL(testURI, *this, mySession.StringPool().StringF(HTTP::EPOST,RHTTPSession::GetTable()));
CleanupClosePushL(myTransaction);
iEngine->Utils().LogIt(_L("Transaction Created in mySession"));
//Get a handle of the request in myTransaction
RHTTPRequest myRequest = myTransaction.Request();
RHTTPHeaders myHeaders = myRequest.GetHeaderCollection();
// provide some headers
THTTPHdrVal v2(iMyStrP.OpenFStringL(_L8("text/plain")));
THTTPHdrVal v3(iMyStrP.OpenFStringL(_L8("text/html")));
THTTPHdrVal v4(6);
myHeaders.SetFieldL(iMyStrP.OpenFStringL(_L8("Accept")),v2 );
myHeaders.SetFieldL(iMyStrP.OpenFStringL(_L8("Content-Type")), v3);
myHeaders.SetFieldL(iMyStrP.StringF(HTTP::EContentLength, RHTTPSession::GetTable()),v4);
iEngine->Utils().LogIt(_L("Testing Authentication. Method:Post"));
myRequest.SetBody(*this);
myTransaction.SubmitL();
CActiveScheduler::Start();
myTransaction.Close();
iEngine->Utils().LogIt(_L("Transaction terminated\n"));
mySession.Close();
iEngine->Utils().LogIt(_L("Session terminated"));
if (iTestFail==1)
{
User::Leave(-1);
}
CleanupStack::Pop(2); // mySession,myTansaction
CleanupStack::PopAndDestroy(newUrl8);
}
void CHttpController::ProcessResponseCompleteL( RHTTPTransaction& aTransaction )
{
CheckStatusCodeL( aTransaction );
iState = EHttpFinished;
aTransaction.Close();
if ( iOutputStream )
{
iOutputStream->CommitL();
iOutputStream->Close();
iOutputStream = NULL;
iObserver->StreamReceived();
}
else
{
iObserver->ContentReceived( iResponseData );
iResponseData = NULL;
}
delete iResponseData;
iResponseData = NULL;
iObserver->TransactionSucceeded();
iState = EHttpNotified;
}
// ----------------------------------------------------------------------------
// CClientEngine::MHFRunL()
//
// Inherited from MHTTPTransactionCallback
// Called by framework to pass transaction events.
// ----------------------------------------------------------------------------
void CClientEngine::MHFRunL(RHTTPTransaction aTransaction,
const THTTPEvent& aEvent)
{
switch (aEvent.iStatus)
{
case THTTPEvent::EGotResponseHeaders:
{
// HTTP response headers have been received. Use
// aTransaction.Response() to get the response. However, it's not
// necessary to do anything with the response when this event occurs.
// Get HTTP status code from header (e.g. 200)
RHTTPResponse resp = aTransaction.Response();
TInt status = resp.StatusCode();
// Get status text (e.g. "OK")
TBuf<KStatustextBufferSize> statusText;
statusText.Copy(resp.StatusText().DesC());
TBuf<KDefaultBufferSize> text;
_LIT(KHeaderReceived, "Header received. Status: %d %S");
text.Format(KHeaderReceived, status, &statusText);
iObserver.ClientEvent(text);
}
break;
case THTTPEvent::EGotResponseBodyData:
{
// Part (or all) of response's body data received. Use
// aTransaction.Response().Body()->GetNextDataPart() to get the actual
// body data.
// Get the body data supplier
MHTTPDataSupplier* body = aTransaction.Response().Body();
TPtrC8 dataChunk;
// GetNextDataPart() returns ETrue, if the received part is the last
// one.
TBool isLast = body->GetNextDataPart(dataChunk);
iObserver.ClientBodyReceived(dataChunk);
TBuf<KInfotextBufferSize> text;
_LIT(KBodyPartReceived, "%d bytes received... ");
text.Format(KBodyPartReceived, dataChunk.Length());
iObserver.ClientEvent(text);
// NOTE: isLast may not be ETrue even if last data part received.
// (e.g. multipart response without content length field)
// Use EResponseComplete to reliably determine when body is completely
// received.
if (isLast)
{
_LIT(KBodyReceived,"Body received");
iObserver.ClientEvent(KBodyReceived);
}
// Always remember to release the body data.
body->ReleaseData();
}
break;
case THTTPEvent::EResponseComplete:
{
// Indicates that header & body of response is completely received.
// No further action here needed.
_LIT(KTransactionComplete, "Transaction Complete");
iObserver.ClientEvent(KTransactionComplete);
}
break;
case THTTPEvent::ESucceeded:
{
// Indicates that transaction succeeded.
_LIT(KTransactionSuccessful, "Transaction Successful");
iObserver.ClientEvent(KTransactionSuccessful);
// Transaction can be closed now. It's not needed anymore.
aTransaction.Close();
iRunning = EFalse;
}
break;
case THTTPEvent::EFailed:
{
// Transaction completed with failure.
_LIT(KTransactionFailed, "Transaction Failed");
iObserver.ClientEvent(KTransactionFailed);
aTransaction.Close();
iRunning = EFalse;
}
break;
default:
// There are more events in THTTPEvent, but they are not usually
// needed. However, event status smaller than zero should be handled
// correctly since it's error.
{
TBuf<KInfotextBufferSize> text;
if (aEvent.iStatus < 0)
{
_LIT(KErrorStr, "Error: %d");
text.Format(KErrorStr, aEvent.iStatus);
// Just close the transaction on errors
aTransaction.Close();
iRunning = EFalse;
}
else
{
// Other events are not errors (e.g. permanent and temporary
// redirections)
_LIT(KUnrecognisedEvent, "Unrecognised event: %d");
text.Format(KUnrecognisedEvent, aEvent.iStatus);
}
iObserver.ClientEvent(text);
}
break;
}
}
void CINC097492_3::MHFRunL(RHTTPTransaction aTransaction, const THTTPEvent& aEvent)
{
switch (aEvent.iStatus)
{
case THTTPEvent::EGotResponseHeaders:
{
// HTTP response headers have been received
iEngine->Utils().LogIt(_L("<Got response headers>"));
MHTTPDataSupplier* body = aTransaction.Response().Body ();
if ( body )
{
body->ReleaseData ();
}
} break;
case THTTPEvent::ESubmit:
{
} break;
case THTTPEvent::EGotResponseBodyData:
{
// Some (more) body data has been received (in the HTTP response)
iEngine->Utils().LogIt(_L("<Got a chunk of data>"));
// Get the body data supplier
MHTTPDataSupplier* iRespBody = aTransaction.Response().Body();
// Append to the output file.
TPtrC8 bodyData;
TBool lastChunk = iRespBody->GetNextDataPart( bodyData );
iRespBody->ReleaseData();
} break;
case THTTPEvent::EResponseComplete:
{
// The transaction's response is complete
iEngine->Utils().LogIt(_L("<Transaction Complete>"));
} break;
case THTTPEvent::ESucceeded:
{
// The transaction succeeded
iEngine->Utils().LogIt(_L("<Transaction succeeded>"));
aTransaction.Close();
if(--iOpenTransCount == 0)
{
CActiveScheduler::Stop();
}
}
break;
case THTTPEvent::EFailed:
{
// The transaction failed so fail the test
iEngine->Utils().LogIt(_L("<Transaction failed>"));
aTransaction.Close();
if(--iOpenTransCount == 0)
{
CActiveScheduler::Stop();
}
} break;
default:
{
_LIT(KLogDescription, "<unrecognised event> %d");
iEngine->Utils().LogIt(KLogDescription,aEvent.iStatus);
if (aEvent.iStatus < 0)
{
iFailureError = aEvent.iStatus;
CActiveScheduler::Stop();
}
}
break;
}
return;
}
void CHttpTestCase4::DoRunL()
{
// Literals used in the function
_LIT8(KWapTestUrl, "http://WapTestIP/perl/dumpform.pl");
// Replace the host name in the URL
HBufC8* newUrl8 = TSrvAddrVal::ReplaceHostNameL(KWapTestUrl(), iIniSettingsFile);
CleanupStack::PushL(newUrl8);
TPtr8 newUrlPtr8 = newUrl8->Des();
TUriParser8 testURI;
testURI.Parse(newUrlPtr8);
//open a Session
RHTTPSession mySession;
mySession.OpenL();
CleanupClosePushL(mySession);
iEngine->Utils().LogIt(_L("Session Created(TC4)"));
iEngine->Utils().LogIt(_L("Session parameters: Default"));
//Get the mySession'string pool handle;
iMyStrP = mySession.StringPool();
//get strings this testcase needs
RStringF textPlain = iMyStrP.StringF(HTTP::ETextPlain, RHTTPSession::GetTable());
RStringF textHtml = iMyStrP.StringF(HTTP::ETextHtml, RHTTPSession::GetTable());
RStringF mimeType = iMyStrP.StringF(HTTP::EApplicationXWwwFormUrlEncoded, RHTTPSession::GetTable());
//Open a Transaction in mySession
RHTTPTransaction myTransaction;
myTransaction = mySession.OpenTransactionL(testURI, *this, iMyStrP.StringF(HTTP::EPOST,RHTTPSession::GetTable()));
CleanupClosePushL(myTransaction);
iEngine->Utils().LogIt(_L("Transaction Created in mySession"));
//Get a handle of the request in myTransaction
RHTTPRequest myRequest = myTransaction.Request();
RHTTPHeaders myHeaders = myRequest.GetHeaderCollection();
//provide some headers
THTTPHdrVal v2(textPlain);
THTTPHdrVal v3(textHtml);
THTTPHdrVal v4(6);
THTTPHdrVal v5(mimeType);
myHeaders.SetFieldL(iMyStrP.StringF(HTTP::EAccept,RHTTPSession::GetTable()),v2);
myHeaders.SetFieldL(iMyStrP.StringF(HTTP::EAccept,RHTTPSession::GetTable()),v3);
myHeaders.SetFieldL(iMyStrP.StringF(HTTP::EContentLength,RHTTPSession::GetTable()),v4);
myHeaders.SetFieldL(iMyStrP.StringF(HTTP::EContentType,RHTTPSession::GetTable()), v5);
TSrvAddrVal::LogUsing8BitDesL(iEngine, newUrlPtr8);
iEngine->Utils().LogIt(_L("Method:Post"));
iEngine->Utils().LogIt(_L("Accept:test/plain,text/html"));
iEngine->Utils().LogIt(_L("Content-Type: application/x-www-form-urlencoded"));
iEngine->Utils().LogIt(_L("Content-Length: 6"));
myRequest.SetBody(*this);
myTransaction.SubmitL();
CActiveScheduler::Start();
//close Transaction and session
myTransaction.Close();
iEngine->Utils().LogIt(_L("Transaction terminated\n"));
mySession.Close();
iEngine->Utils().LogIt(_L("Session terminated"));
if (iTestFail==1)
{
User::Leave(-1);
}
CleanupStack::Pop(2); // mySession, myTansaction
CleanupStack::PopAndDestroy(newUrl8);
}
void CTextModeTestMultiTransMalformedStatusLine::MHFRunL(RHTTPTransaction aTransaction,
const THTTPEvent& aEvent)
{
switch (aEvent.iStatus)
{
case THTTPEvent::EGotResponseHeaders:
{
// HTTP response headers have been received
iEngine->Utils().LogIt(_L("<Got response headers>"));
} break;
case THTTPEvent::ESubmit:
{
} break;
case THTTPEvent::EGotResponseBodyData:
{
// Some (more) body data has been received (in the HTTP response)
iEngine->Utils().LogIt(_L("<Got a chunk of data>"));
} break;
case THTTPEvent::EResponseComplete:
{
// The transaction's response is complete
iEngine->Utils().LogIt(_L("<Transaction Complete>"));
} break;
case THTTPEvent::ESucceeded:
{
iEngine->Utils().LogIt(_L("<Transaction validated successfully>"));
aTransaction.Close();
if (--iOpenTransactionCount == 0)
CActiveScheduler::Stop();
} break;
case THTTPEvent::EFailed:
{
iEngine->Utils().LogIt(_L("<Transaction NOT validated successfully>"));
aTransaction.Close();
if (--iOpenTransactionCount == 0)
{
CActiveScheduler::Stop();
}
iFailureError = KErrTestFailed;
} break;
default:
{
iEngine->Utils().LogIt(_L("<unrecognised event> %d"),aEvent.iStatus);
aTransaction.Close();
TInt status = aEvent.iStatus;
if ( status < 0)
{
if( status == KErrCouldNotConnect )
{
++iConnectFailureCount;
// If we get KErrCouldNotConnect create another transation to replace (it means the
// test server is too slow and was not ready for the next request)
RStringF get = iSession.StringPool().StringF(HTTP::EGET,RHTTPSession::GetTable());
CreateSingleTransactionL(get);
}
else if( status == KErrCorrupt )
iConnectFailureCount = 0;
else
iFailureError = aEvent.iStatus;
if( --iOpenTransactionCount == 0 )
CActiveScheduler::Stop();
if ( iConnectFailureCount == 10 )
{
iFailureError = KErrCouldNotConnect;
CActiveScheduler::Stop();
}
}
}
break;
}
}
void CHttpEventHandler::MHFRunL(RHTTPTransaction aTransaction, const THTTPEvent& aEvent)
{
switch (aEvent.iStatus)
{
case THTTPEvent::EGotResponseHeaders:
{
// HTTP response headers have been received. We can determine now if there is
// going to be a response body to save.
RHTTPResponse resp = aTransaction.Response();
TInt status = resp.StatusCode();
if (iVerbose)
{
RStringF statusStr = resp.StatusText();
TBuf<32> statusStr16;
statusStr16.Copy(statusStr.DesC());
iTest->Console()->Printf(_L("Status: %d (%S)\n"), status, &statusStr16);
// Dump the headers if we're being verbose
DumpRespHeadersL(aTransaction);
}
// Determine if the body will be saved to disk
iSavingResponseBody = EFalse;
if (resp.HasBody() && (status >= 200) && (status < 300) && (status != 204))
{
if (iVerbose)
{
TInt dataSize = resp.Body()->OverallDataSize();
if (dataSize >= 0)
iTest->Console()->Printf(_L("Response body size is %d\n"), dataSize);
else
iTest->Console()->Printf(_L("Response body size is unknown\n"));
}
iSavingResponseBody = ETrue;
}
else
{
if (iVerbose)
iTest->Console()->Printf(_L("Response status is bad\n"));
}
if ((status >= 200) && (status < 300) && (status != 204))
{
ParseCookieL(aTransaction);
}
if (iSavingResponseBody) // If we're saving, then open a file handle for the new file
{
if ( iUsingFile )
{
iHttpFileManager->GetNewFile(iRespBodyFilePath, iRespBodyFileName, EFalse);
// Check it exists and open a file handle
TInt valid = iFileServ.IsValidName(iRespBodyFilePath);
if (!valid)
{
if (iVerbose)
iTest->Console()->Printf(_L("The specified filename is not valid!.\n"));
iSavingResponseBody = EFalse;
}
else
{
TInt err = iRespBodyFile.Create(iFileServ,
iRespBodyFilePath,
EFileWrite|EFileShareExclusive);
if (err)
{
iSavingResponseBody = EFalse;
User::Leave(err);
}
}
}
else
{
TInt dataSize = resp.Body()->OverallDataSize();
if ( iResBodyBuffer )
delete iResBodyBuffer;
iResBodyBuffer = NULL;
if ( dataSize > 50 * 1024) //skip large chunks of data
{
iSavingResponseBody = false;
//try to stop current connection
if (iVerbose)
iTest->Console()->Printf(_L("Transaction Failed\n"));
aTransaction.Close();
CActiveScheduler::Stop();
}
else
{
iResBodyBuffer = HBufC8::NewMaxL(dataSize);
iResBodyBufferPtr.Set(iResBodyBuffer->Des());
}
iCurPos = 0;
}
}
} break;
case THTTPEvent::EGotResponseBodyData:
{
// Get the body data supplier
iRespBody = aTransaction.Response().Body();
// Some (more) body data has been received (in the HTTP response)
if (iVerbose)
DumpRespBody(aTransaction);
// Append to the output file if we're saving responses
if (iSavingResponseBody)
{
TPtrC8 bodyData;
TBool lastChunk = iRespBody->GetNextDataPart(bodyData);
if ( iUsingFile )
{
iRespBodyFile.Write(bodyData);
if (lastChunk)
{
iRespBodyFile.Flush();
iRespBodyFile.Rename(iRespBodyFileName);
iRespBodyFile.Close();
}
}
else
{
Mem::Copy((void*)(iResBodyBuffer->Ptr()+iCurPos), (void*)bodyData.Ptr(), bodyData.Size());
iCurPos += bodyData.Size();
}
}
// Done with that bit of body data
iRespBody->ReleaseData();
} break;
case THTTPEvent::EResponseComplete:
{
// The transaction's response is complete
if (iVerbose)
iTest->Console()->Printf(_L("\nTransaction Complete\n"));
} break;
case THTTPEvent::ESucceeded:
{
if (iVerbose)
iTest->Console()->Printf(_L("Transaction Successful\n"));
aTransaction.Close();
CActiveScheduler::Stop();
} break;
case THTTPEvent::EFailed:
{
if (iVerbose)
iTest->Console()->Printf(_L("Transaction Failed\n"));
aTransaction.Close();
CActiveScheduler::Stop();
} break;
case THTTPEvent::ERedirectedPermanently:
{
if (iVerbose)
iTest->Console()->Printf(_L("Permanent Redirection\n"));
} break;
case THTTPEvent::ERedirectedTemporarily:
{
if (iVerbose)
iTest->Console()->Printf(_L("Temporary Redirection\n"));
} break;
default:
{
if (iVerbose)
iTest->Console()->Printf(_L("<unrecognised event: %d>\n"), aEvent.iStatus);
// close off the transaction if it's an error
if (aEvent.iStatus < 0)
{
aTransaction.Close();
CActiveScheduler::Stop();
}
} break;
}
}
void CSTTrackerConnection::MHFRunL(RHTTPTransaction aTransaction,
const THTTPEvent& aEvent)
{
switch (aEvent.iStatus)
{
case THTTPEvent::EGotResponseHeaders:
{
// HTTP response headers have been received. Use
// aTransaction.Response() to get the response. However, it's not
// necessary to do anything with the response when this event occurs.
LWRITELN(iLog, _L("[Trackerconnection] Got HTTP headers"));
// Get HTTP status code from header (e.g. 200)
RHTTPResponse resp = aTransaction.Response();
TInt status = resp.StatusCode();
if (status != 200) // ERROR, hiba esetén mi legyen? 404-et lekezelni!
{
LWRITE(iLog, _L("[Trackerconnection] Error, status = "));
TBuf<20> numBuf;
numBuf.Num(status);
LWRITELN(iLog, numBuf);
Cancel();
if (iObserver)
iObserver->TrackerConnectionFailedL();
break;
}
// Get status text (e.g. "OK")
HLWRITE(iLog, _L("[Trackerconnection] Status text = "));
TBuf<32> statusText;
statusText.Copy(resp.StatusText().DesC());
HLWRITELN(iLog, statusText);
#ifdef LOG_TO_FILE
RHTTPHeaders headers =
aTransaction.Response().GetHeaderCollection();
THTTPHdrFieldIter i =
headers.Fields();
for (i.First(); !(i.AtEnd()); ++i)
{
RStringF header = iSession.StringPool().StringF(i());
if ((header.DesC() == _L8("Content-Type")))
{
HLWRITE(iLog, header.DesC());
HLWRITE(iLog, _L(": "));
THTTPHdrVal val;
headers.GetField(header, 0, val);
RStringF value = val.StrF();
HLWRITELN(iLog, value.DesC());
}
else
HLWRITELN(iLog, header.DesC());
}
#endif
}
break;
case THTTPEvent::EGotResponseBodyData:
{
// Part (or all) of response's body data received. Use
// aTransaction.Response().Body()->GetNextDataPart() to get the actual
// body data.
// Get the body data supplier
MHTTPDataSupplier* body = aTransaction.Response().Body();
TPtrC8 dataChunk;
// GetNextDataPart() returns ETrue, if the received part is the last
// one.
TBool isLast = body->GetNextDataPart(dataChunk);
//iDownloadedSize += dataChunk.Size();
HLWRITELN(iLog, _L8("[TrackerConnection] HTTP response body chunk received: "));
HLWRITELN(iLog, dataChunk);
if (iReceiveBuffer)
{
HBufC8* temp = HBufC8::NewL(
iReceiveBuffer->Length() + dataChunk.Length());
TPtr8 tempPtr(temp->Des());
tempPtr.Copy(*iReceiveBuffer);
tempPtr.Append(dataChunk);
delete iReceiveBuffer;
iReceiveBuffer = temp;
}
else
iReceiveBuffer = dataChunk.AllocL();
// Always remember to release the body data.
body->ReleaseData();
// NOTE: isLast may not be ETrue even if last data part received.
// (e.g. multipart response without content length field)
// Use EResponseComplete to reliably determine when body is completely
// received.
if (isLast)
{
#ifdef LOG_TO_FILE
_LIT(KBodyReceived,"Body received");
HLWRITELN(iLog, KBodyReceived);
#endif
//CSTBencode* bencodedResponse = CSTBencode::ParseL(*iReceiveBuffer);
//iLog->WriteLineL(*iReceiveBuffer);
//
//if (bencodedResponse)
//{
// CleanupStack::PushL(bencodedResponse);
// iTorrent.ProcessTrackerResponseL(bencodedResponse);
// CleanupStack::PopAndDestroy(); // bencodedResponse
//}
}
}
break;
case THTTPEvent::EResponseComplete:
{
// Indicates that header & body of response is completely received.
// No further action here needed.
//_LIT(KTransactionComplete, "Transaction Complete");
//iLog->WriteLineL(KTransactionComplete);
//iResult = ESucceeded;
}
break;
case THTTPEvent::ESucceeded:
{
LWRITELN(iLog, _L("[Trackerconnection] HTTP transaction succeded"));
CSTBencode* bencodedResponse = CSTBencode::ParseL(*iReceiveBuffer);
//iLog->WriteLineL(*iReceiveBuffer);
if (bencodedResponse && iObserver)
{
CleanupStack::PushL(bencodedResponse);
iObserver->TrackerResponseReceivedL(*bencodedResponse);
CleanupStack::PopAndDestroy(); // bencodedResponse
}
iRunning = EFalse;
if (iObserver)
iObserver->TrackerConnectionSucceededL();
}
break;
case THTTPEvent::EFailed:
{
LWRITELN(iLog, _L("[Trackerconnection] HTTP transaction failed"));
iRunning = EFalse;
if (iObserver)
iObserver->TrackerConnectionFailedL();
}
break;
default:
// There are more events in THTTPEvent, but they are not usually
// needed. However, event status smaller than zero should be handled
// correctly since it's error.
{
TBuf<64> text;
if (aEvent.iStatus < 0)
{
LWRITE(iLog, _L("[Trackerconnection] HTTP transaction failed, "));
_LIT(KErrorStr, "Error: %d");
text.Format(KErrorStr, aEvent.iStatus);
LWRITELN(iLog, text);
// Just close the transaction on errors
aTransaction.Close();
iRunning = EFalse;
if (iObserver)
iObserver->TrackerConnectionFailedL();
}
else
{
// Other events are not errors (e.g. permanent and temporary
// redirections)
_LIT(KUnrecognisedEvent, "[Trackerconnection] Unrecognised event: %d");
text.Format(KUnrecognisedEvent, aEvent.iStatus);
LWRITELN(iLog, text);
}
}
break;
}
}
