00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017 #include <uri8.h>
00018 #include <e32base.h>
00019 #include <http.h>
00020 #include <chttpformencoder.h>
00021
00022 #include "httpexampleclient.h"
00023 #include "httpexampleutils.h"
00024
00025
00026
00027 _LIT(KDateFormat,"%D%M%Y%/0%1%/1%2%/2%3%/3 %:0%H%:1%T%:2%S.%C%:3");
00028
00029
00030 _LIT(KFileSystemRoot,"\\");
00031
00032
00033 _LIT8(KUserAgent, "HTTPExampleClient (1.0)");
00034 _LIT8(KAccept, "*/*");
00035
00036 _LIT(KHttpExampleClientPanic, "HTTP-EC");
00037
00038 enum THttpExampleClientPanics
00039 {
00040 EReqBodySumitBufferNotAllocated,
00041 KBodyWithInvalidSize,
00042 KCouldntNotifyBodyDataPart
00043 };
00044
00045
00046 const TInt KMaxSubmitSize = 1024;
00047 const TInt KMaxHeaderNameLen = 32;
00048 const TInt KMaxHeaderValueLen = 128;
00049
00050
00051
00052
00053
00054
00055
00056
00057 _LIT(KHttpExampleClientTestName, "HttpExample");
00058
00059 CHttpClient::CHttpClient()
00060 : iReqBodySubmitBufferPtr(0,0)
00061 {
00062
00063 ResetTimeElapsed();
00064 }
00065
00066
00067 CHttpClient::~CHttpClient()
00068 {
00069 iSess.Close();
00070 iFileServ.Close();
00071 delete iReqBodySubmitBuffer;
00072 delete iTransObs;
00073 delete iFormEncoder;
00074 delete iUtils;
00075 }
00076
00077 CHttpClient* CHttpClient::NewLC()
00078 {
00079 CHttpClient* me = new(ELeave) CHttpClient;
00080 CleanupStack::PushL(me);
00081 me->ConstructL();
00082 return me;
00083 }
00084
00085 CHttpClient* CHttpClient::NewL()
00086 {
00087 CHttpClient* me = NewLC();
00088 CleanupStack::Pop(me);
00089 return me;
00090 }
00091
00092 void CHttpClient::ConstructL()
00093 {
00094 iUtils = CHttpExampleUtils::NewL(KHttpExampleClientTestName);
00095
00096
00097 iSess.OpenL();
00098
00099
00100 InstallAuthenticationL(iSess);
00101
00102 User::LeaveIfError(iFileServ.Connect());
00103 iTransObs = CHttpEventHandler::NewL(*iUtils);
00104 }
00105
00106 void CHttpClient::StartClientL()
00107 {
00108 ResetTimeElapsed();
00109 TBuf<256> url;
00110 RStringPool strP = iSess.StringPool();
00111
00112
00113 TBool done = EFalse;
00114 while (!done)
00115 {
00116
00117 iUtils->Test().Console()->ClearScreen();
00118 _LIT(KSelectOption, " Select an option \n\n");
00119 iUtils->Test().Printf(KSelectOption);
00120 _LIT(KPossibleSelectionsText, " 1 Get \n 2 Post \n 3 Head \n 4 Trace \n 5 Toggle Verbose \n 6 Quit \n");
00121 _LIT(KPossibleSelections,"123456");
00122 TInt selection = iUtils->GetSelection(KPossibleSelectionsText, KPossibleSelections);
00123 RStringF method;
00124 iHasARequestBody = EFalse;
00125
00126
00127 switch (selection)
00128 {
00129 case EGet:
00130 method = strP.StringF(HTTP::EGET,RHTTPSession::GetTable());
00131 break;
00132 case EPost:
00133 method = strP.StringF(HTTP::EPOST,RHTTPSession::GetTable());
00134 iHasARequestBody = ETrue;
00135 break;
00136 case EHead:
00137 method = strP.StringF(HTTP::EHEAD,RHTTPSession::GetTable());
00138 break;
00139 case ETrace:
00140 method = strP.StringF(HTTP::ETRACE,RHTTPSession::GetTable());
00141 break;
00142 case EToggleVerbosity:
00143 {
00144 TBool verbose = iTransObs->Verbose();
00145 iTransObs->SetVerbose(!verbose);
00146 if (!verbose)
00147 User::InfoPrint(_L("Verbosity is ON "));
00148 else
00149 User::InfoPrint(_L("Verbosity is OFF"));
00150 }
00151 break;
00152 case EQuit:
00153 done = ETrue;
00154 break;
00155 default:
00156 break;
00157 }
00158
00159 if (!done && (selection >= 0) && (selection <= 3))
00160 {
00161
00162 _LIT(KEnterUrl, "Enter Url");
00163 iUtils->GetAnEntry(KEnterUrl, url);
00164 if (url.Length() > 0)
00165 {
00166
00167 if (iHasARequestBody)
00168 {
00169 GetRequestBodyL(method);
00170 }
00171
00172
00173 TBuf8<256> url8;
00174 url8.Copy(url);
00175 InvokeHttpMethodL(url8, method);
00176 }
00177 else
00178 {
00179 _LIT(KEmptyUrlErrorText, "You must supply a non empty url");
00180 iUtils->Test().Printf(KEmptyUrlErrorText);
00181 User::After(1000000);
00182 }
00183 }
00184
00185 }
00186
00187
00188 DisplayTimeElapsed();
00189 iUtils->PressAnyKey();
00190 }
00191
00196 void CHttpClient::GetPostBodyManuallyL()
00197 {
00198 if (iFormEncoder)
00199 {
00200 delete iFormEncoder;
00201 iFormEncoder = NULL;
00202 }
00203
00204 iFormEncoder = CHTTPFormEncoder::NewL();
00205 TBuf<256> name;
00206 TBuf<256> value;
00207 TBuf8<256> name8;
00208 TBuf8<256> value8;
00209
00210 _LIT(KGetPostName, "Enter Name (END to finish)");
00211 _LIT(KGetPostValue, "Enter Value ");
00212 _LIT(KEnd, "END");
00213 do
00214 {
00215 iUtils->GetAnEntry(KGetPostName, name);
00216 if (name.CompareF(KEnd) != 0)
00217 {
00218 iUtils->GetAnEntry(KGetPostValue, value);
00219 name8.Copy(name);
00220 value8.Copy(value);
00221 iFormEncoder->AddFieldL(name8, value8);
00222 }
00223 }
00224 while (name.CompareF(KEnd) != 0);
00225 }
00226
00227
00231 void CHttpClient::GetRequestBodyL(RStringF& aMethod)
00232 {
00233 if (aMethod== iSess.StringPool().StringF(HTTP::EPOST,RHTTPSession::GetTable()))
00234 {
00235
00236 _LIT(KConstructPostManually, "\n> Construct Post Manually? Yes | No ");
00237 _LIT(KYesNo, "YyNn");
00238 TInt selection = iUtils->GetSelection(KConstructPostManually,KYesNo);
00239 if (selection < 2)
00240 {
00241 iManualPost = ETrue;
00242 GetPostBodyManuallyL();
00243 return;
00244 }
00245
00246 }
00247
00248 iManualPost = EFalse;
00249 _LIT(KRequestPathPrompt, "Enter path to request body file: ");
00250 iUtils->GetAnEntry(KRequestPathPrompt, iReqBodyFileName);
00251 _LIT(KRequestBodyContentType, "Enter request body content-type: ");
00252 iUtils->GetAnEntry(KRequestBodyContentType, iReqBodyContentType);
00253 iParsedFileName.Set(KFileSystemRoot,&iReqBodyFileName,NULL);
00254
00255
00256 if (iFileServ.IsValidName(iReqBodyFileName))
00257 {
00258 User::LeaveIfError(iReqBodyFile.Open(iFileServ, iParsedFileName.FullName(), EFileRead));
00259 delete iReqBodySubmitBuffer;
00260 iReqBodySubmitBuffer = NULL;
00261 iReqBodySubmitBuffer = HBufC8::NewMaxL(KMaxSubmitSize);
00262 iReqBodySubmitBufferPtr.Set(iReqBodySubmitBuffer->Des());
00263 }
00264 else
00265 {
00266 _LIT(KFileNameNotValid, "The specified filename is not valid!.\n");
00267 iUtils->Test().Printf(KFileNameNotValid);
00268 }
00269 }
00270
00271 TBool CHttpClient::GetNextDataPart(TPtrC8& aDataPart)
00272 {
00273 __ASSERT_DEBUG(iReqBodySubmitBuffer, User::Panic(KHttpExampleClientPanic, EReqBodySumitBufferNotAllocated));
00274
00275 TBool retVal = EFalse;
00276 TInt err = iReqBodyFile.Read(iReqBodySubmitBufferPtr);
00277 if (err == KErrNone)
00278 {
00279 aDataPart.Set(iReqBodySubmitBufferPtr);
00280 ++iDataChunkCount;
00281 retVal = (iReqBodySubmitBufferPtr.Length() == 0);
00282 }
00283 return retVal;
00284 }
00285
00286 void CHttpClient::ReleaseData()
00287 {
00288
00289 TPtr8 buff = iReqBodySubmitBuffer->Des();
00290 buff.Zero();
00291
00292 TRAPD(err, iTrans.NotifyNewRequestBodyPartL());
00293 if (err != KErrNone)
00294 User::Panic(KHttpExampleClientPanic, KCouldntNotifyBodyDataPart);
00295 }
00296
00297 TInt CHttpClient::OverallDataSize()
00298 {
00299 TInt size = 0;
00300 TInt err = iReqBodyFile.Size(size);
00301 if (err < 0)
00302 User::Panic(KHttpExampleClientPanic,KBodyWithInvalidSize);
00303
00304 return size;
00305 }
00306
00307 TInt CHttpClient::Reset()
00308 {
00309 return KErrNotSupported;
00310 }
00311
00312
00316 void CHttpClient::InvokeHttpMethodL(const TDesC8& aUri, RStringF aMethod)
00317 {
00318
00319
00320
00321
00322
00323
00324
00325
00326 iDataChunkCount = 0;
00327 TUriParser8 uri;
00328 uri.Parse(aUri);
00329 iTrans = iSess.OpenTransactionL(uri, *iTransObs, aMethod);
00330 RHTTPHeaders hdr = iTrans.Request().GetHeaderCollection();
00331
00332
00333 SetHeaderL(hdr, HTTP::EUserAgent, KUserAgent);
00334 SetHeaderL(hdr, HTTP::EAccept, KAccept);
00335
00336
00337 if (iHasARequestBody)
00338 {
00339
00340 TBuf8<KMaxContentTypeSize> contTypeBuf;
00341 contTypeBuf.Copy(iReqBodyContentType);
00342 RStringF contTypeStr = iSess.StringPool().OpenFStringL(contTypeBuf);
00343 THTTPHdrVal contType(contTypeStr);
00344 hdr.SetFieldL(iSess.StringPool().StringF(HTTP::EContentType,RHTTPSession::GetTable()), contType);
00345 contTypeStr.Close();
00346
00347 MHTTPDataSupplier* dataSupplier = this;
00348 if (iManualPost)
00349 dataSupplier = iFormEncoder;
00350 iTrans.Request().SetBody(*dataSupplier);
00351 }
00352
00353
00354 iTrans.SubmitL();
00355
00356
00357
00358 CActiveScheduler::Start();
00359
00360
00361 iUtils->PressAnyKey();
00362
00363
00364 if (iHasARequestBody)
00365 iReqBodyFile.Close();
00366 }
00367
00368 void CHttpClient::SetHeaderL(RHTTPHeaders aHeaders, TInt aHdrField, const TDesC8& aHdrValue)
00369 {
00370 RStringF valStr = iSess.StringPool().OpenFStringL(aHdrValue);
00371 THTTPHdrVal val(valStr);
00372 aHeaders.SetFieldL(iSess.StringPool().StringF(aHdrField,RHTTPSession::GetTable()), val);
00373 valStr.Close();
00374 }
00375
00376 void CHttpClient::ResetTimeElapsed()
00377
00378 {
00379 iLastTimeStamp.UniversalTime();
00380 }
00381
00382
00383 void CHttpClient::DisplayTimeElapsed()
00384
00385 {
00386 TTime timeNow;
00387 timeNow.UniversalTime();
00388 TTimeIntervalMicroSeconds elapsedMicroSec =
00389 timeNow.MicroSecondsFrom(iLastTimeStamp);
00390 iLastTimeStamp = timeNow;
00391 iUtils->Test().Printf(
00392 _L("Time elapsed since last measurement is: %d ms\n"),
00393 elapsedMicroSec.Int64()/1000
00394 );
00395 }
00396
00397
00402 TBool CHttpClient::GetCredentialsL(const TUriC8& aURI, RString aRealm,
00403 RStringF aAuthenticationType,
00404 RString& aUsername,
00405 RString& aPassword)
00406
00407 {
00408 TBuf<80> scratch;
00409 TBuf8<80> scratch8;
00410 scratch8.Format(_L8("Enter credentials for URL %S, realm %S"), &aURI.UriDes(), &aRealm.DesC());
00411 scratch.Copy(scratch8);
00412 iUtils->Test().Printf(_L("%S\n"), &scratch);
00413 scratch.Copy(aAuthenticationType.DesC());
00414 iUtils->Test().Printf(_L("Using %S authentication\n"), &scratch);
00415 iUtils->GetAnEntry(_L("Username (or QUIT to give up): "), scratch);
00416 scratch8.Copy(scratch);
00417 if (scratch8.CompareF(_L8("quit")))
00418 {
00419 TRAPD(err, aUsername = aRealm.Pool().OpenStringL(scratch8));
00420 if (!err)
00421 {
00422 iUtils->GetAnEntry(_L("Password: "), scratch);
00423 scratch8.Copy(scratch);
00424 TRAP(err, aPassword = aRealm.Pool().OpenStringL(scratch8));
00425 if (!err)
00426 return ETrue;
00427 }
00428 }
00429 return EFalse;
00430 }
00431
00432
00433
00434
00435
00436
00437 void CHttpEventHandler::ConstructL()
00438 {
00439 User::LeaveIfError(iFileServ.Connect());
00440 }
00441
00442
00443 CHttpEventHandler::CHttpEventHandler(CHttpExampleUtils& aUtils) :
00444 iUtils(aUtils)
00445 {
00446 }
00447
00448
00449 CHttpEventHandler::~CHttpEventHandler()
00450 {
00451 iFileServ.Close();
00452 }
00453
00454
00455 CHttpEventHandler* CHttpEventHandler::NewLC(CHttpExampleUtils& aUtils)
00456 {
00457 CHttpEventHandler* me = new(ELeave)CHttpEventHandler(aUtils);
00458 CleanupStack::PushL(me);
00459 me->ConstructL();
00460 return me;
00461 }
00462
00463
00464 CHttpEventHandler* CHttpEventHandler::NewL(CHttpExampleUtils& aUtils)
00465 {
00466 CHttpEventHandler* me = NewLC(aUtils);
00467 CleanupStack::Pop(me);
00468 return me;
00469 }
00470
00471
00472 void CHttpEventHandler::SetVerbose(TBool aVerbose)
00473 {
00474 iVerbose = aVerbose;
00475 }
00476
00477
00478 TBool CHttpEventHandler::Verbose() const
00479 {
00480 return iVerbose;
00481 }
00482
00483
00484 void CHttpEventHandler::MHFRunL(RHTTPTransaction aTransaction, const THTTPEvent& aEvent)
00485 {
00486 switch (aEvent.iStatus)
00487 {
00488 case THTTPEvent::EGotResponseHeaders:
00489 {
00490
00491
00492 RHTTPResponse resp = aTransaction.Response();
00493 TInt status = resp.StatusCode();
00494 RStringF statusStr = resp.StatusText();
00495 TBuf<32> statusStr16;
00496 statusStr16.Copy(statusStr.DesC());
00497 iUtils.Test().Printf(_L("Status: %d (%S)\n"), status, &statusStr16);
00498
00499
00500 if (iVerbose)
00501 DumpRespHeadersL(aTransaction);
00502
00503
00504 iSavingResponseBody = EFalse;
00505 TBool cancelling = EFalse;
00506 if (resp.HasBody() && (status >= 200) && (status < 300) && (status != 204))
00507 {
00508 TInt dataSize = resp.Body()->OverallDataSize();
00509 if (dataSize >= 0)
00510 iUtils.Test().Printf(_L("Response body size is %d\n"), dataSize);
00511 else
00512 iUtils.Test().Printf(_L("Response body size is unknown\n"));
00513
00514 TInt selection = iUtils.GetSelection(_L("\n> Save response to disk? Yes | No | Cancel"), _L("YyNnCc"));
00515 iSavingResponseBody = (selection < 2);
00516 cancelling = (selection == 4) || (selection == 5);
00517 }
00518
00519
00520 if (cancelling)
00521 {
00522 iUtils.Test().Printf(_L("\nTransaction Cancelled\n"));
00523 aTransaction.Close();
00524 CActiveScheduler::Stop();
00525 }
00526 else if (iSavingResponseBody)
00527 {
00528 iUtils.GetAnEntry(_L("Enter filename including path to save response body"), iRespBodyFileName);
00529 iParsedFileName.Set(KFileSystemRoot,&iRespBodyFileName,NULL);
00530
00531
00532 TInt valid = iFileServ.IsValidName(iRespBodyFileName);
00533 if (!valid)
00534 {
00535 iUtils.Test().Printf(_L("The specified filename is not valid!.\n"));
00536 iSavingResponseBody = EFalse;
00537 }
00538 else
00539 {
00540 TInt err = iRespBodyFile.Replace(iFileServ,
00541 iParsedFileName.FullName(),
00542 EFileWrite|EFileShareExclusive);
00543 if (err)
00544 {
00545 iSavingResponseBody = EFalse;
00546 User::Leave(err);
00547 }
00548 }
00549 }
00550
00551 } break;
00552 case THTTPEvent::EGotResponseBodyData:
00553 {
00554
00555 iRespBody = aTransaction.Response().Body();
00556
00557
00558 if (iVerbose)
00559 DumpRespBody(aTransaction);
00560 else
00561 iUtils.Test().Printf(_L("*"));
00562
00563
00564 if (iSavingResponseBody)
00565 {
00566 TPtrC8 bodyData;
00567 TBool lastChunk = iRespBody->GetNextDataPart(bodyData);
00568 iRespBodyFile.Write(bodyData);
00569 if (lastChunk)
00570 iRespBodyFile.Close();
00571 }
00572
00573
00574 iRespBody->ReleaseData();
00575 } break;
00576 case THTTPEvent::EResponseComplete:
00577 {
00578
00579 iUtils.Test().Printf(_L("\nTransaction Complete\n"));
00580 } break;
00581 case THTTPEvent::ESucceeded:
00582 {
00583 iUtils.Test().Printf(_L("Transaction Successful\n"));
00584 aTransaction.Close();
00585 CActiveScheduler::Stop();
00586 } break;
00587 case THTTPEvent::EFailed:
00588 {
00589 iUtils.Test().Printf(_L("Transaction Failed\n"));
00590 aTransaction.Close();
00591 CActiveScheduler::Stop();
00592 } break;
00593 case THTTPEvent::ERedirectedPermanently:
00594 {
00595 iUtils.Test().Printf(_L("Permanent Redirection\n"));
00596 } break;
00597 case THTTPEvent::ERedirectedTemporarily:
00598 {
00599 iUtils.Test().Printf(_L("Temporary Redirection\n"));
00600 } break;
00601 default:
00602 {
00603 iUtils.Test().Printf(_L("<unrecognised event: %d>\n"), aEvent.iStatus);
00604
00605 if (aEvent.iStatus < 0)
00606 {
00607 aTransaction.Close();
00608 CActiveScheduler::Stop();
00609 }
00610 } break;
00611 }
00612 }
00613
00614 TInt CHttpEventHandler::MHFRunError(TInt aError, RHTTPTransaction , const THTTPEvent& )
00615 {
00616 iUtils.Test().Printf(_L("MHFRunError fired with error code %d\n"), aError);
00617
00618 return KErrNone;
00619 }
00620
00621
00622 void CHttpEventHandler::DumpRespHeadersL(RHTTPTransaction& aTrans)
00623 {
00624 RHTTPResponse resp = aTrans.Response();
00625 RStringPool strP = aTrans.Session().StringPool();
00626 RHTTPHeaders hdr = resp.GetHeaderCollection();
00627 THTTPHdrFieldIter it = hdr.Fields();
00628
00629 TBuf<KMaxHeaderNameLen> fieldName16;
00630 TBuf<KMaxHeaderValueLen> fieldVal16;
00631
00632 while (it.AtEnd() == EFalse)
00633 {
00634 RStringTokenF fieldName = it();
00635 RStringF fieldNameStr = strP.StringF(fieldName);
00636 THTTPHdrVal fieldVal;
00637 if (hdr.GetField(fieldNameStr,0,fieldVal) == KErrNone)
00638 {
00639 const TDesC8& fieldNameDesC = fieldNameStr.DesC();
00640 fieldName16.Copy(fieldNameDesC.Left(KMaxHeaderNameLen));
00641 switch (fieldVal.Type())
00642 {
00643 case THTTPHdrVal::KTIntVal:
00644 iUtils.Test().Printf(_L("%S: %d\n"), &fieldName16, fieldVal.Int());
00645 break;
00646 case THTTPHdrVal::KStrFVal:
00647 {
00648 RStringF fieldValStr = strP.StringF(fieldVal.StrF());
00649 const TDesC8& fieldValDesC = fieldValStr.DesC();
00650 fieldVal16.Copy(fieldValDesC.Left(KMaxHeaderValueLen));
00651 iUtils.Test().Printf(_L("%S: %S\n"), &fieldName16, &fieldVal16);
00652 }
00653 break;
00654 case THTTPHdrVal::KStrVal:
00655 {
00656 RString fieldValStr = strP.String(fieldVal.Str());
00657 const TDesC8& fieldValDesC = fieldValStr.DesC();
00658 fieldVal16.Copy(fieldValDesC.Left(KMaxHeaderValueLen));
00659 iUtils.Test().Printf(_L("%S: %S\n"), &fieldName16, &fieldVal16);
00660 }
00661 break;
00662 case THTTPHdrVal::KDateVal:
00663 {
00664 TDateTime date = fieldVal.DateTime();
00665 TBuf<40> dateTimeString;
00666 TTime t(date);
00667 t.FormatL(dateTimeString,KDateFormat);
00668
00669 iUtils.Test().Printf(_L("%S: %S\n"), &fieldName16, &dateTimeString);
00670 }
00671 break;
00672 default:
00673 iUtils.Test().Printf(_L("%S: <unrecognised value type>\n"), &fieldName16);
00674 break;
00675 }
00676
00677
00678 RStringF wwwAuth = strP.StringF(HTTP::EWWWAuthenticate,RHTTPSession::GetTable());
00679 if (fieldNameStr == wwwAuth)
00680 {
00681
00682 RStringF basic = strP.StringF(HTTP::EBasic,RHTTPSession::GetTable());
00683 RStringF realm = strP.StringF(HTTP::ERealm,RHTTPSession::GetTable());
00684 THTTPHdrVal realmVal;
00685 if ((fieldVal.StrF() == basic) &&
00686 (!hdr.GetParam(wwwAuth, realm, realmVal)))
00687 {
00688 RStringF realmValStr = strP.StringF(realmVal.StrF());
00689 fieldVal16.Copy(realmValStr.DesC());
00690 iUtils.Test().Printf(_L("Realm is: %S\n"), &fieldVal16);
00691 }
00692 }
00693 }
00694 ++it;
00695 }
00696 }
00697
00698 void CHttpEventHandler::DumpRespBody(RHTTPTransaction& aTrans)
00699 {
00700 MHTTPDataSupplier* body = aTrans.Response().Body();
00701 TPtrC8 dataChunk;
00702 TBool isLast = body->GetNextDataPart(dataChunk);
00703 DumpIt(dataChunk);
00704 if (isLast)
00705 iUtils.Test().Printf(_L("Got last data chunk.\n"));
00706 }
00707
00708
00709 void CHttpEventHandler::DumpIt(const TDesC8& aData)
00710
00711 {
00712
00713 const TInt cols=16;
00714 TInt pos = 0;
00715 TBuf<KMaxFileName - 2> logLine;
00716 TBuf<KMaxFileName - 2> anEntry;
00717 const TInt dataLength = aData.Length();
00718 while (pos < dataLength)
00719 {
00720
00721 anEntry.Format(TRefByValue<const TDesC>_L("%04x : "), pos);
00722 logLine.Append(anEntry);
00723
00724
00725 TInt offset;
00726 for (offset = 0; offset < cols; ++offset)
00727 {
00728 if (pos + offset < aData.Length())
00729 {
00730 TInt nextByte = aData[pos + offset];
00731 anEntry.Format(TRefByValue<const TDesC>_L("%02x "), nextByte);
00732 logLine.Append(anEntry);
00733 }
00734 else
00735 {
00736
00737 anEntry.Format(TRefByValue<const TDesC>_L(" "));
00738 logLine.Append(anEntry);
00739 }
00740 }
00741 anEntry.Format(TRefByValue<const TDesC>_L(": "));
00742 logLine.Append(anEntry);
00743
00744
00745 for (offset = 0; offset < cols; ++offset)
00746 {
00747 if (pos + offset < aData.Length())
00748 {
00749 TInt nextByte = aData[pos + offset];
00750 if ((nextByte >= ' ') && (nextByte <= '~'))
00751 {
00752 anEntry.Format(TRefByValue<const TDesC>_L("%c"), nextByte);
00753 logLine.Append(anEntry);
00754 }
00755 else
00756 {
00757 anEntry.Format(TRefByValue<const TDesC>_L("."));
00758 logLine.Append(anEntry);
00759 }
00760 }
00761 else
00762 {
00763 anEntry.Format(TRefByValue<const TDesC>_L(" "));
00764 logLine.Append(anEntry);
00765 }
00766 }
00767 iUtils.Test().Printf(TRefByValue<const TDesC>_L("%S\n"), &logLine);
00768 logLine.Zero();
00769
00770
00771 pos += cols;
00772 }
00773 }
00774
00775
00776
00777
00778
00779
00780 LOCAL_D void TestL()
00781
00782 {
00783
00784
00785 CHttpExampleUtils::InitCommsL();
00786
00787
00788 CActiveScheduler* scheduler = new(ELeave) CActiveScheduler();
00789 CleanupStack::PushL(scheduler);
00790 CActiveScheduler::Install(scheduler);
00791
00792
00793 CHttpClient* httpCli = CHttpClient::NewLC();
00794 httpCli->StartClientL();
00795
00796 CleanupStack::PopAndDestroy(2);
00797 }
00798
00799
00800 GLDEF_C TInt E32Main()
00801
00802
00803 {
00804 __UHEAP_MARK;
00805 CTrapCleanup* tc=CTrapCleanup::New();
00806
00807 TRAPD(err,TestL());
00808 if (err!=KErrNone)
00809 User::Panic(_L("Test failed with error code: %i"), err);
00810 delete tc;
00811 __UHEAP_MARKEND;
00812 return KErrNone;
00813 }
00814
00815
00816