// ---------------------------------------------------------------------------------------- // CFMSServer::WriteToFile() // ---------------------------------------------------------------------------------------- void CFMSServer::WriteToFile(TInt aReason, TInt aBearer,TDriveNumber aDrive, TInt aSize, TBool aWcdmaBearer ) { if(iSessionCount == 0) { FLOG(_L("CFMSServer::WriteToFile- begin")); TInt err=iFile.Open(iFs,KFotaInterruptFileName,EFileWrite); if(err == KErrNone) { FLOG(_L("CFMSServer::WriteToFile--passed")); TBuf8<30> data;//size 30 or 32--as args is 16 bytes TBuf8<30> temp; temp.Num(aReason); data.Append(temp); data.Append(','); temp.Num(aBearer);// or use iFMSinterruptAob's iBearer data.Append(temp); data.Append(','); temp.Num((TInt)aDrive); data.Append(temp); data.Append(','); temp.Num(aSize); data.Append(temp); data.Append(','); temp.Num(aWcdmaBearer); data.Append(temp); iFile.Write(data); iFile.Close(); } else FLOG(_L("CFMSServer::WriteToFile- Failed")); } else FLOG(_L("CFMSServer::WriteToFile- not done as another request is there")); }
// --------------------------------------------------------------------------------- // CUpnpTmFilteredAppList::IconLookUp // Performs the icon look up // Checks if the requested icon and given icon matches // @param aIcon Reference to the Terminal Mode Icon object // @return Returns boolean value(true or false) // --------------------------------------------------------------------------------- // TBool CUpnpTmFilteredAppList::IconLookUp( CUpnpTerminalModeIcon& aIcon ) { OstTraceFunctionEntry0( CUPNPTMFILTEREDAPPLIST_ICONLOOKUP_ENTRY ); TBool matchFound(EFalse); const TDesC8& filterMimeType = iFilterInfo->MimeType(); const TDesC8& filterWidth = iFilterInfo->Width(); const TDesC8& filterHeight = iFilterInfo->Height(); const TDesC8& filterDepth = iFilterInfo->Depth(); // Check whether the icon is meant to be used only at launch time TBuf8<UpnpString::KShortStringLength> widthBuf; widthBuf.Num(aIcon.Width()); TBuf8<UpnpString::KShortStringLength> heightBuf; heightBuf.Num(aIcon.Height()); TBuf8<UpnpString::KShortStringLength> depthBuf; depthBuf.Num(aIcon.Depth()); /* Check if the icon in provided in the input filter string, and if so then does it match with the desired icon ( type and dimension ) */ if ( (( filterMimeType.Length() == 0 ) ||( (aIcon.MimeType()).MatchC(filterMimeType) != KErrNotFound)) && (( filterWidth.Length() == 0 ) ||( widthBuf.MatchC(filterWidth) != KErrNotFound)) && (( filterHeight.Length() == 0 ) ||( heightBuf.MatchC(filterHeight) != KErrNotFound)) && (( filterDepth.Length() == 0 ) ||( depthBuf.MatchC(filterDepth) != KErrNotFound))) { matchFound = ETrue; } OstTraceFunctionExit0( CUPNPTMFILTEREDAPPLIST_ICONLOOKUP_EXIT ); return matchFound; }
TInt CEventLogger::UpdateLogEventParam(CLogEvent& aLogEvent, TInt aRConnectionStatusId, const TUid& aDataEventType, const TInt64& aBytesSent, const TInt64& aBytesReceived) { TTime time; TInt ret =KErrNone; time.UniversalTime(); TTimeIntervalSeconds interval(0); if (time.SecondsFrom(iCurrentLogEvent->Time(),interval) != KErrNone) { interval = 0; // no duration available ->error } if (KConnectionStatusIdNotAvailable != aRConnectionStatusId) { //status needs to be updated TBuf<KLogMaxStatusLength > logStatusBuf; iLogWrap->Log().GetString(logStatusBuf, aRConnectionStatusId); // Ignore error - string blank on error which is ok aLogEvent.SetStatus(logStatusBuf); } if ( aDataEventType != TUid::Null()) { aLogEvent.SetEventType(aDataEventType); } aLogEvent.SetDuration(interval.Int()); //0 or not //check if data metrics need to be updated TInt64 byteInfoNotAvailable(KBytesInfoNotAvailable); if ((aBytesReceived != byteInfoNotAvailable) && (aBytesSent != byteInfoNotAvailable)) { TBuf8<KDatabufferSize> dataBuffer; dataBuffer.Num(aBytesSent); dataBuffer.Append(TChar(',')); dataBuffer.AppendNum(aBytesReceived); TRAP(ret, aLogEvent.SetDataL(dataBuffer)); } return ret; }
TInt CSenLayeredXmlProperties::SetIntPropertyL(const TDesC8& aName, const TInt aValue) { TBuf8<KFlatBufSize> buffer; buffer.Num(aValue); return SetPropertyL(aName, buffer); }
// ----------------------------------------------------------------------------- // CNSmlDmDevDetailAdapter::FetchLeafObjectSizeL( const TDesC8& aURI, // const TDesC8& aLUID, const TDesC8& aType, const TInt aResultsRef, // const TInt aStatusRef ) // ----------------------------------------------------------------------------- void CNSmlDmDevDetailAdapter::FetchLeafObjectSizeL( const TDesC8& aURI, const TDesC8& /*aLUID*/, const TDesC8& aType, const TInt aResultsRef, const TInt aStatusRef ) { _DBG_FILE("CNSmlDmDevDetailAdapter::FetchLeafObjectSizeL(): begin"); CBufBase *object = CBufFlat::NewL( 1 ); CleanupStack::PushL( object ); CSmlDmAdapter::TError retValue = FetchLeafObjectL( aURI, *object ); TInt objSizeInBytes = object->Size(); TBuf8<KNSmlMaxSizeBufferLength> stringObjSizeInBytes; stringObjSizeInBytes.Num( objSizeInBytes ); object->Reset(); object->InsertL( 0, stringObjSizeInBytes ); iDmCallback->SetStatusL( aStatusRef, retValue ); iDmCallback->SetResultsL( aResultsRef, *object, aType); CleanupStack::PopAndDestroy(); //object _DBG_FILE("CNSmlDmDevDetailAdapter::FetchLeafObjectSizeL(): end"); }
void CSTPreferences::SaveSettingL(RFile& aFile, const TDesC8& aSettingName, const TDesC& aSettingValue) { aFile.Write(aSettingName); aFile.Write(KLit8Colon); HBufC8* encodedSettingValue = ConvertToUtf8L(aSettingValue); if (encodedSettingValue) { CleanupStack::PushL(encodedSettingValue); TBuf8<16> settingLength; settingLength.Num(encodedSettingValue->Length()); aFile.Write(settingLength); aFile.Write(KLit8EqualSign); aFile.Write(*encodedSettingValue); CleanupStack::PopAndDestroy(); // encodedSettingValue } else { _LIT8(KLit8Unset, "0="); aFile.Write(KLit8Unset); } aFile.Write(KLit8EndLine); }
void CRightsCriteriaCount::WriteDescription(RFile& aFile) { TBuf8 <10> count; count.Num(iCount); aFile.Write(_L8("Count = ")); aFile.Write(count); aFile.Write(_L8("\r\n")); }
// ----------------------------------------------------------------------------- // CSIPParamContainerBase::SetParamL // ----------------------------------------------------------------------------- // void CSIPParamContainerBase::SetParamL(RStringF aName, TReal aValue) { TBuf8<KMaxNumericValueAsTextLength> valueAsText; TRealFormat format; const TChar KDotChr = '.'; format.iPoint = KDotChr; // SIP uses always dot as a decimal point User::LeaveIfError(valueAsText.Num(aValue,format)); SetParamL(aName, valueAsText); }
// ----------------------------------------------------------------------------- // CUpnpObjectBean::AttachRefIdL // (other items were commented in a header). // ----------------------------------------------------------------------------- // void CUpnpObjectBean::AttachRefIdL(TXmlEngElement aElement) { if(ObjRefId() != CUpnpObjectBean::KUndef) { TBuf8<KMaxIntegerLen> num; num.Num(ObjRefId()); aElement.AddNewAttributeL( KRefID(), num ); } }
void CHttpController::SendRequestL( TInt aMethodIndex, const TDesC8& aUri, CHttpHeaders* aHeaders ) { if ( !iObserver ) { User::Leave( KErrHttpInvalidObserver ); } RStringF method = iSession.StringPool().StringF( aMethodIndex, RHTTPSession::GetTable() ); TUriParser8 uri; uri.Parse( aUri ); iTransaction = iSession.OpenTransactionL( uri, *this, method ); RHTTPHeaders hdr = iTransaction.Request().GetHeaderCollection(); RArray< TInt > addedElements; CleanupClosePushL( addedElements ); SetHeaderL( HTTP::EUserAgent, hdr, KUserAgent, addedElements ); SetHeaderL( HTTP::EConnection, hdr, KClose, addedElements ); SetHeaderL( HTTP::EAccept, hdr, KAccept, addedElements ); SetHeaderL( HTTP::EHost, hdr, uri.Extract( EUriHost ), addedElements ); TInt count( iPersistentHeaders->Count() ); for ( TInt i( 0 ); i < count; ++i ) { if ( addedElements.FindInOrder( i ) >= 0 ) { continue; } SetHeaderL( hdr, iPersistentHeaders->Key( i ), iPersistentHeaders->Value( i ) ); } CleanupStack::PopAndDestroy( &addedElements ); if ( aHeaders ) { TInt count( aHeaders->Count() ); for ( TInt i( 0 ); i < count; ++i ) { SetHeaderL( hdr, aHeaders->Key( i ), aHeaders->Value( i ) ); } } if ( aMethodIndex == HTTP::EPOST ) { const TInt KMaxContentLenBufferLength = 100; TBuf8< KMaxContentLenBufferLength > contentLength; contentLength.Num( iOutputEncoder->OverallDataSize() ); SetHeaderL( hdr, HTTP::EContentLength, contentLength ); SetHeaderL( hdr, HTTP::EContentType, KUrlEncodedContentType ); iTransaction.Request().SetBody( *iOutputEncoder ); } iTransaction.SubmitL(); StartTimeout(); iState = EHttpActive; }
HBufC8* CPolicyPatcher::CreatePatchDataL(const CPolicyPatchInfo* aPatchInfo) { TInt patchDataLength = 0; TBuf8<20> keyBuf; const TDesC8& certSubjectName = aPatchInfo->CertSubjectName(); if (0 == aPatchInfo->UserCertKeyLen()) { // CA cert patch patchDataLength = KName().Length() + KNewLine().Length() + KDataField().Length() + KSpace().Length() + certSubjectName.Length(); } else { // user cert patch keyBuf.Num(aPatchInfo->UserCertKeyLen()); patchDataLength = KDNField().Length() + certSubjectName.Length() + KNewLine().Length() + KKeyLenField().Length() + keyBuf.Length(); } HBufC8* patchData = HBufC8::NewL(patchDataLength); CleanupStack::PushL(patchData); TPtr8 ptrPatchData(patchData->Des()); if (0 == aPatchInfo->UserCertKeyLen()) { // CA cert patch ptrPatchData.Append(KName); ptrPatchData.Append(KNewLine); ptrPatchData.Append(KDataField); ptrPatchData.Append(KSpace); ptrPatchData.Append(certSubjectName); } else { // User cert patch ptrPatchData.Append(KKeyLenField); ptrPatchData.Append(keyBuf); ptrPatchData.Append(KNewLine); ptrPatchData.Append(KDNField); ptrPatchData.Append(certSubjectName); iUserCertPatched = ETrue; } CleanupStack::Pop(); // patchData return patchData; }
void CSetDRMProtectedTestDevice::DoWriteToFileL(TBool aFlag) { RFs fs; CleanupClosePushL(fs); User::LeaveIfError(fs.Connect()); RFile file; CleanupClosePushL(file); // File doesn't yet exist // It is the responsibility of the calling test function to delete the file after use User::LeaveIfError(file.Create(fs, KCITestFileName, EFileWrite)); TBuf8<KMaxCITestFileDataLength> outputBuf; outputBuf.Num(aFlag); User::LeaveIfError(file.Write(outputBuf)); CleanupStack::PopAndDestroy(2); // fs, file }
// --------------------------------------------------------------------------------- // CUpnpTmClientProfileService::GetMaxNumProfilesActionL // @param aAction pointer to action object // @return Returns upnp error code // --------------------------------------------------------------------------------- // TUpnpErrorCode CUpnpTmClientProfileService::GetMaxNumProfilesActionL( CUpnpAction* aAction ) { OstTraceFunctionEntry0( CUPNPTMCLIENTPROFILESERVICE_GETMAXNUMPROFILESACTIONL_ENTRY ); TUint profileCount; TTerminalModeErrorCode ret = iTmServerImpl.GetMaxNumProfiles( profileCount ); if ( ret != ETerminalModeSuccess ) { OstTrace0( TRACE_ERROR, DUP1_CUPNPTMCLIENTPROFILESERVICE_GETMAXNUMPROFILESACTIONL, "CUpnpTmClientProfileService::GetMaxNumProfilesActionL" ); return TUpnpErrorCode( ret ); } OstTrace1( TRACE_NORMAL, CUPNPTMCLIENTPROFILESERVICE_GETMAXNUMPROFILESACTIONL, "CUpnpTmClientProfileService::GetMaxNumProfilesActionL;profileCount=%d", profileCount ); TBuf8<UpnpString::KMaxTUintLength> countBuf; countBuf.Num(profileCount); aAction->SetArgumentL( KNumProfilesAllowed, countBuf ); OstTraceFunctionExit0( CUPNPTMCLIENTPROFILESERVICE_GETMAXNUMPROFILESACTIONL_EXIT ); return EHttpOk; }
EXPORT_C void CSenBaseIdentityManager::UpdateTouchIdentityDBL(MSenServiceDescription& asd) { CSenIdentityProvider* Idp = NULL; Idp = iIdentity->IdentityProviderL(asd); if(Idp != NULL) { TUint32 current_tick(0); TBuf8<32> tickBuf; CSenElement& IdpElem = Idp->AsElement(); current_tick = User::NTickCount(); tickBuf.Num(current_tick); IdpElem.AddAttrL(KTouch(), tickBuf); } // CleanupUnusedIdentityDBL(); // (don't de-serialize old items). Serialized // objects cannot be de-allocated on the fly. }
// create a custom interface Mux implementation MMMFDevSoundCustomInterfaceMuxPlugin* CMMFDevSoundCIMuxUtility::CreateCustomInterfaceMuxL(TUid aInterfaceId) { // The Uid of the plugin will be used as string for matching the best suitable plug in. TInt uidAsInteger = aInterfaceId.iUid; TBuf8<KMuxTempBufferSize> tempBuffer; tempBuffer.Num(uidAsInteger, EHex); TUid interfaceUid = {KUidDevSoundCustomInterfaceMux}; TUid destructorKey; MMMFDevSoundCustomInterfaceMuxPlugin* self = static_cast<MMMFDevSoundCustomInterfaceMuxPlugin*> (MmPluginUtils::CreateImplementationL(interfaceUid, destructorKey, tempBuffer, KRomOnlyResolverUid)); // pass the destructor key so class can destroy itself self->PassDestructorKey(destructorKey); CleanupReleasePushL(*self); // attempt to construct the plugin self->CompleteConstructL(this); CleanupStack::Pop(); // self return self; }
// ---------------------------------------------------------------------------------------- // CTerminalControlServer::GetProcessDataL // ---------------------------------------------------------------------------------------- CBufFlat* CTerminalControlServer::GetProcessDataL( const TDesC8 &aProcessName, TDesC8 &aDataName ) { RDEBUG("CTerminalControlServer::GetProcessDataL"); _LIT8(KProcessDataFormat, "\ <process-information name=\"%S\">\r\n\ \t<process-data name=\"%S\" value=\"%S\"/>\r\n\ </process-information>\r\n\ "); TTcProcessInfo info = FindLocalProcessInfoL( aProcessName ); CBufFlat* processData; processData = 0; processData = CBufFlat::NewL(128); CleanupStack::PushL( processData ); // Set process data if(aDataName == _L8("ID")) { TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> numBuf; numBuf.Num((TUint)info.iId); processData->InsertL(0, numBuf); } else if(aDataName == _L8("FromRAM")) { TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> numBuf; numBuf.Num((TUint)!info.iCodeInRom); processData->InsertL(0, numBuf); } else if(aDataName == _L8("MemoryInfo")) { TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> valueBuf; valueBuf.Num((TUint)info.iMemoryInfo.iCodeSize+ info.iMemoryInfo.iConstDataSize+ info.iMemoryInfo.iInitialisedDataSize+ info.iMemoryInfo.iUninitialisedDataSize); TInt responseLength = KProcessDataFormat().Length() + aProcessName.Length() + aDataName.Length() + valueBuf.Length(); HBufC8* buffer = HBufC8::NewLC( responseLength ); buffer->Des().Format( KProcessDataFormat, &aProcessName, &aDataName, &valueBuf ); processData->InsertL(0, *buffer); CleanupStack::PopAndDestroy( buffer ); } else if(aDataName == _L8("Filename")) { TBuf8<sizeof(TFileName)> fname; fname.Copy(info.iFileName); processData->InsertL(0, fname); } else { User::Leave( KErrNotFound ); } CleanupStack::Pop( processData ); return processData; }
// --------------------------------------------------------- // CNSmlCmdsBase::DoSyncHdrL // Makes SyncHdr element and calls parser to generate xml // --------------------------------------------------------- EXPORT_C void CNSmlCmdsBase::DoSyncHdrL() { // create generator instance first if ( !iGenerator ) { iGenerator = new( ELeave ) CWBXMLSyncMLGenerator( iVersionPublicId ); } // create workspace iGenerator->CreateWorkspaceL( iWorkspaceSize ); //initialise SyncHdr SmlSyncHdr_t* syncHdr = new( ELeave ) SmlSyncHdr_t; CleanupStack::PushL( syncHdr ); //element type syncHdr->elementType = SML_PE_HEADER; //VerDTD element //1.2 CHANGES: 1.2 and 1.1 version support PcdataNewL ( syncHdr->version, *iVerDTD ); //changes end //VerProto element PcdataNewL ( syncHdr->proto, *iVerProto ); //sessionID element PcdataNewL ( syncHdr->sessionID, *iSessionID ); //msgID element TBuf8<16> stringMsgID; stringMsgID.Num( ++iCurrMsgID ); PcdataNewL( syncHdr->msgID, stringMsgID ); //Target element delete iSentSyncHdrTarget; iSentSyncHdrTarget = NULL; if ( iRespURI ) { // Target changes if a server has issued RespURI in previous message DoTargetL( syncHdr->target, iRespURI->HostName() ); iSentSyncHdrTarget = CNSmlURI::NewL( iRespURI->HostName() ); } else { DoTargetL( syncHdr->target, iSyncServer->HostName() ); iSentSyncHdrTarget = CNSmlURI::NewL( iSyncServer->HostName() ); } //Source element HBufC* imeiCode = HBufC::NewLC( 50 ); TPtr imeiCodePtr = imeiCode->Des(); iPhoneInfo->PhoneDataL( CNSmlPhoneInfo::EPhoneSerialNumber, imeiCodePtr ); CNSmlAgentBase::TAuthenticationType authType; authType = iAgent->AuthTypeL(); if ( ( !iAlreadyAuthenticated ) && ( authType == CNSmlAgentBase::EMD5 ) ) { DoSourceL( syncHdr->source, imeiCodePtr, *iSyncMLUserName); } else { DoSourceL( syncHdr->source, imeiCodePtr ); } delete iSentSyncHdrSource; iSentSyncHdrSource = NULL; iSentSyncHdrSource = CNSmlURI::NewL( *imeiCode ); CleanupStack::PopAndDestroy(); //imeiCode // Cred element if ( authType == CNSmlAgentBase::ENoAuth || iAgent->AlreadyAuthenticated() ) { syncHdr->cred = NULL; } else { syncHdr->cred = new( ELeave ) SmlCred_t; SmlMetInfMetInf_t* metInf; DoMetInfLC( metInf ); if ( authType == CNSmlAgentBase::EMD5 ) { PcdataNewL( metInf->type, KNSmlAgentAuthMD5 ); PcdataNewL( metInf->format, KNSmlAgentBase64Format ); } else // Basic { PcdataNewL( metInf->type, KNSmlAgentAuthBasic ); } DoMetaL( syncHdr->cred->meta, metInf ); CleanupStack::Pop(); //metInf HBufC8* credential; if ( authType == CNSmlAgentBase::EMD5 ) { credential = iAgent->Md5CredentialL(); } else // Basic { credential = iAgent->BasicCredentialL(); } CleanupStack::PushL( credential ); PcdataNewL ( syncHdr->cred->data, *credential ); CleanupStack::PopAndDestroy(); //credential } // MaxMsgSize SmlMetInfMetInf_t* maxMsgMetInf; DoMetInfLC( maxMsgMetInf ); TBuf<16> maxMsgSize; maxMsgSize.Num( iWorkspaceSize ); HBufC8* maxMsgSizeInUTF8 = NULL; NSmlUnicodeConverter::HBufC8InUTF8LC( maxMsgSize, maxMsgSizeInUTF8 ); PcdataNewL( maxMsgMetInf->maxmsgsize, *maxMsgSizeInUTF8 ); CleanupStack::PopAndDestroy(); //maxMsgSizeInUTF8 if ( iSynchHdrMaxObjSize > 0 ) { DoMaxObjSizeL( *maxMsgMetInf, iSynchHdrMaxObjSize ); } DoMetaL( syncHdr->meta, maxMsgMetInf ); CleanupStack::Pop(); //maxMsgMetInf TInt ret; ret = iGenerator->smlStartMessage( syncHdr ); if ( ret != KWBXMLGeneratorOk ) { User::Leave( ret ); } CleanupStack::PopAndDestroy(); //syncHdr iCurrCmdID = 0; //save Status response information for response status controlling CreateAndInitResponseItemL( KNSmlAgentSyncHdr ); }
void CSTTrackerConnection::CreateUriL() { TInetAddr localAddress; TInt getAddressRes = KErrGeneral; // only send IP if we are connected via proxy //if (Preferences()->IncomingConnectionsMode() == EEnabledWithProxy) // getAddressRes = iNetMgr->Address(localAddress); CBufFlat* uriBuf = CBufFlat::NewL(512); CleanupStack::PushL(uriBuf); //TPtrC8 activeTracker = iTorrent.AnnounceList()->ActiveAddress(); //LWRITE(iLog, _L("Active tracker: ")); //LWRITELN(iLog, activeTracker); uriBuf->InsertL(uriBuf->Size(), *iAddress); uriBuf->InsertL(uriBuf->Size(), _L8("?")); uriBuf->InsertL(uriBuf->Size(), _L8("info_hash=")); HBufC8* encoded = EscapeUtils::EscapeEncodeL(iTorrent.InfoHash(), EscapeUtils::EEscapeUrlEncoded); CleanupStack::PushL(encoded); uriBuf->InsertL(uriBuf->Size(), *encoded); CleanupStack::PopAndDestroy(); // encoded uriBuf->InsertL(uriBuf->Size(), _L8("&peer_id=")); encoded = EscapeUtils::EscapeEncodeL(TorrentMgr()->PeerId(), EscapeUtils::EEscapeUrlEncoded); CleanupStack::PushL(encoded); uriBuf->InsertL(uriBuf->Size(), *encoded); CleanupStack::PopAndDestroy(); // encoded uriBuf->InsertL(uriBuf->Size(), _L8("&key=")); TBuf8<32> keyBuf; keyBuf.Num(TorrentMgr()->Key()); uriBuf->InsertL(uriBuf->Size(), keyBuf); uriBuf->InsertL(uriBuf->Size(), _L8("&port=")); TBuf8<32> portBuf; if (getAddressRes == KErrNone) portBuf.Num(localAddress.Port()); else portBuf.Num(Preferences()->IncomingPort()); uriBuf->InsertL(uriBuf->Size(), portBuf); uriBuf->InsertL(uriBuf->Size(), _L8("&uploaded=")); TBuf8<24> bytesUploaded; bytesUploaded.Num(iTorrent.BytesUploaded()); uriBuf->InsertL(uriBuf->Size(), bytesUploaded); uriBuf->InsertL(uriBuf->Size(), _L8("&downloaded=")); TBuf8<24> bytesDownloaded; bytesDownloaded.Num(iTorrent.BytesDownloaded()); uriBuf->InsertL(uriBuf->Size(), bytesDownloaded); uriBuf->InsertL(uriBuf->Size(), _L8("&left=")); TBuf8<24> bytesLeft; bytesLeft.Num(iTorrent.BytesLeft()); uriBuf->InsertL(uriBuf->Size(), bytesLeft); // it seems that some trackers support only compact responses uriBuf->InsertL(uriBuf->Size(), _L8("&compact=1")); if (iEvent != ETrackerEventNotSpecified) { uriBuf->InsertL(uriBuf->Size(), _L8("&event=")); switch (iEvent) { case ETrackerEventStarted: uriBuf->InsertL(uriBuf->Size(), _L8("started")); break; case ETrackerEventStopped: uriBuf->InsertL(uriBuf->Size(), _L8("stopped")); break; case ETrackerEventCompleted: uriBuf->InsertL(uriBuf->Size(), _L8("completed")); break; default: break; } } if (getAddressRes == KErrNone) { TBuf<64> ipBuf; localAddress.Output(ipBuf); TBuf8<64> ipBuf8; ipBuf8.Copy(ipBuf); uriBuf->InsertL(uriBuf->Size(), _L8("&ip=")); uriBuf->InsertL(uriBuf->Size(), ipBuf8); #ifdef LOG_TO_FILE // debug info LWRITE(iLog, _L("Sent to tracker: ")); LWRITE(iLog, ipBuf); TBuf8<32> portBuf; portBuf.Num(localAddress.Port()); LWRITE(iLog, _L(":")); LWRITELN(iLog, portBuf); #endif // } iUri = uriBuf->Ptr(0).AllocL(); CleanupStack::PopAndDestroy(); // uriBuf //iLog->WriteL(_L("[Trackerconnection] GET ")); //iLog->WriteLineL(*iUri); }
void CWspHeaderReader::DecodeWellKnownParamTokenL(TWspPrimitiveDecoder& aDecoder, TInt& aBytesRead, TPtrC8& aRawParamBlock, CHeaderFieldPart& aHeaderFieldPart) const { TInt err = 0; TUint32 parameterToken = 0; aBytesRead = aDecoder.Integer(parameterToken); THTTPHdrVal paramValue; RStringF paramDesValue; CleanupClosePushL(paramDesValue); RStringF paramName = iStrPool.StringF(parameterToken, WSPParam::Table); switch( parameterToken ) { case WSPParam::EQ: { // Decode Q value TUint32 qIntValue = 0; err = aDecoder.UintVar(qIntValue); User::LeaveIfError(err); aBytesRead += err; TReal q; TInt numDecimals = 0; TBuf8<KMaxNumQDigits> qDesC; if( qIntValue > 100 ) { // Value is -100 and then divide by 1000 qIntValue -= 100; q = ((TReal)(qIntValue/1000.)); numDecimals = 3; } else { // Value is -1 and then divide by 100 --qIntValue; if( qIntValue%10 ==0 ) numDecimals = 1; else numDecimals = 2; q = ((TReal)(qIntValue/100.)); } TRealFormat realFt(KMaxNumQDigits,numDecimals); // set max width and 3 decimal places // always use a decimal separator rather than the one supplied // by the current locale realFt.iPoint = TChar('.'); qDesC.Num(q, realFt); paramDesValue = iStrPool.OpenFStringL(qDesC); paramValue.SetStrF(paramDesValue); } break; case WSPParam::ECharset: { if( aRawParamBlock[aBytesRead] == 128 ) { paramDesValue = iStrPool.StringF(WSPStdConstants::EAny, WSPStdConstants::Table); paramValue.SetStrF(paramDesValue); // Need to call Integer to update offset in WSP Decoder TUint8 updateDecoder = 0; err = aDecoder.Val7Bit(updateDecoder); User::LeaveIfError(err); aBytesRead += err; } else { switch( aDecoder.VarType() ) { case TWspPrimitiveDecoder::E7BitVal: case TWspPrimitiveDecoder::ELengthVal: { TUint32 value = 0; err = aDecoder.Integer(value); User::LeaveIfError(err); aBytesRead += err; GetCharacterSetFromValueL(value, paramDesValue); paramValue.SetStrF(paramDesValue); } break; default: User::Leave(KErrCorrupt); break; } } } break; case WSPParam::ELevel: { // This is a version value err = aDecoder.VersionL(iStrPool,paramDesValue); User::LeaveIfError(err); aBytesRead += err; paramValue.SetStrF(paramDesValue); } break; case WSPParam::EType: case WSPParam::ESize: case WSPParam::EPadding: case WSPParam::ESEC: case WSPParam::EMaxAge: { TUint32 integerValue = 0; err = aDecoder.Integer(integerValue); User::LeaveIfError(err); aBytesRead += err; paramValue.SetInt(integerValue); } break; case WSPParam::ECreationDate: case WSPParam::EModificationDate: case WSPParam::EReadDate: { TDateTime dateTime(1970, EJanuary, 0, 0, 0, 0, 0); err = aDecoder.Date(dateTime); User::LeaveIfError(err); aBytesRead += err; paramValue.SetDateTime(dateTime); } case WSPParam::ENameDep: case WSPParam::EFilenameDep: case WSPParam::EStartDep: case WSPParam::EStartInfoDep: case WSPParam::ECommentDep: case WSPParam::EDomainDep: case WSPParam::EPathDep: { TPtrC8 textString; err = aDecoder.String(textString); User::LeaveIfError(err); aBytesRead += err; paramDesValue = iStrPool.OpenFStringL(textString); paramValue.SetStrF(paramDesValue); } break; case WSPParam::EMAC: case WSPParam::EName: case WSPParam::EFilename: case WSPParam::EStart: case WSPParam::EStartInfo: case WSPParam::EComment: case WSPParam::EDomain: case WSPParam::EPath: { // Check if the string has <no-value> ie <octet 0> if( aRawParamBlock[aBytesRead] == 0 ) { paramDesValue = iStrPool.OpenFStringL(KNullDesC8()); paramValue.SetStrF(paramDesValue); // Need to call Integer to update offset in WSP Decoder TUint32 updateDecoder = 0; err = aDecoder.Integer(updateDecoder); User::LeaveIfError(err); } else { TPtrC8 textString; err = aDecoder.String(textString); User::LeaveIfError(err); paramDesValue = iStrPool.OpenFStringL(textString); paramValue.SetStrF(paramDesValue); } aBytesRead += err; } break; case WSPParam::EDifferences: { aBytesRead += DecodeGenericParamTokenL(aDecoder, iStrTable, paramValue, paramDesValue); } break; case WSPParam::EContentTypeType: { aBytesRead += DecodeGenericParamTokenL(aDecoder, WSPContentTypes::Table, paramValue, paramDesValue); } break; case WSPParam::ESecure: { // <octet 0> no-value paramDesValue = iStrPool.OpenFStringL(KNullDesC8()); paramValue.SetStrF(paramDesValue); // Need to call Integer to update offset in WSP Decoder TUint32 updateDecoder = 0; err = aDecoder.Integer(updateDecoder); User::LeaveIfError(err); aBytesRead += err; } break; default: User::Leave(KErrCorrupt); break; } // Add the parameter name and value TPtrC8 paramDes(paramName.DesC()); SetNewParamL(aHeaderFieldPart, paramDes, paramValue); CleanupStack::PopAndDestroy(¶mDesValue); }
// // Get all email services // void CEmailNotificationParser::GetEmailServicesL() { CCnvCharacterSetConverter* charconv = CCnvCharacterSetConverter::NewL(); CleanupStack::PushL(charconv); CArrayFix<CCnvCharacterSetConverter::SCharacterSet> *charsetsAvailable = charconv->CreateArrayOfCharacterSetsAvailableL(iFs); CleanupStack::PushL(charsetsAvailable); charconv->PrepareToConvertToOrFromL(KUidCharsetISO88591,*charsetsAvailable,iFs); const TMsvId current = iEntry.Entry().Id(); iEntry.SetEntryL(KMsvRootIndexEntryId); // Get all POP3 and Imap services CMsvEntrySelection* rootChildren = iEntry.ChildrenL(); CleanupStack::PushL(rootChildren); TMsvEntry entry; CEmailAccounts* accounts = CEmailAccounts::NewLC(); const TInt count = rootChildren->Count(); TInt j =0; while(j < count && iFoundServer ==EFalse) { // set context to service entry iEntry.SetEntryL((*rootChildren)[j]); entry = iEntry.Entry(); if (entry.iType == KUidMsvServiceEntry && (entry.iMtm == KUidMsgTypePOP3 || entry.iMtm == KUidMsgTypeIMAP4)) { TBuf8<8> port; if(entry.iMtm == KUidMsgTypePOP3) { // calculate hash value CImPop3Settings* settings = new(ELeave)CImPop3Settings; CleanupStack::PushL(settings); TPopAccount id; accounts->GetPopAccountL(entry.Id(), id); accounts->LoadPopSettingsL(id, *settings); port.Num((TUint)KPOP3DefaultPortNumber); iFoundServer = CalcHashValueL( *charconv, settings->LoginName(), settings->ServerAddress(), port); } else // entry.iMtm == KUidMsgTypeIMAP4 { CImImap4Settings* settings = new(ELeave)CImImap4Settings; CleanupStack::PushL(settings); TImapAccount id; accounts->GetImapAccountL(entry.Id(), id); accounts->LoadImapSettingsL(id, *settings); port.Num((TUint)KIMAPDefaultPortNumber); iFoundServer = CalcHashValueL( *charconv, settings->LoginName(), settings->ServerAddress(), port); } CleanupStack::PopAndDestroy(); // settings } j++; } if( iFoundServer ) iServiceMsvId = entry.Id(); CleanupStack::PopAndDestroy(4, charconv); // charconv, charsetsAvailable, rootChildren, accounts iEntry.SetEntryL(current); }
// ---------------------------------------------------------------------------------------- // CTerminalControlServer::GetRunningProcessesL // ---------------------------------------------------------------------------------------- CBufFlat* CTerminalControlServer::GetRunningProcessesL( ) { RDEBUG("CTerminalControlServer::GetRunningProcessesL"); TFullName processName; TFindProcess findProcess; CBufFlat *buffer = CBufFlat::NewL(128); iProcessInfoArray->Reset(); while( KErrNone == findProcess.Next( processName ) ) { TTcProcessInfo info; RProcess process; if( KErrNone == process.Open( findProcess ) ) { // // Add process information to local array // info.iProcessName = processName; info.iFileName = process.FileName(); info.iHandle = process.Handle(); info.iId = process.Id(); info.iSecureId = process.SecureId(); info.iProtected = EFalse; process.GetMemoryInfo( info.iMemoryInfo ); User::IsRomAddress( info.iCodeInRom, (TAny*)(info.iMemoryInfo.iCodeBase) ); if( !info.iCodeInRom ) { User::IsRomAddress( info.iCodeInRom, (TAny*)(info.iMemoryInfo.iCodeBase) ); } iProcessInfoArray->AppendL( info ); // // Add process also to return buffer // /* TInt appendPosition = buffer->Size(); if(iProcessInfoArray->Count() >= 2) { TBuf8<sizeof(info.iProcessName)> proName; proName.Copy(info.iProcessName); buffer->InsertL(appendPosition, _L8("/")); buffer->InsertL(appendPosition+1, proName); } else { TBuf8<sizeof(info.iProcessName)> proName; proName.Copy(info.iProcessName); buffer->InsertL(appendPosition, proName); } } */ // Enumerate names from 1 TInt appendPosition = buffer->Size(); TBuf8<MAX_NUMBER_OF_DIGITS_IN_10BASE_INT64> numBuf; TBuf8<sizeof(KFormatProcessNamePrefix)+20> nameBuf; numBuf.Num(iProcessInfoArray->Count()); nameBuf.Zero(); nameBuf.Append(KFormatProcessNamePrefix); nameBuf.Append(numBuf); if(iProcessInfoArray->Count() >= 2) { buffer->InsertL(appendPosition, _L8("/")); buffer->InsertL(appendPosition+1, nameBuf); } else { buffer->InsertL(appendPosition, nameBuf); } } } /* TUint32 flags = Exec::ProcessFlags(KCurrentProcessHandle); if (flags & KProcessFlagSystemPermanent) return ESystemPermanent; if (flags & KProcessFlagSystemCritical) return ESystemCritical; if (flags & KThreadFlagProcessPermanent) return EAllThreadsCritical; return ENotCritical; */ return buffer; }
// ----------------------------------------------------------------------------- // CUpnpSsdpServer::UdpMessageReceivedL // UDP message received. // ----------------------------------------------------------------------------- // void CUpnpSsdpServer::UdpMessageReceivedL( CUdpMessage* aMessage ) { if ( !aMessage ) { return; } CUpnpSsdpMessage* message = ( CUpnpSsdpMessage* ) aMessage; // Unless it's response, check if HOST header has explicitly specified port number - 1900 // If not, then add this port if ( !message->IsSsdpResponse() ) { TPtrC8 host = message->GetHeaderValue( KHdrHost ); // : Not found so port is not specified if( host.Find( UpnpString::KColon() ) == KErrNotFound ) { TBuf8<KMaxIntegerLength> defaultPort; defaultPort.Num( KMulticastPort ); HBufC8* newHost = HBufC8::NewLC( host.Length() + UpnpString::KColon().Length() + defaultPort.Length() ); newHost->Des().Zero(); newHost->Des().Append( host ); newHost->Des().Append( UpnpString::KColon() ); newHost->Des().Append( defaultPort ); message->AddHostL( *newHost ); CleanupStack::PopAndDestroy(newHost); } } if ( iMasterServer ) { iMasterServer->MessageFromMulticastL( message ); } else { if ( message->IsSsdpMSearch() ) { LOGS( "SSDP *** Search received"); ResponseL( message ); // add additional notification to upper-layer // used for detection IP address change iSsdpServerObserver->SsdpEventL( message ); } else if (message->IsSsdpNotify()) { LOGS( "SSDP *** Notify received"); iSsdpServerObserver->SsdpEventL( message ); } else if (message->IsSsdpResponse()) { LOGS( "SSDP *** Response received"); iSsdpServerObserver->SsdpEventL( message ); } else { LOGS( "SSDP *** UNKNOWN MESSAGE RECEIVED"); } } }
// --------------------------------------------------------------------------- // T_SIPAdapter::CheckSettingsL // Checks saved settings. // --------------------------------------------------------------------------- // void T_SIPAdapter::CheckSettingsL( ) { __UHEAP_MARK; CSIPProfileRegistryObserver* observer = CSIPProfileRegistryObserver::NewLC(); // CS:1 CSIPManagedProfileRegistry* registry = CSIPManagedProfileRegistry::NewLC( *observer ); // CS:2 RPointerArray<CSIPProfile> profiles; CleanupClosePushL( profiles ); // CS:3 registry->ProfilesL( profiles ); EUNIT_ASSERT( 3 == profiles.Count() ); TUint32 tuintValue( KErrNone ); TBuf8<100> bufValue; TBool boolValue( EFalse ); // First SIP profile. CSIPManagedProfile* profile = static_cast<CSIPManagedProfile*>( profiles[0] ); const TDesC8* provider1 = NULL; profile->GetParameter( KSIPProviderName, provider1 ); bufValue.Copy( *provider1 ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( KProviderId1() == bufValue ); TSIPProfileTypeInfo type1 = profile->Type(); bufValue.Num( type1.iSIPProfileClass ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( TSIPProfileTypeInfo::EIms == type1.iSIPProfileClass ); profile->GetParameter( KSIPAccessPointId, tuintValue ); bufValue.Num( tuintValue ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( 1 < tuintValue ); tuintValue = 0; const TDesC8* puid1 = NULL; profile->GetParameter( KSIPUserAor, puid1 ); bufValue.Copy( *puid1 ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( KPublicUsername1() == bufValue ); profile->GetParameter( KSIPSigComp, boolValue ); bufValue.Num( boolValue ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( ETrue == boolValue ); boolValue = EFalse; profile->GetParameter( KSIPSecurityNegotiation, boolValue ); bufValue.Num( boolValue ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( ETrue == boolValue ); boolValue = ETrue; profile->GetParameter( KSIPAutoRegistration, boolValue ); bufValue.Num( boolValue ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( EFalse == boolValue ); boolValue = EFalse; const TDesC8* proxy1 = NULL; profile->GetParameter( KSIPOutboundProxy, KSIPServerAddress, proxy1 ); bufValue.Copy( *proxy1 ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( KProxyAddress1() == bufValue ); const TDesC8* proxyUser1 = NULL; profile->GetParameter( KSIPPrivateIdentity, proxyUser1 ); bufValue.Copy( *proxyUser1 ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( KPrivateIdentity1() == bufValue ); const TDesC8* proxyPw1 = NULL; TInt error = profile->GetParameter( KSIPOutboundProxy, KSIPDigestPassword, proxyPw1 ); // Passwords are changed to write only (in API) so can't read the contents. EUNIT_ASSERT( KErrPermissionDenied == error ); error = KErrNone; const TDesC8* proxyRealm1 = NULL; profile->GetParameter( KSIPOutboundProxy, KSIPDigestRealm, proxyRealm1 ); bufValue.Copy( *proxyRealm1 ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( KProxyRealm1() == bufValue ); const TDesC8* registrarUri1 = NULL; profile->GetParameter( KSIPRegistrar, KSIPServerAddress, registrarUri1 ); bufValue.Copy( *registrarUri1 ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( KRegistrarAddr1() == bufValue ); const TDesC8* registrarPw1 = NULL; error = profile->GetParameter( KSIPRegistrar, KSIPDigestPassword, registrarPw1 ); EUNIT_ASSERT( KErrPermissionDenied == error ); error = KErrNone; const TDesC8* registrarRealm1 = NULL; profile->GetParameter( KSIPRegistrar, KSIPDigestRealm, registrarRealm1 ); bufValue.Copy( *registrarRealm1 ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( KRegistrarRealm1() == bufValue ); profile->GetParameter( KSIPDefaultProfile, boolValue ); bufValue.Num( boolValue ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( ETrue == boolValue ); boolValue = EFalse; profile->GetParameter( KSIPProfileLocked, boolValue ); bufValue.Num( boolValue ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( ETrue == boolValue ); boolValue = ETrue; // Second SIP profile. profile = NULL; profile = static_cast<CSIPManagedProfile*>( profiles[1] ); const TDesC8* provider2 = NULL; profile->GetParameter( KSIPProviderName, provider2 ); bufValue.Copy( *provider2 ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( KProviderId2() == bufValue ); TSIPProfileTypeInfo type2 = profile->Type(); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( TSIPProfileTypeInfo::EInternet == type2.iSIPProfileClass ); profile->GetParameter( KSIPSnapId, tuintValue ); bufValue.Num( tuintValue ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( 1 < tuintValue ); tuintValue = 0; const TDesC8* puid2 = NULL; profile->GetParameter( KSIPUserAor, puid2 ); bufValue.Copy( *puid2 ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( KPublicUsername2() == bufValue ); profile->GetParameter( KSIPSigComp, boolValue ); bufValue.Num( boolValue ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( EFalse == boolValue ); boolValue = ETrue; profile->GetParameter( KSIPSecurityNegotiation, boolValue ); bufValue.Num( boolValue ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( EFalse == boolValue ); boolValue = ETrue; profile->GetParameter( KSIPAutoRegistration, boolValue ); bufValue.Num( boolValue ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( EFalse == boolValue ); boolValue = ETrue; const TDesC8* proxy2 = NULL; profile->GetParameter( KSIPOutboundProxy, KSIPServerAddress, proxy2 ); bufValue.Copy( *proxy2 ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( KProxyAddress2() == bufValue ); const TDesC8* proxyUsr2 = NULL; profile->GetParameter( KSIPOutboundProxy, KSIPDigestUserName, proxyUsr2 ); bufValue.Copy( *proxyUsr2 ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( KProxyUsername2() == bufValue ); const TDesC8* proxyPw2 = NULL; error = profile->GetParameter( KSIPOutboundProxy, KSIPDigestPassword, proxyPw2 ); EUNIT_ASSERT( KErrPermissionDenied == error ); error = KErrNone; const TDesC8* proxyRealm2 = NULL; profile->GetParameter( KSIPOutboundProxy, KSIPDigestRealm, proxyRealm2 ); bufValue.Copy( *proxyRealm2 ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( KProxyRealm2() == bufValue ); const TDesC8* registrarUri2 = NULL; profile->GetParameter( KSIPRegistrar, KSIPServerAddress, registrarUri2 ); bufValue.Copy( *registrarUri2 ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( KRegistrarAddr2() == bufValue ); const TDesC8* registrarUsr2 = NULL; profile->GetParameter( KSIPRegistrar, KSIPDigestUserName, registrarUsr2 ); bufValue.Copy( *registrarUsr2 ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( KRegistrarUsername2() == bufValue ); const TDesC8* registrarPw2 = NULL; error = profile->GetParameter( KSIPRegistrar, KSIPDigestPassword, registrarPw2 ); EUNIT_ASSERT( KErrPermissionDenied == error ); error = KErrNone; const TDesC8* registrarRealm2 = NULL; profile->GetParameter( KSIPRegistrar, KSIPDigestRealm, registrarRealm2 ); bufValue.Copy( *registrarRealm2 ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( KRegistrarRealm2() == bufValue ); profile->GetParameter( KSIPDefaultProfile, boolValue ); bufValue.Num( boolValue ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( EFalse == boolValue ); boolValue = ETrue; // Profile not locked, SIPAdapter did not handle the setting, setting not // stored, should return KErrNotFound. TInt err = profile->GetParameter( KSIPProfileLocked, boolValue ); DBG_PRINT_2( "read KSIPProfileLocked from profile, error code %d", err ); EUNIT_ASSERT( KErrNotFound == err ); // Third SIP profile. profile = NULL; profile = static_cast<CSIPManagedProfile*>( profiles[2] ); const TDesC8* provider3 = NULL; profile->GetParameter( KSIPProviderName, provider3 ); bufValue.Copy( *provider3 ); EUNIT_PRINT( bufValue ); EUNIT_ASSERT( KProviderId3() == bufValue ); profile = NULL; // &profiles, registry, observer CleanupStack::PopAndDestroy( 3, observer ); __UHEAP_MARKEND; }
EXPORT_C void StartApplicationL(const TUid& aUid, const TDesC& aDocumentName, TInt aRetryInterval, TApaCommand aCommand) { TUid appToBeStarted = aUid; TInt pushed=0; #ifdef DEBUG RFs fs; User::LeaveIfError(fs.Connect()); CleanupClosePushL(fs); pushed++; RFile f; User::LeaveIfError(f.Replace(fs, _L("c:\\processmanagement.txt"), EFileWrite)); CleanupClosePushL(f); pushed++; f.Write(_L8("starting\n")); #endif TInt retries=0; LOG(_L8("new'ing ls session...")); RApaLsSession *lsp; lsp=new (ELeave) RApaLsSession; LOG(_L8("\n")); CleanupStack::PushL(lsp); ++pushed; RApaLsSession& ls(*lsp); while(retries<80) { TInt i_pushed=0; LOG(_L8("connecting ls session...")); TInt err=ls.Connect(); LOG(_L8(": ")); TBuf8<12> msg; msg.Num(err); msg.Append(_L("\n")); LOG(msg); if (err==KErrNone) { CleanupClosePushL(ls); ++i_pushed; pushed+=i_pushed; break; } else { CleanupStack::PopAndDestroy(i_pushed); } LOG(_L8("waiting...")); retries++; User::After(TTimeIntervalMicroSeconds32(aRetryInterval*1000)); LOG(_L8("done.\n")); } LOG(_L8("ls session created\n")); LOG(_L8("creating info...")); TApaAppInfo* infop=0; infop=new (ELeave) TApaAppInfo; LOG(_L8("1 ")); CleanupStack::PushL(infop); ++pushed; LOG(_L8("2 ")); TApaAppInfo& info(*infop); LOG(_L8("done\n")); RWsSession ws; User::LeaveIfError(ws.Connect()); CleanupClosePushL(ws); ++pushed; TApaTaskList tl(ws); TApaTask app_task=tl.FindApp(aUid); TBool exists=app_task.Exists(); while( !exists && retries<80) { TInt pushed=0; LOG(_L8("getting info...")); TInt err=ls.GetAppInfo(info, appToBeStarted); LOG(_L8("done: ")); TBuf8<12> msg; msg.Num(err); msg.Append(_L("\n")); LOG(msg); if (err==KErrNone) { #ifndef __S60V3__ CApaCommandLine* cmd=CApaCommandLine::NewLC(info.iFullName); pushed++; #else CApaCommandLine* cmd=CApaCommandLine::NewLC(); pushed++; cmd->SetExecutableNameL(info.iFullName); #endif cmd->SetCommandL( aCommand ); if ( aDocumentName.Length() > 0 ) { cmd->SetDocumentNameL(aDocumentName); } #ifndef __S60V3__ TRAP(err, EikDll::StartAppL(*cmd)); #else err=ls.StartApp(*cmd); #endif CleanupStack::PopAndDestroy(pushed); LOG(_L8("StartAppL: ")); msg.Num(err); msg.Append(_L("\n")); LOG(msg); if (err==KErrNone) break; } else { LOG(_L8("popping...")); CleanupStack::PopAndDestroy(pushed); LOG(_L8("done\n")); } LOG(_L8("waiting...")); retries++; User::After(TTimeIntervalMicroSeconds32(aRetryInterval*1000)); LOG(_L8("done.\n")); } LOG(_L8("done\n")); CleanupStack::PopAndDestroy(pushed); }
// ----------------------------------------------------------------------------- // CUpnpObjectBean::AttachIdL // (other items were commented in a header). // ----------------------------------------------------------------------------- // void CUpnpObjectBean::AttachIdL(TXmlEngElement aElement) { TBuf8<KMaxIntegerLen> num; num.Num(ObjId()); aElement.AddNewAttributeL( KIdAttrName(), num ); }
// ----------------------------------------------------------------------------- // CUpnpObjectBean::AttachParentIdL // (other items were commented in a header). // ----------------------------------------------------------------------------- // void CUpnpObjectBean::AttachParentIdL(TXmlEngElement aElement) { TBuf8<KMaxIntegerLen> num; num.Num(ObjParentId()); aElement.AddNewAttributeL( KParentID(), num ); }
void CHttpClientHeaderWriter::EncodeHostL(RHeaderField& aHeader) const /** Encodes the host header. RFC2616 section 14.23 Host = "Host" ":" host [ ":" port ] The host header value may be empty. @internalComponent @param aHeader The host header field to encode. @leave RHeaderField::BeginRawDataL @leave RHeaderField::PartsL @leave RHeaderField::WriteRawDataL @leave KErrHttpEncodeHost There were no parts, or the part value type or the parameter value type was not a string or a folded string. */ { __START_PERFORMANCE_LOGGER(); // Our convention will be that a string called HTTP::EPort will be used to // set a parameter holding the integer port number // Check part 1 THeaderFieldPartIter iter1 = aHeader.PartsL(); iter1.First(); if( iter1.AtEnd() ) { User::Leave(KErrHttpEncodeHost); } const CHeaderFieldPart* part = iter1(); if( part == NULL) { User::Leave(KErrHttpEncodeHost); } THTTPHdrVal pt1val = part->Value(); if( pt1val.Type() != THTTPHdrVal::KStrFVal ) { User::Leave(KErrHttpEncodeHost); } // Write the host string RStringF hostStr = pt1val.StrF(); aHeader.BeginRawDataL(); aHeader.WriteRawDataL(hostStr.DesC()); // Check for a port number THeaderFieldParamIter iter2 = part->Parameters(); iter2.First(); if( !iter2.AtEnd() ) { // Got a parameter - if its the port, check then write it const CHeaderFieldParam* param = iter2(); if( !param ) { User::Leave(KErrHttpEncodeHostPort); } if( param->Name() == iStringPool.StringF(HTTP::EPort,iStringTable) ) { // Get the port value THTTPHdrVal portVal = param->Value(); if (portVal.Type() != THTTPHdrVal::KTIntVal) { User::Leave(KErrHttpEncodeHostPort); } TBuf8<KMaxNumPortDigits> portDesC; const TInt portValue = portVal.Int(); if(portValue > KMaxNumPortValue) { User::Leave(KErrHttpEncodeHostPort); } portDesC.Num(portValue); aHeader.WriteRawDataL(':'); aHeader.WriteRawDataL(portDesC); } } aHeader.CommitRawData(); __END_PERFORMANCE_LOGGER(_L(",CHttpClientHeaderWriter::EncodeHostL()")); }