EXPORT_C #if defined (_DEBUG) /** Function to do a write of the supplied data, literally where possible. @param aData The descriptor that holds the supplied data. */ void THttpLogger::WriteComment(const TDesC8& aData) //Do a write of the supplied data, literally where possible { if(iLogger) { // If the connection to flogger was made if(iLogger->Handle() != 0) { TPtrC8 line; line.Set(aData); while (line.Length() > KMaxLogLineLength) { iLogger->Write(line.Left(KMaxLogLineLength)); line.Set(line.Right(line.Length() - KMaxLogLineLength)); } iLogger->Write(line.Left(line.Length())); } } }
// ----------------------------------------------------------------------------- // Get value for given id. // ----------------------------------------------------------------------------- // HBufC8* CConfigurationHandler::GetTokenValue( const TDesC8& aData, const TDesC8& aKey ) { if( aData.Find(aKey)==KErrNotFound ) { return NULL; } // id is in the string TLex8 lex(aData); while( !lex.Eos() ) { TPtrC8 token = lex.NextToken(); TInt spos = token.Find(aKey); if( spos==KErrNotFound ) { continue; } // key was found return value TPtrC8 value = token.Right(token.Length()-aKey.Length()); HBufC8* retval = HBufC8::NewL(value.Length()); TPtr8 des = retval->Des(); des.Append(value); return retval; } return NULL; }
// ----------------------------------------------------------------------------- // CContactSubscriber::RunL() // Assyncronous request handler , on completion of notification // ----------------------------------------------------------------------------- // void CContactSubscriber::RunL() { __TRACE_CALLSTACK; SubscribeChangeNotiFication(); // property updated, get new value TBuf8 <KBufferSize> value; TPtrC8 id; TPtrC8 sourceType; TPtrC8 addressCount; if ( KErrNone == iProperty.Get( value ) ) { TInt pos = value.Locate(TChar('-')); id.Set( value.Left(pos) ); TPtrC8 ptr = value.Right(3); sourceType.Set(ptr.Left(1)); addressCount.Set(ptr.Right(1)); TInt appId = -1, addressType = -1, addressTypeCount = -1; TLex8 lex(id); lex.Val(appId); TLex8 lex1(sourceType); lex1.Val( addressType ); TLex8 lex2(addressCount); lex2.Val(addressTypeCount); iNotifyChange.GetChangeNotificationL( appId, addressType,addressTypeCount ); } }
// ----------------------------------------------------------------------------- // CUpnpDevice::DescriptionUrlPort // Retrun description URL port. // ----------------------------------------------------------------------------- // EXPORT_C TInt CUpnpDevice::DescriptionUrlPort() const { if ( iAddress != TInetAddr( INET_ADDR( 0,0,0,0 ), 0) ) { return iAddress.Port(); } const TDesC8& url = DescriptionUrl(); if ( url.Length()> KHttp().Length() ) { TPtrC8 addrAndPath = url.Right( url.Length() - KHttp().Length() ); TInt separIndex = addrAndPath.Find( KSepar() ); if ( separIndex == KErrNotFound ) { return KDefaultDescriptionUrlPort; } TInt slashIndex = addrAndPath.Find( KSlash8() ); if ( slashIndex != KErrNotFound ) { TPtrC8 port = addrAndPath.Mid( separIndex + 1, slashIndex - separIndex ); TLex8 lex( port ); TInt prt; TInt err = lex.Val( prt ); if( KErrNone != err ) { return KErrNotFound; } return prt; } else { TPtrC8 port = addrAndPath.Right( addrAndPath.Length() - ( separIndex + 1 ) ); TLex8 lex( port ); TInt prt; TInt err = lex.Val( prt ); if( KErrNone != err ) { return KErrNotFound; } return prt; } } return KDefaultDescriptionUrlPort; }
CSenElement* CPolicyNormalizer::ProcessPolicyReferenceL(CSenElement* aPolicy, CPolicyRegistry* aRegistry) { //Loop for wsp:PolicyReference element and if found then replace // it with wsp:All and copy everything from found policy to here if(aRegistry == NULL) return NULL; //Check if there is a reference if yes then resolve it RPointerArray<CSenElement> referenceChildren; if(aPolicy->ElementsL(referenceChildren, KWsPolicyReference) == KErrNone) { TInt childCount = referenceChildren.Count(); TInt i = 0; CSenElement* pNextChild; while (i < childCount) { pNextChild = referenceChildren[i]; TPtrC8 localName = pNextChild->LocalName(); TPtrC8 uri = GetReferenceUriL(pNextChild); _LIT8(KHash, "#"); HBufC8* aRippedUri = NULL; if(uri.Left(1).Compare(KHash) == 0) aRippedUri = uri.Right(uri.Length()-1).AllocL(); if(aRippedUri->Length() > 0) { CSenElement* referedPolicy = aRegistry->LookupPolicy(aRippedUri->Des()); if(referedPolicy) { ReplacePolicyReferenceL(pNextChild,referedPolicy); } } delete aRippedUri; i++; } } //Check in all children recursively PolicyReferences and resolve them RPointerArray<CSenElement>& children = aPolicy->ElementsL(); TInt childCount = children.Count(); CSenElement* pNextChild; TInt i=0; while (i < childCount) { pNextChild = children[i]; TPtrC8 localName = pNextChild->LocalName(); ProcessPolicyReferenceL(pNextChild, aRegistry); i++; } return NULL; }
// --------------------------------------------------------- // CDdEng::ParseLicenseL() // --------------------------------------------------------- // void CDdEng::ParseLicenseL() { HBufC8* descriptorBuf = CodUtil::ConvertLC( iCodBuf->Des()); TPtrC8 license; TPtrC8 descriptor (descriptorBuf->Ptr()); TInt startTag = descriptor.Find(KLicenseStartTag); // "<license" if (startTag != KErrNotFound) { descriptor.Set(descriptor.Right(descriptor.Length()- startTag -1)); TInt endTag = descriptor.Locate(KElementEnd); //'>' if (endTag != KErrNotFound) { license.Set(descriptor.Right(descriptor.Length()-endTag-1)); TInt licenseTagEnd = license.Find(KLicenseEndTag); // "</license" if (licenseTagEnd != KErrNotFound) { license.Set(license.Left(licenseTagEnd)); } } } iSaver->AppendData( license ); CleanupStack::PopAndDestroy( descriptorBuf ); }
TInt CVersionFileReader::ReadNewVersionFileL(const TDesC& versionFile) { iNewVersionArray->Reset(); class RFs& fs = CCoeEnv::Static()->FsSession(); class RFile file; TInt ret = file.Open(fs, versionFile, EFileStreamText | EFileRead); if(ret != KErrNone) { /* Could not open file, return the error code */ return ret; } HBufC8* line = HBufC8::NewLC(40); TInt pos = -1; file.Seek(ESeekStart, pos); TPtr8 pLine = line->Des(); ret = file.Read(pLine); if(line->Length() == 0) { // Empty file file.Close(); return KErrEof; } file.Close(); // The file contains a string that should match this regex: // [0-9]+\.[0-9]+\.[0-9]\+:[0-9]+\.[0-9]+\.[0-9]\+:[0-9]\+ // The string is separated into three parts by ':'. // The first part is the application version // The second part is the resource version // The third part is the mlfw version. const TChar colon = ':'; const TChar dot = '.'; while(line->Length() > 0) { if(line->Locate(colon) != KErrNotFound) { TPtrC8 part = line->Left(line->Locate(colon)); TPtrC8 version = part.Left(part.LocateReverse(dot)); TPtrC8 misc = part.Right(part.Length() - part.LocateReverse(dot) - 1); iNewVersionArray->AppendL(part); iNewVersionArray->AppendL(version); iNewVersionArray->AppendL(misc); line->Des().CopyF(line->Right(line->Length() - line->Locate(colon) - 1)); } else { iNewVersionArray->AppendL(*line); break; } } CleanupStack::PopAndDestroy(line); return 0; }
EXPORT_C #if defined (_DEBUG) void TInuLogger::WriteComment(const TDesC8& aData) //Do a write of the supplied data, literally where possible { TPtrC8 line; line.Set(aData); while (line.Length() > KMaxLogLineLength) { iLogger.Write(line.Left(KMaxLogLineLength)); line.Set(line.Right(line.Length() - KMaxLogLineLength)); } iLogger.Write(line.Left(line.Length())); }
// ----------------------------------------------------------------------------- // CUpnpDevice::DescriptionUrlPath // Return description URL path. // ----------------------------------------------------------------------------- // EXPORT_C const TPtrC8 CUpnpDevice::DescriptionUrlPath() const { const TDesC8& url = DescriptionUrl(); if ( url.Length()> KHttp().Length() ) { TPtrC8 addrAndPath = url.Right( url.Length() - KHttp().Length() ); TInt index = addrAndPath.Find( KSlash8() ); if ( index != KErrNotFound ) { TPtrC8 addr = addrAndPath.Right( addrAndPath.Length() - index ); return addr; } } return TPtrC8( KNullDesC8 ); }
// ----------------------------------------------------------------------------- // MceSip::ToSIPExtensionHeadersL // ----------------------------------------------------------------------------- // void MceSip::ToSIPExtensionHeadersL( RPointerArray<CSIPHeaderBase>& aSIPHeaders, const MDesC8Array& aHeaders ) { for ( int i = 0; i < aHeaders.MdcaCount(); i++ ) { TPtrC8 param = aHeaders.MdcaPoint( i ); TInt index = param.Locate( KMceSipSeparator ); if ( index != KErrNotFound && param.Left( index ) != KMceSipSubscriptionStateHeader ) { CSIPExtensionHeader* extHeader = CSIPExtensionHeader::NewL( param.Left(index), param.Right( param.Length() - ( index + 1 ) ) ); CleanupStack::PushL( extHeader ); User::LeaveIfError( aSIPHeaders.Append( extHeader ) ); CleanupStack::Pop( extHeader ); } } }
void CSatNotifySendSs::CheckCallForwarding ( TPtrC8 aSource, RSat::TSsString& aSsString ) { OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSATNOTIFYSENDSS_CHECKCALLFORWARDING_1, "CSAT:: CSatNotifySendSs::CheckCallForwarding"); _LIT8(KCFU,"*21*"); // Call forwarding unconditional (CFU) _LIT8(KCFB,"*67*"); // Call forwarding on Mobile Subscriber Busy(CFB) _LIT8(KCFNRy, "*61*"); // Call forwarding on No Reply (CFNRy) _LIT8(KCFNRc, "*62*"); // Call forwarding on Mobile Subscriber Not // Reachable (CFNRc) // Try to find call forwarding string TInt pos( aSource.Find( KCFU ) ); if ( KErrNotFound == pos ) { pos = aSource.Find( KCFB ); } if ( KErrNotFound == pos ) { pos = aSource.Find( KCFNRy ); } if ( KErrNotFound == pos ) { pos = aSource.Find( KCFNRc ); } if ( KErrNotFound != pos ) { OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSATNOTIFYSENDSS_CHECKCALLFORWARDING_2, "CSAT:: CSatNotifySendSs::CheckCallForwarding, String is for call forwarding"); aSsString.iSsString.Zero(); aSsString.iSsString.Append( aSource.Left( pos + 4 ) ); aSsString.iSsString.Append( KPlusMarkCharacterCode ); aSsString.iSsString.Append( aSource.Right( aSource.Length() - ( pos + 4) ) ); } }
// --------------------------------------------------------------------------- // CAtSmsReceive::CMTResponseFirstLineL // other items were commented in a header // --------------------------------------------------------------------------- void CAtSmsReceive::CMTResponseFirstLineL() { LOGTEXT(_L8("CAtSmsReceive::CMTResponseFirstLineL Enter funciton")); iError = KErrNone; TPtrC8 firstLineBuf; firstLineBuf.Set(Buffer()); TInt pos = firstLineBuf.FindF(KCMTResponseString); if (pos == KErrNotFound) { LOGTEXT(_L8("CAtSmsReceive::CMTResponseFirstLineL()\tError - Cannot find '+CMT:' string")); iError = KErrNotFound; return; } //skip the string of +CMT: pos += KCMTResponseString().Length(); //skip a "," character while(!(TChar(firstLineBuf[pos]).IsDigit())) { ++pos; } TInt lenPos = firstLineBuf.Length()-pos; TPtrC8 pduLenBuf; pduLenBuf.Set(firstLineBuf.Right(lenPos)); TLex8 lex(pduLenBuf); TUint16 val; TInt ret = lex.Val(val,EDecimal); if(ret != KErrNone) { iError = ret; return; } iPduLen = val; LOGTEXT2(_L8("New SMS detected of length %d"),iPduLen); }
// --------------------------------------------------------------------------- // CUpnpHttpFileTransferWriter::StartL // Sends the HTTP headers of the content // --------------------------------------------------------------------------- // void CUpnpHttpFileTransferWriter::SendHeadersL() { if(iState == EHeaders) if( iSession.FileAccess() ) if(!IsActive()) { //in case session not connected,waiting... if(!iSession.IsConnected()) { iWaiting = ETrue; return; } iSendBuffer.Zero(); if ( ( iSession.FileAccess()->GetHeaders().Length() - iSession.FileAccess()->TransferredBytes()) <= iSendBuffer.MaxLength() ) { TPtrC8 headerPointer; headerPointer.Set(iSession.FileAccess()->GetHeaders()); headerPointer.Set( headerPointer.Right( iSession.FileAccess()->GetHeaders().Length()- iSession.FileAccess()->TransferredBytes()) ); iSendBuffer.Append( headerPointer ); iSession.FileAccess()->SetHeadersSent(); // Adding file content to the header TInt length = iSendBuffer.MaxLength()-iSendBuffer.Length(); HBufC8* tmpBuffer = HBufC8::NewLC(length); iSendPointer.Set(tmpBuffer->Des()); if( iSession.FileAccess()->GetL(iSendPointer,length) ) { iState = EFinished; } iSendBuffer.Append(iSendPointer); CleanupStack::PopAndDestroy( tmpBuffer ); } else { TPtrC8 headerPointer; headerPointer.Set( iSession.FileAccess()->GetHeaders() ); headerPointer.Set( headerPointer.Right( iSession.FileAccess()->GetHeaders().Length() - iSession.FileAccess()->TransferredBytes() ) ); headerPointer.Set( headerPointer.Left( iSendBuffer.Length() ) ); iSendBuffer.Append( headerPointer ); iSession.FileAccess()->SetPosOfHeader( iSession.FileAccess()->TransferredBytes() + headerPointer.Length() ); } iSendPointer.Set((TUint8*)iSendBuffer.Ptr(),iSendBuffer.Length(),iSendBuffer.MaxLength()); iSession.TimerCancel(); WriteToSocket(); iSession.StartTimeoutTimer(ETrue); if(!iHttpPostStarted) { iSession.NotifyUpperLayersOnPostL(); iHttpPostStarted = ETrue; } } }
// --------------------------------------------------------------------------- // CNSmlDmACLParser::ParseL() // Parses ACL data and keeps data until Reset() is called or instance // is destructed // --------------------------------------------------------------------------- TInt CNSmlDmACLParser::ParseL(const TDesC8& aACL) { Reset(); for(TInt i=EAclExecute;i>=EAclAdd;i--) { TInt aclStart = 0; TBool found=EFalse; switch(i) { case EAclAdd: aclStart = aACL.Find(KNSmlDmAclAddEqual); found = aclStart>=0; aclStart=aclStart+KNSmlDmAclAddEqual().Length(); break; case EAclReplace: aclStart = aACL.Find(KNSmlDmAclReplaceEqual); found = aclStart>=0; aclStart=aclStart+KNSmlDmAclReplaceEqual().Length(); break; case EAclDelete: aclStart = aACL.Find(KNSmlDmAclDeleteEqual); found = aclStart>=0; aclStart=aclStart+KNSmlDmAclDeleteEqual().Length(); break; case EAclGet: aclStart = aACL.Find(KNSmlDmAclGetEqual); found = aclStart>=0; aclStart=aclStart+KNSmlDmAclGetEqual().Length(); break; case EAclExecute: aclStart = aACL.Find(KNSmlDmAclExecEqual); found = aclStart>=0; aclStart=aclStart+KNSmlDmAclExecEqual().Length(); break; default: User::Panic(KSmlDmTreeDbHandlerPanic,KErrArgument); break; } if(found) { TInt aclStop = aACL.Right(aACL.Length()-aclStart). Locate(KNSmlDMAclCommandSeparator); if(aclStop<0) { aclStop = aACL.Length()-aclStart; } TPtrC8 commandAcl = aACL.Mid(aclStart,aclStop); CNSmlAclElement* aclElement = new(ELeave) CNSmlAclElement(); aclElement->iCommandType = (TNSmlDmCmdType)i; aclElement->iNext = iCommandAcls; iCommandAcls=aclElement; if(commandAcl.Compare(KNSmlDmAclAll)==0) { aclElement->iAllServers=ETrue; } else { TBool end = EFalse; TInt serverIdStart=0; while(!end) { TPtrC8 serverIdPtr = commandAcl.Right(commandAcl.Length()-serverIdStart); TInt serverIdStop = serverIdPtr.Locate(KNSmlDMAclSeparator); if(serverIdStop == KErrNotFound) { serverIdStop=commandAcl.Length(); end=ETrue; } HBufC8* serverId = serverIdPtr.Left(serverIdStop).AllocL(); aclElement->iServerIds.AppendL(serverId); serverIdStart=serverIdStart+serverIdStop+1; } } } } return KErrNone; }
// Parses Ecmt packets void CEcmtMidpDebugPlugin::HandleNotifyL(const CEcmtMessageEvent& aEvent) { static const TInt KMinMsgSize[] = { 0, ECMT_MIDP_DEBUG_OPEN_SIZE, ECMT_MIDP_DEBUG_CLOSE_SIZE, ECMT_MIDP_DEBUG_SEND_MIN_SIZE, ECMT_MIDP_DEBUG_CONNECT_SIZE, ECMT_MIDP_DEBUG_RESET_SIZE }; static const TInt KMaxMsgSize[] = { 0, ECMT_MIDP_DEBUG_OPEN_SIZE, ECMT_MIDP_DEBUG_CLOSE_SIZE, ECMT_MIDP_DEBUG_SEND_MAX_SIZE, ECMT_MIDP_DEBUG_CONNECT_SIZE, ECMT_MIDP_DEBUG_RESET_SIZE }; const TPtrC8 msg = iMessaging->Message(aEvent); TInt msglen = msg.Length(); if (msglen >= ECMT_MIDP_DEBUG_HEADER_SIZE) { // Decode the header TUint opcode = msg[ECMT_MIDP_DEBUG_HEADER_OPCODE_OFFSET]; TUint sid = (msg[ECMT_MIDP_DEBUG_HEADER_SID_OFFSET] << 24) | (msg[ECMT_MIDP_DEBUG_HEADER_SID_OFFSET+1] << 16) | (msg[ECMT_MIDP_DEBUG_HEADER_SID_OFFSET+2] << 8) | (msg[ECMT_MIDP_DEBUG_HEADER_SID_OFFSET+3]); // Check opcode if (opcode < ECMT_MIDP_DEBUG_OPCODE_MIN || opcode > ECMT_MIDP_DEBUG_OPCODE_MAX) { TRACE1("invalid opcode: %u",opcode); return; } // Check message size if (msglen < KMinMsgSize[opcode] || msglen > KMaxMsgSize[opcode]) { TRACE2("opcode %u, invalid message size %u",opcode,msglen); return; } // Try to find existing session TInt index = -1; CEcmtMidpDebugSession* session = FindSession(sid, index); switch (opcode) { case ECMT_MIDP_DEBUG_OPCODE_OPEN: if (session) { TRACE2("OPEN: destroying session %08X (%d)",session,sid); delete session; iSessions.Remove(index); } session = CEcmtMidpDebugSession::NewL(sid,this,iMessaging); CleanupStack::PushL(session); LEAVE_IF_ERROR(iSessions.Append(session)); CleanupStack::Pop(session); TRACE2("OPEN: created new session %08X (%u)",session,sid); break; case ECMT_MIDP_DEBUG_OPCODE_CLOSE: if (session) { TRACE2("CLOSE: destroying session %08X (%u)",session,sid); delete session; iSessions.Remove(index); } else { TRACE1("CLOSE: no such session: %u",sid); } break; case ECMT_MIDP_DEBUG_OPCODE_SEND: if (session) { TUint cid = (msg[ECMT_MIDP_DEBUG_SEND_CID_OFFSET] << 24) | (msg[ECMT_MIDP_DEBUG_SEND_CID_OFFSET+1] << 16) | (msg[ECMT_MIDP_DEBUG_SEND_CID_OFFSET+2] << 8) | (msg[ECMT_MIDP_DEBUG_SEND_CID_OFFSET+3]); TUint seq = (msg[ECMT_MIDP_DEBUG_SEND_SEQ_OFFSET] << 24) | (msg[ECMT_MIDP_DEBUG_SEND_SEQ_OFFSET+1] << 16) | (msg[ECMT_MIDP_DEBUG_SEND_SEQ_OFFSET+2] << 8) | (msg[ECMT_MIDP_DEBUG_SEND_SEQ_OFFSET+3]); session->Send(cid, seq, msg.Right(msglen - ECMT_MIDP_DEBUG_SEND_DATA_OFFSET)); } else { // Tell the other side that this session id is invalid TRACE1("SEND: invalid sid %u",sid); SendSessionCloseMessage(sid); } break; case ECMT_MIDP_DEBUG_OPCODE_CONNECT: if (session) { TUint cid = (msg[ECMT_MIDP_DEBUG_CONNECT_CID_OFFSET] << 24) | (msg[ECMT_MIDP_DEBUG_CONNECT_CID_OFFSET+1] << 16) | (msg[ECMT_MIDP_DEBUG_CONNECT_CID_OFFSET+2] << 8) | (msg[ECMT_MIDP_DEBUG_CONNECT_CID_OFFSET+3]); TUint port = (msg[ECMT_MIDP_DEBUG_CONNECT_PORT_OFFSET] << 8) | (msg[ECMT_MIDP_DEBUG_CONNECT_PORT_OFFSET+1]); session->ConnectL(cid, port); } else { // Tell the other side that this session id is invalid TRACE1("CONNECT: invalid sid %u",sid); SendSessionCloseMessage(sid); } break; case ECMT_MIDP_DEBUG_OPCODE_RESET: if (session) { TUint cid = (msg[ECMT_MIDP_DEBUG_RESET_CID_OFFSET] << 24) | (msg[ECMT_MIDP_DEBUG_RESET_CID_OFFSET+1] << 16) | (msg[ECMT_MIDP_DEBUG_RESET_CID_OFFSET+2] << 8) | (msg[ECMT_MIDP_DEBUG_RESET_CID_OFFSET+3]); session->Reset(cid); } else { // Tell the other side that this session id is invalid TRACE1("RESET: invalid sid %u",sid); SendSessionCloseMessage(sid); } break; } } }
void CSyncHttpConnection::StateChange(THttpEngineState aState) { iEngineStatus = aState; //CommonUtils::WriteLogL(_L("CSyncHttpConnection::StateChange iEngineStatus = "), iEngineStatus); switch (aState) { case EHttpError: case EHttpGetHeaderTimeOut: case EHttpGetBodyTimeOut: case EHttpFinished: if (iWait->IsStarted()) { iWait->AsyncStop(); } break; case EGetHeader: break; case ERedirect: { HBufC8* head = iConnection->GetResponeHeader(); TPtrC8 redirectUrl; if (head) { _LIT8(GOHREF, "Location:"); TInt redirectUrlIndex = head->FindC(GOHREF); if (redirectUrlIndex >= 0) { redirectUrl.Set(head->Right(head->Length() - redirectUrlIndex - GOHREF().Length())); _LIT8(SPACE, " "); redirectUrlIndex = redirectUrl.FindC(SPACE); while (redirectUrlIndex == 0) { redirectUrl.Set(redirectUrl.Right(redirectUrl.Length() - redirectUrlIndex - SPACE().Length())); redirectUrlIndex = redirectUrl.FindC(SPACE); } redirectUrlIndex = redirectUrl.FindC(_L8("\r\n")); if (redirectUrlIndex >= 0) { redirectUrl.Set(redirectUrl.Left(redirectUrlIndex)); } } } if (redirectUrl.Length() > 0) { TBuf<200> aUri; aUri.Copy(redirectUrl); //CommonUtils::WriteLogL(_L("CSyncHttpConnection::StateChange redirectUrl = "), aUri); iConnection->ResetVarible(); iConnection->Stop(); iConnection->GetRequestL(aUri, 0); iConnection->sendRequest(); } else { //CommonUtils::WriteLogL(_L("CSyncHttpConnection::StateChange ERedirect error"), _L("")); iEngineStatus = EHttpError; if (iWait->IsStarted()) { iWait->AsyncStop(); } } } break; default: if (iWait->IsStarted()) { iWait->AsyncStop(); } break; } }
TInt CFloggerTest028_Sync_Static_Multiple2::DoTestCheckWriteL() { RFile logFile; HBufC8* hBuffer; TInt listfilesize,returnCode; RFs fileSystem; //For file operation create a file system TInt numSuccessful = 0; User::LeaveIfError(fileSystem.Connect()); //Open the file in the read mode User::LeaveIfError(logFile.Open(fileSystem,KFloggerOutputFile,EFileRead)); CleanupClosePushL(logFile); User::LeaveIfError(logFile.Size(listfilesize)); //Size of the file hBuffer = HBufC8::New(listfilesize); //Allocate the buffer CleanupStack::PushL(hBuffer); TPtr8 ptrString = hBuffer->Des(); //To access the buffer // Read from position 0: start of file User::LeaveIfError(returnCode = logFile.Read(ptrString)); // the test case writes 5 elements 100 times, but we only check these things: // 1. that the long test message with one parameter is written 100 times // 2. that the test message with one param is written 100 times // 3. that the end of test message has been written TPtrC8 ptrStringOffsetForSearching; returnCode = ptrString.Find(KTestMessageOneParamExpected); if (returnCode > 0) { numSuccessful++; } TInt newLength; // allow length to be watched during debugging TInt loop; ptrStringOffsetForSearching.Set(ptrString.Right((ptrString.Length()-returnCode)-KTestMessageOneParamExpected().Length())); for (loop=0; loop < KMultipleWriteStressTimes; loop++) { returnCode = ptrStringOffsetForSearching.Find(KTestMessageOneParamExpected); //find the next occurance if (returnCode > 0) { numSuccessful++; } newLength = ptrStringOffsetForSearching.Length() - returnCode - KTestMessageOneParamExpected().Length(); if (newLength < 0) { User::Leave(KErrUnknown); } ptrStringOffsetForSearching.Set(ptrStringOffsetForSearching.Right(newLength)); } returnCode = ptrString.Find(KTestTooLongMessageOneParamExpected); if (returnCode > 0) { numSuccessful++; } newLength = ptrString.Length()-returnCode-KTestTooLongMessageOneParamExpected().Length(); ptrStringOffsetForSearching.Set(ptrString.Right(newLength)); for (loop=0; loop < KMultipleWriteStressTimes; loop++) { returnCode = ptrStringOffsetForSearching.Find(KTestTooLongMessageOneParamExpected); //find the next occurance if (returnCode > 0) { numSuccessful++; } if (loop < (KMultipleWriteStressTimes - 1)) { newLength = ptrStringOffsetForSearching.Length() - returnCode - KTestTooLongMessageOneParamExpected().Length(); if (newLength < 0) { User::Leave(KErrUnknown); } ptrStringOffsetForSearching.Set(ptrStringOffsetForSearching.Right(newLength)); } } returnCode = ptrString.Find(KTestEndMessage8); if (returnCode > 0) { numSuccessful++; } CleanupStack::PopAndDestroy(hBuffer); CleanupStack::PopAndDestroy(); //logFile if ( numSuccessful == 201 ) return KErrNone; else return KErrUnknown; }
TInt CFloggerTest028_Sync_ConMultiple2::DoTestCheckWriteL() { RFile logFile; HBufC8* hBuffer; TInt listfilesize,returnCode; RFs fileSystem; //For file operation create a file system TInt numSuccessful = 0; TInt loop = 0; User::LeaveIfError(fileSystem.Connect()); //Open the file in the read mode User::LeaveIfError(logFile.Open(fileSystem,KFloggerOutputFile,EFileRead)); CleanupClosePushL(logFile); User::LeaveIfError(logFile.Size(listfilesize)); //Size of the file hBuffer = HBufC8::New(listfilesize); //Allocate the buffer. This is about 176K in size CleanupStack::PushL(hBuffer); TPtr8 ptrString = hBuffer->Des(); //To access the buffer // Read from position 0: start of file User::LeaveIfError(returnCode = logFile.Read(ptrString)); // the test case writes 6 elements 100 times, but we only check these things: // 1. that the test message with one parameter is written 100 times // 2. that the long message is written 100 times // 3. that the end of test message has been written // 4. that the file is suitably big enough to be expected to contain the // 1K data segment 100 times in it. TPtrC8 ptrStringOffsetForSearching; returnCode = ptrString.Find(KTestMessageOneParamExpected); if (returnCode > 0) { numSuccessful++; } TInt newLength; ptrStringOffsetForSearching.Set(ptrString.Right((ptrString.Length()-returnCode)-KTestMessageOneParamExpected().Length())); for (loop=0; loop < KMultipleWriteStressTimes; loop++) { returnCode = ptrStringOffsetForSearching.Find(KTestMessageOneParamExpected); //find the next occurance if (returnCode > 0) { numSuccessful++; } newLength = ptrStringOffsetForSearching.Length() - returnCode - KTestMessageOneParamExpected().Length(); if (newLength < 0) { User::Leave(KErrUnknown); } ptrStringOffsetForSearching.Set(ptrStringOffsetForSearching.Right(newLength)); } returnCode = ptrString.Find(KTestTooLongExpectedMessage); if (returnCode > 0) { numSuccessful++; } ptrStringOffsetForSearching.Set(ptrString.Right((ptrString.Length()-returnCode)-KTestTooLongExpectedMessage().Length())); for (loop=0; loop < KMultipleWriteStressTimes; loop++) { returnCode = ptrStringOffsetForSearching.Find(KTestTooLongExpectedMessage); //find the next occurance if (returnCode > 0) { numSuccessful++; } newLength = ptrStringOffsetForSearching.Length() - returnCode - KTestTooLongExpectedMessage().Length(); if (newLength <0) { User::Leave(KErrUnknown); } ptrStringOffsetForSearching.Set(ptrStringOffsetForSearching.Right(newLength)); } returnCode = ptrString.Find(KTestEndMessage8); if (returnCode > 0) { numSuccessful++; } // we don't check that all the binary data is there - just that the file is nice and long if ( listfilesize > (K1KilobyteOfDataSize * KMultipleWriteStressTimes)) { numSuccessful++; } CleanupStack::PopAndDestroy(hBuffer); CleanupStack::PopAndDestroy(); //logFile if ( numSuccessful == 202 ) return KErrNone; else return KErrUnknown; }
// --------------------------------------------------------------------------- // CAtSmsReceive::CMTResponseSecondLineL // other items were commented in a header // --------------------------------------------------------------------------- void CAtSmsReceive::CMTResponseSecondLineL() { LOGTEXT(_L8("CAtSmsReceive::CMTResponseSecondLineL Enter funciton")); iError = KErrNone; iAttr.iFlags=0; TPtrC8 secondLineBuf; secondLineBuf.Set(CurrentLine()); #ifdef _DEBUG TInt totalLen = secondLineBuf.Length(); if(totalLen <= KLogMaxCharNumPerLine) { LOGTEXT2(_L8("CAtSmsReceiveMessage::CMTResponseSecondLineL\tSecondLine=%S"),&secondLineBuf); } else { TInt lines = (totalLen/KLogMaxCharNumPerLine); TInt remainingStrNum = (totalLen%KLogMaxCharNumPerLine); for(TInt i = 0; i < lines; i++) { TPtrC8 line(secondLineBuf.Mid(i*KLogMaxCharNumPerLine,KLogMaxCharNumPerLine)); LOGTEXT2(_L8("CAtSmsReceiveMessage::CMTResponseSecondLineL \tSecondLine line=%S"),&line); } TPtrC8 remaining(secondLineBuf.Right(remainingStrNum)); LOGTEXT2(_L8("CAtSmsReceiveMessage::CMTResponseSecondLineL \tSecondLine line=%S"),&remaining); } #endif // Buffer size calculated as follows; // (max pdu size + max prefixed SCA size) * number of ASCII chars used to code an octet TBuf8<(RMobileSmsMessaging::KGsmTpduSize+12)*2> localPdu; localPdu.Copy(secondLineBuf); // The CMT frame sometimes contains odd number of nibbles which // causes panic in ConvertAsciiToBinary() method. This type of // frames will simply be discarded. if(localPdu.Length() < (iPduLen*2)) { iError = KErrUnderflow; User::Leave(KErrUnderflow); } // // Check if we have a prefixed SCA on our pdu. // If we do then remove it. if(localPdu.Length() > (iPduLen*2)) { TInt ret = SmsAtUtil::ReadAndRemoveAddressFromAscii(localPdu,iAttr.iGsmServiceCentre); if(ret !=KErrNone) { LOGTEXT(_L8("CAtSmsReceiveMessage::CMTResponseSecondLineL Failed to read and remove SCA from PDU")); iError = ret; return; } else { iMsgReceive.iServiceCentre = iAttr.iGsmServiceCentre.iTelNumber; //for iServiceCentre iMsgReceive.iMobileScNPI = iAttr.iGsmServiceCentre.iNumberPlan; iMsgReceive.iMobileScTON = iAttr.iGsmServiceCentre.iTypeOfNumber; iAttr.iFlags|= RMobileSmsMessaging::KGsmServiceCentre; } } // // Convert received pdu from ASCII into binary TInt ret = SmsAtUtil::ConvertAsciiToBinary(localPdu,iPdu); if (ret!=KErrNone) { LOGTEXT(_L8("CAtSmsReceiveMessage::CMTResponseSecondLineL Failed to code PDU into binary")); iError = ret; return; } else { iAttr.iDataFormat=RMobileSmsMessaging::EFormatGsmTpdu; iAttr.iFlags|=RMobileSmsMessaging::KSmsDataFormat; iAttr.iStatus = RMobileSmsMessaging::EMtMessageUnstoredClientAck; iAttr.iFlags|=RMobileSmsMessaging::KIncomingStatus; } LOGTEXT2(_L8("Received PDU String is %S"),&iPdu); iMsgReceive.iSmsMsg = iPdu; }
// ----------------------------------------------------------------------------- // CSTSCredentialManager::AddCredentialL // Adds a certificate or certificate URI to certificate store // ----------------------------------------------------------------------------- // TBool CSTSCredentialManager::AddCredentialL( TInt/*const TDesC&*/ aCertDisplayName, TInt/*const TDesC&*/ aPkiPath) { if (iState != EReady) { User::Leave(KErrNotReady); } iWritableCertStoreIndex = CheckWriteCertStoreSEIDL(NULL, NULL); const TDesC8* path = reinterpret_cast< const TDesC8* >(aPkiPath); TASN1DecGeneric genericDecoder(*path); genericDecoder.InitL(); TPtrC8 certificates = genericDecoder.GetContentDER(); TInt certificatesLength = certificates.Length(); TInt pos = 0; iSubject.Set(certificates.Right(certificatesLength)); TPtrC8 issuer(iSubject); // go through the certificate chain, leaving the last certificate as subject // and second last as issuer while (pos < certificatesLength) { issuer.Set(iSubject); TASN1DecGeneric certDecoder(certificates.Right(certificatesLength - pos)); certDecoder.InitL(); TInt certLength = certDecoder.LengthDER(); TPtrC8 singleCert(certificates.Mid(pos, certLength)); iSubject.Set(singleCert); pos+=certLength; } CX509Certificate* cert = CX509Certificate::NewLC(iSubject); CX509Certificate* issuerCert = CX509Certificate::NewLC(issuer); iSubjectKeyId = cert->KeyIdentifierL(); iIssuerKeyId = issuerCert->KeyIdentifierL(); iCertDisplayName = reinterpret_cast<TDesC*>(aCertDisplayName); // now we have to check that this certificate does not exist in the // database yet CCertAttributeFilter* filter = CCertAttributeFilter::NewLC(); filter->SetFormat(EX509Certificate); filter->SetSubjectKeyId(iSubjectKeyId); filter->SetIssuerKeyId(iIssuerKeyId); RMPointerArray< CCTCertInfo >* certInfoArray = new(ELeave) RMPointerArray< CCTCertInfo >(); if (iCertInfoArray) { iCertInfoArray->Close(); delete iCertInfoArray; } iCertInfoArray = certInfoArray; iState = EAddListing; iStore->WritableCertStore(iWritableCertStoreIndex) .List(*iCertInfoArray, *filter, iStatus); WaitForCompletionL(); CleanupStack::PopAndDestroy(3); // filter, cert, issuerCert iCertInfoArray->Close(); delete iCertInfoArray; iCertInfoArray = NULL; return ETrue; }
// ----------------------------------------------------------------------------- // CUpnpHttpSession::ParseRangeHeader // Parse range values // ----------------------------------------------------------------------------- // TBool CUpnpRangeHeaderParser::ParseRangeHeader( TDesC8& aRangeHeader, TInt& aStartPos, TInt& aEndPos ) { // Check header's syntax: "bytes=x-y" where y i optional TInt pos( KErrNotFound ); // 1 string has to contain "=" pos = aRangeHeader.FindC( UpnpString::KEqual() ); if( pos == KErrNotFound ) return EFalse; // 2 "bytes" has to be at the beginnig pos = aRangeHeader.FindC( UpnpHTTP::KBytes() ); if( pos == KErrNotFound || pos != 0 ) return EFalse; // 3 Sets position to after bytes pos = UpnpHTTP::KBytes().Length(); // 4 If there any space or tab after "bytes" - move pos after it CUpnpRangeHeaderParser::MovePosition( aRangeHeader, pos ); // 5 "=" - has to be at this position (after "bytes" + spaces or tabs) if( aRangeHeader[ pos ] != UpnpString::KEqual()[0] ) return EFalse; // 6 Sets position to after "=" pos++; // 7 If there any space or tab after "=" - move pos after it CUpnpRangeHeaderParser::MovePosition( aRangeHeader, pos ); // 8 extract x-y. -1 stands for '=' length TPtrC8 byteRange = aRangeHeader.Right( aRangeHeader.Length() - pos ); // 9 There can't be any comas because multi-range is not allowed if( byteRange.Find( UpnpString::KComa() ) != KErrNotFound ) return EFalse; // 10 "-" delimiter must occure and it cant't be first char, because notation as follows: "-y" is not allowed pos = byteRange.Find( UpnpString::KMinus() ); if( pos == KErrNotFound ) return EFalse; // 11 Checks if it is a final bytes request // e.g. Range: bytes= -20 if( pos == 0 ) { // If there any space or tab after "-" - move pos after it CUpnpRangeHeaderParser::MovePosition( byteRange.Right( byteRange.Length()-1 ), pos ); // if pos equal 0 should be 1 to avoid "-" in getting number from string operation pos = pos == 0 ? 1 : pos; TLex8 endMinus( byteRange.Right( byteRange.Length() - pos ) ); endMinus.SkipSpace(); TInt error = endMinus.Val( aEndPos ); if ( !CUpnpRangeHeaderParser::HandleConversionException( endMinus, aEndPos, error ) ) { return EFalse; } // We have to check if something else than space or tab leaves after conversion - unless for example 11a will be correct but it is not if ( CUpnpRangeHeaderParser::HasImproperChars( endMinus ) ) return EFalse; aStartPos = KErrNotFound; return ETrue; } // 12 All looks fine, so now parse it and get x and y TLex8 start( byteRange.Left( pos ) ); start.SkipSpace(); // 13 If conversion fails - return error TInt error = start.Val( aStartPos ); if ( !CUpnpRangeHeaderParser::HandleConversionException( start, aStartPos, error ) ) { return EFalse; } // 14 We have to check if something else than space or tab leaves after conversion - unless for example 11a will be correct but it is not if ( CUpnpRangeHeaderParser::HasImproperChars( start ) ) return EFalse; // y is optional if( ( byteRange.Length() - pos - 1 ) > 0 ) { TLex8 end( byteRange.Right( byteRange.Length() - pos - 1 ) ); end.SkipSpace(); error = end.Val( aEndPos ); if ( !CUpnpRangeHeaderParser::HandleConversionException( end, aEndPos, error ) ) { return EFalse; } // We have to check if something else than space or tab leaves after conversion - unless for example 11a will be correct but it is not if ( CUpnpRangeHeaderParser::HasImproperChars( end ) ) return EFalse; } else { aEndPos = KErrNotFound; } return ETrue; }