/** Check if we can copy the file to the new location */ TMTPResponseCode CMTPImageDpCopyObject::CanCopyObjectL(const TDesC& aOldName, const TDesC& aNewName) const { OstTraceFunctionEntry0( CMTPIMAGEDPCOPYOBJECT_CANCOPYOBJECTL_ENTRY ); TMTPResponseCode result = EMTPRespCodeOK; TEntry fileEntry; LEAVEIFERROR(iFramework.Fs().Entry(aOldName, fileEntry), OstTraceExt2( TRACE_ERROR, DUP1_CMTPIMAGEDPCOPYOBJECT_CANCOPYOBJECTL, "Gets the entry details for %S failed! error code %d", aOldName, munged_err )); TDriveNumber drive(static_cast<TDriveNumber>(iFramework.StorageMgr().DriveNumber(iStorageId))); LEAVEIFERROR(drive, OstTraceExt2( TRACE_ERROR, DUP2_CMTPIMAGEDPCOPYOBJECT_CANCOPYOBJECTL, "Gets drive for storage %d failed! error code %d", iStorageId, munged_err )); TVolumeInfo volumeInfo; LEAVEIFERROR(iFramework.Fs().Volume(volumeInfo, drive), OstTraceExt2( TRACE_ERROR, DUP3_CMTPIMAGEDPCOPYOBJECT_CANCOPYOBJECTL, "Gets volume information for driver %d failed! error code %d", drive, munged_err )); if(volumeInfo.iFree < fileEntry.FileSize()) { result = EMTPRespCodeStoreFull; } else if (BaflUtils::FileExists(iFramework.Fs(), aNewName)) { result = EMTPRespCodeInvalidParentObject; } OstTrace1( TRACE_NORMAL, CMTPIMAGEDPCOPYOBJECT_CANCOPYOBJECTL, "CanCopyObjectL - Exit with response code 0x%04X", result ); OstTraceFunctionExit0( CMTPIMAGEDPCOPYOBJECT_CANCOPYOBJECTL_EXIT ); return result; }
// --------------------------------------------------------- // CDpDataBuffer::SetLength // This method sets length of buffer. This is called from // CDpDataPort::SetReceiveBufferLength() method. // --------------------------------------------------------- // TInt CDpDataBuffer::SetLength( const TInt aLen) { OstTrace0( TRACE_NORMAL, CDPDATABUFFER_SETLENGTH, "CDpDataBuffer::SetLength" ); LOGM(" CDpDataBuffer::SetLength"); //Initialization TInt max( 0 ); TInt ret( KErrNone ); if ( iHead + iWE.iSize > iEnd ) { max = iHead + iWE.iSize; } else { max = iEnd; } OstTraceExt2( TRACE_NORMAL, DUP1_CDPDATABUFFER_SETLENGTH, "CDpDataBuffer:: iHead: %d, iWE.iSize: %d", iHead, iWE.iSize ); OstTraceExt2( TRACE_NORMAL, DUP2_CDPDATABUFFER_SETLENGTH, "CDpDataBuffer:: iEnd : %d, aLen : %d", iEnd, aLen ); LOG2(" iHead: %d, \t iWE.iSize: %d", iHead, iWE.iSize ); LOG2(" iEnd : %d, \t aLen : %d", iEnd, aLen ); if ( ( max >= ( aLen + iMaxReservationSize ) ) || ( aLen < 2*iMaxReservationSize ) ) { // buffer may be filled further than length OstTrace0( TRACE_NORMAL, DUP3_CDPDATABUFFER_SETLENGTH, "CDpDataBuffer:: ERROR, Client tried to reserve too big or too small Receive Buffer Size" ); OstTraceExt2( TRACE_NORMAL, DUP4_CDPDATABUFFER_SETLENGTH, "CDpDataBuffer:: aLen: %d, iMaxReservationSize: %d", aLen, iMaxReservationSize ); OstTrace1( TRACE_NORMAL, DUP5_CDPDATABUFFER_SETLENGTH, "CDpDataBuffer:: max: %d", max ); LOG(" ERROR, Client tried to reserve too big or too small Receive Buffer Size"); LOG2(" aLen: %d, \t iMaxReservationSize: %d", aLen, iMaxReservationSize ); LOG1(" max: %d", max ); ret = KErrArgument; } else { iBuf->Des().SetLength( max ); HBufC8* tmp = NULL; // ReAllocL returns address of the expanded or contracted HBufC descriptor. // ReAllocL() leaves, if there is insufficient memory. TRAP(ret, ( tmp = iBuf->ReAllocL( aLen+iMaxReservationSize ) )); if ( KErrNone == ret ) { iBuf=tmp; iBuf->Des().SetLength( aLen + iMaxReservationSize ); iBufSize = aLen + iMaxReservationSize; iTreshold = aLen; } } return ret; }
// --------------------------------------------------------------------------------- // CUpnpTmAppServerService::LaunchAppActionL // @param aAction pointer to upnp action object // @return Returns upnp error code // --------------------------------------------------------------------------------- // TUpnpErrorCode CUpnpTmAppServerService::LaunchAppActionL( CUpnpAction* aAction ) { OstTraceFunctionEntry0( CUPNPTMAPPSERVERSERVICE_LAUNCHAPPACTIONL_ENTRY ); TUint appIdInt; TUint profileIdInt; // Validates the input parameters if ( ( ConvertDescriptorToInt( aAction->ArgumentValue(KAppId), appIdInt ) != KErrNone ) || ( ConvertDescriptorToInt( aAction->ArgumentValue(KProfileId), profileIdInt ) != KErrNone )) { OstTraceExt2( TRACE_ERROR, CUPNPTMAPPSERVERSERVICE_LAUNCHAPPACTIONL, "CUpnpTmAppServerService::LaunchAppActionL;appIdInt=%u;profileIdInt=%u", appIdInt, profileIdInt ); return EInvalidArgs; // either invalid app ID or invalid profile ID } RBuf8 launchUrl; TTerminalModeErrorCode ret = iTmServerImpl.LaunchApp( appIdInt,profileIdInt,launchUrl ); if ( ret != ETerminalModeSuccess ) { // Error is returned launchUrl.Close(); OstTrace0( TRACE_ERROR, DUP1_CUPNPTMAPPSERVERSERVICE_LAUNCHAPPACTIONL, "CUpnpTmAppServerService::LaunchAppActionL" ); return TUpnpErrorCode( ret ); } CleanupClosePushL(launchUrl); aAction->SetArgumentL( KAppLaunchUri , launchUrl ); CleanupStack::PopAndDestroy(&launchUrl); OstTraceFunctionExit0( CUPNPTMAPPSERVERSERVICE_LAUNCHAPPACTIONL_EXIT ); return EHttpOk; }
// ----------------------------------------------------------------------------- // CSACommonIscServiceChannelListener::NewL // Two-phased constructor. // ----------------------------------------------------------------------------- // CSACommonIscServiceChannelListener* CSACommonIscServiceChannelListener::NewL( MSAIscService& aAdaptation, RIscApi& aIscApi) { OstTraceExt2( TRACE_NORMAL, SA_COMMON_ISC_SERVICE_CHANNEL_LISTENER_AUTOMATED_5, "ISCSERVICE - CSACommonIscServiceChannelListener::NewL(0x%x,0x%x)", (TUint)&aAdaptation, (TUint)&aIscApi ); INTERNAL_TRACE( ( _L( "ISCSERVICE - CSACommonIscServiceChannelListener::NewL(0x%x,0x%x)" ), &aAdaptation, &aIscApi ) ); CSACommonIscServiceChannelListener* self = new( ELeave ) CSACommonIscServiceChannelListener( aAdaptation, aIscApi ); CleanupStack::PushL( self ); self->ConstructL(); CleanupStack::Pop( self ); OstTrace1( TRACE_NORMAL, SA_COMMON_ISC_SERVICE_CHANNEL_LISTENER_AUTOMATED_6, "ISCSERVICE - CSACommonIscServiceChannelListener::NewL - return 0x%x", self ); INTERNAL_TRACE( ( _L( "ISCSERVICE - CSACommonIscServiceChannelListener::NewL - return 0x%x" ), self ) ); return self; }
void CUT_PBASE_T_USBDI_1231::ExecuteHostTestCaseL() { OstTraceFunctionEntry1( CUT_PBASE_T_USBDI_1231_EXECUTEHOSTTESTCASEL_ENTRY, this ); OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_1231_DCUT_PBASE_T_USBDI_1231_DUP01, "====> ExecuteHostTestCaseL entry priority = %d", RThread().Priority()); // Bump thread priority for this test only RThread().SetPriority(EPriorityAbsoluteHigh); OstTraceExt2(TRACE_NORMAL, CUT_PBASE_T_USBDI_1231_DCUT_PBASE_T_USBDI_1231_DUP02, "Thread priority raised %d->%d", iPriority, RThread().Priority()); iCaseStep = EInProcess; iActorFDF = CActorFDF::NewL(*this); iControlEp0 = new (ELeave) CEp0Transfer(iUsbInterface0); iInterface0Watcher = new (ELeave) CInterfaceWatcher(iUsbInterface0,TCallBack(CUT_PBASE_T_USBDI_1231::Interface0ResumedL,this)); iInterface1Watcher = new (ELeave) CInterfaceWatcher(iUsbInterface1,TCallBack(CUT_PBASE_T_USBDI_1231::Interface1ResumedL,this)); // Monitor for device connections iActorFDF->Monitor(); // Start the connection timeout TimeoutIn(30); OstTraceFunctionExit1( CUT_PBASE_T_USBDI_1231_EXECUTEHOSTTESTCASEL_EXIT, this ); }
TBool CMTPSvcDeleteServicePropList::DoHandleResponsePhaseL() { OstTraceFunctionEntry0( CMTPSVCDELETESERVICEPROPLIST_DOHANDLERESPONSEPHASEL_ENTRY ); TMTPResponseCode responseCode = EMTPRespCodeOK; TUint32 parameter = 0; const TUint count = iDeleteServicePropList->NumberOfElements(); for (TUint i = 0; i < count && responseCode == EMTPRespCodeOK; i++) { TMTPTypeDataPair& element = iDeleteServicePropList->ElementL(i); if (iDataProvider.ServiceID() != element.Uint32(TMTPTypeDataPair::EOwnerHandle)) { parameter = i; responseCode = EMTPRespCodeInvalidServiceID; break; } TUint16 propertyCode = element.Uint16(TMTPTypeDataPair::EDataCode); responseCode = iDataProvider.ServiceHandler()->DeleteServicePropertyL(propertyCode); if (EMTPRespCodeOK != responseCode) { parameter = i; break; } } SendResponseL(responseCode, 1, ¶meter); OstTraceExt2( TRACE_NORMAL, CMTPSVCDELETESERVICEPROPLIST_DOHANDLERESPONSEPHASEL, "Exit responseCode = 0x%04X, failed index = %u", responseCode, parameter ); OstTraceFunctionExit0( CMTPSVCDELETESERVICEPROPLIST_DOHANDLERESPONSEPHASEL_EXIT ); return EFalse; }
TInt TFsFormatNext::DoRequestL(CFsRequest* aRequest) // // Format the next part of the media. // { __PRINT1(_L("TFsFormatNext::DoRequestL() drv:%d"), aRequest->DriveNumber()); CFormatCB* format=(CFormatCB*)aRequest->ScratchValue(); TInt r=format->CheckMount(); if (r!=KErrNone && r!=KErrInUse) { __PRINT1(_L("TFsFormatNext::DoRequestL() err:%d"), r); return r; } TPtr8 pStep((TUint8*)&format->CurrentStep(),sizeof(TInt)); aRequest->ReadL(KMsgPtr0,pStep); OstTrace1(TRACE_FILESYSTEM, FSYS_ECFORMATCBDOFORMATSTEPL, "this %x", format); TRAP(r,format->DoFormatStepL()); OstTraceExt2(TRACE_FILESYSTEM, FSYS_ECFORMATCBDOFORMATSTEPLRET, "r %d iCurrentStep %d", r, (TUint) format->CurrentStep()); if (r==KErrNone) aRequest->WriteL(KMsgPtr0,pStep); if (r==KErrNone && format->CurrentStep()==0) { FsNotify::DiskChange(aRequest->DriveNumber()); } return(r); }
// --------------------------------------------------------------------------- // Checks whether the given connection was opened by the Wlan Sniffer // application // --------------------------------------------------------------------------- // TBool CWsfKeepalive::OpenedByWlanSniffer( TUint aConnectionId ) { OstTraceFunctionEntry0( CWSFKEEPALIVE_OPENEDBYWLANSNIFFER_ENTRY ); TBool retVal = EFalse; // Get all clients of this connection TConnMonClientEnumBuf clientInfo; iConnMon->GetClientInfo( clientInfo, aConnectionId ); // Check whether Wlan sniffer is one of the clients for ( TInt i( 0 ); i < clientInfo().iCount; ++i ) { if ( clientInfo().iUid[i] == KWlanSnifferUid ) { // Match found, stop looking retVal = ETrue; break; } } OstTraceExt2( TRACE_NORMAL, CWSFKEEPALIVE_OPENEDBYWLANSNIFFER, "CWsfKeepalive::OpenedByWlanSniffer;aConnectionId=%u;retVal=%u", aConnectionId, retVal ); OstTraceFunctionExit0( CWSFKEEPALIVE_OPENEDBYWLANSNIFFER_EXIT ); return retVal; }
/** Decrements the reference counter of the specified entry. If the counter reaches zero, the entry will be destroyed and removed from the container, the database connection - closed. @param aFullName The full database name, including the path. */ void CSqlCompactor::ReleaseEntry(const TDesC& aFullName) { SQL_TRACE_COMPACT(OstTraceExt2(TRACE_INTERNALS, CSQLCOMPACTOR_RELEASEENTRY1, "0x%X;CSqlCompactor::ReleaseEntry;aFullName=%S", (TUint)this, __SQLPRNSTR(aFullName))); SQLCOMPACTOR_INVARIANT(); TInt idx = iEntries.FindInOrder(aFullName, &CSqlCompactor::Search); __ASSERT_DEBUG(idx >= 0, __SQLPANIC(ESqlPanicInternalError)); if(idx >= 0) { CSqlCompactEntry* entry = iEntries[idx]; __ASSERT_DEBUG(entry != NULL, __SQLPANIC(ESqlPanicInternalError)); if(entry) { if(entry->Release() == 0) { iEntries.Remove(idx); #ifdef _DEBUG //This is used prevent the failure of the resource allocation checking for debug mode. if(iEntries.Count() == 0) { iEntries.Reset(); } #endif } } } SQLCOMPACTOR_INVARIANT(); }
// ----------------------------------------------------------------------------- // DDmcExtension::StateChangedDfc // Dfc function, called by IsaKernelIF when a channel state has been changed // ----------------------------------------------------------------------------- // void DDmcExtension::StateChangedDfc(TAny *aPtr) { OstTrace1(TRACE_ENTRY_EXIT, DDMC_STATE_CHANGED_DFC_ENTRY, "DMC:KERN_EXTEN: StateChangedDfc() # IN - aPtr: 0x%x", (TUint)(aPtr)); DMC_TRACE((("DMC:KERN_EXTEN: StateChangedDfc() # IN - aPtr: 0x%x"), aPtr)); DMC_TRACE_ASSERT_RESET(aPtr, "DMC:EH_APE_CEN: StateChangedDfc() - Kernel NULL pointer", KErrNoMemory); DDmcExtension* dmcExtPtr = static_cast<DDmcExtension*>(aPtr); OstTraceExt2(TRACE_FLOW, DDMC_STATE_CHANGED_DFC_1, "DMC:KERN_EXTEN: StateChangedDfc() - iIsaKernelAPIOpenStatus: %d, EIscConnectionOk: %d", dmcExtPtr->iIsaKernelModemStatus, EIscConnectionOk); DMC_TRACE((("DMC:KERN_EXTEN: StateChangedDfc() - iIsaKernelAPIOpenStatus: %d, EIscConnectionOk: %d"), dmcExtPtr->iIsaKernelModemStatus, EIscConnectionOk)); // A Modem connenction lost. if (dmcExtPtr->iIsaKernelModemStatus != EIscConnectionOk) { DmcEvHandApeCent::HandleEvent(KERNEL_EVENT_MODEM_CONNECTION_NOT_OK, NULL /* Kernel*/, NULL /* User */); } OstTrace0(TRACE_ENTRY_EXIT, DDMC_STATE_CHANGED_DFC_RETURN, "DMC:KERN_EXTEN: StateChangedDfc() # OUT"); DMC_TRACE(("DMC:KERN_EXTEN: StateChangedDfc() # OUT")); }
// --------------------------------------------------------------------------------- // CUpnpTmAppServerService::TerminateAppActionL // @param aAction pointer to upnp action object // @return Returns upnp error code // --------------------------------------------------------------------------------- // TUpnpErrorCode CUpnpTmAppServerService::TerminateAppActionL( CUpnpAction* aAction ) { OstTraceFunctionEntry0( CUPNPTMAPPSERVERSERVICE_TERMINATEAPPACTIONL_ENTRY ); // Validates the input parameters TUint appIdInt; TUint profileIdInt; if ( ( ConvertDescriptorToInt( aAction->ArgumentValue(KAppId), appIdInt ) != KErrNone ) || ( ConvertDescriptorToInt( aAction->ArgumentValue(KProfileId), profileIdInt ) != KErrNone )) { OstTraceExt2( TRACE_ERROR, CUPNPTMAPPSERVERSERVICE_TERMINATEAPPACTIONL, "CUpnpTmAppServerService::TerminateAppActionL;appIdInt=%u;profileIdInt=%u", appIdInt, profileIdInt ); return EInvalidArgs; // either invalid app ID or invalid profile ID } TTerminalModeErrorCode ret = iTmServerImpl.TerminateApp( appIdInt,profileIdInt ); if ( ret != ETerminalModeSuccess ) { // Error is returned aAction->SetArgumentL( KAppTerminateResult,KStatusFalse ); OstTrace0( TRACE_ERROR, DUP1_CUPNPTMAPPSERVERSERVICE_TERMINATEAPPACTIONL, "CUpnpTmAppServerService::TerminateAppActionL" ); return TUpnpErrorCode( ret ); } aAction->SetArgumentL( KAppTerminateResult,KStatusTrue); OstTraceFunctionExit0( CUPNPTMAPPSERVERSERVICE_TERMINATEAPPACTIONL_EXIT ); return EHttpOk; }
/** Commonly used step to load the USB Client Driver and set up * a High-Speed electrical test VID/PID pair * @return ETrue if the ldd loaded sucessfully */ TBool COtgRoot::StepChangeVidPid(TUint16 aVID, TUint16 aPID) { test.Printf(_L("Load USBCC HS Test Client 0x%04x/0x%04x\n"),aVID,aPID); OstTraceExt2(TRACE_NORMAL, COTGROOT_STEPCHANGEVIDPID, "Load USBCC HS Test Client 0x%04x/0x%04x\n",(TUint32)aVID,(TUint32)aPID); TInt err; // Set the revised VID/PID pair TBuf8<KUsbDescSize_Device> theDeviceDescriptor; err = oUsbcClient.GetDeviceDescriptor(theDeviceDescriptor); if (err != KErrNone) { AssertionFailed2(KErrAbort, _L("Client GetDes Fail "), err); return (EFalse); } TUint16 oldVID = ( theDeviceDescriptor[8] ) + ( theDeviceDescriptor[9] << 8 ); theDeviceDescriptor[8] = ( aVID & 0x00FF ); theDeviceDescriptor[9] = ( aVID & 0xFF00 ) >> 8; test.Printf(_L("..Change VID 0x%04X->0x%04X\n"), oldVID, aVID); OstTraceExt2(TRACE_NORMAL, COTGROOT_STEPCHANGEVIDPID_DUP01, "..Change VID 0x%04X->0x%04X\n", (TUint32)oldVID, (TUint32)aVID); TUint16 oldPID = ( theDeviceDescriptor[10] ) + ( theDeviceDescriptor[11] << 8 ); theDeviceDescriptor[10] = ( aPID & 0x00FF ); theDeviceDescriptor[11] = ( aPID & 0xFF00 ) >> 8; test.Printf(_L("..Change PID 0x%04X->0x%04X\n"), oldPID, aPID); OstTraceExt2(TRACE_NORMAL, COTGROOT_STEPCHANGEVIDPID_DUP02, "..Change PID 0x%04X->0x%04X\n", (TUint32)oldPID, (TUint32)aPID); err = oUsbcClient.SetDeviceDescriptor(theDeviceDescriptor); if (err != KErrNone) { AssertionFailed2(KErrAbort, _L("Client SetDes Fail "), err); return (EFalse); } // Default no-problem return return(ETrue); }
/** Set the free space of the drive in the storage info data set */ void CMTPGetStorageInfo::SetFreeSpaceInBytesL() { TMTPTypeUint64 mtpFreeSpace; if(iIsCDrive) { mtpFreeSpace.Set(0); } else { CRepository* repository(NULL); TInt thresholdValue(0); TRAPD(err,repository = CRepository::NewL(KCRUidUiklaf)); if (err == KErrNone) { err = repository->Get(KUikOODDiskFreeSpaceWarningNoteLevelMassMemory,thresholdValue); if (err == KErrNone) { OstTrace1( TRACE_NORMAL, CMTPGETSTORAGEINFO_SETFREESPACEINBYTESL, "Read from central repo:%d", thresholdValue); thresholdValue += KFreeSpaceExtraReserved; } delete repository; } if (err != KErrNone) { OstTrace0( TRACE_WARNING, DUP1_CMTPGETSTORAGEINFO_SETFREESPACEINBYTESL, "Fail in read ,use default" ); thresholdValue = KFreeSpaceThreshHoldDefaultValue + KFreeSpaceExtraReserved; } OstTraceExt2( TRACE_NORMAL, DUP2_CMTPGETSTORAGEINFO_SETFREESPACEINBYTESL, "threshold:%d free space:%Ld",thresholdValue,iVolumeInfo.iFree ); //Exclude the reserved disk space when reporting free space TInt64 free = (iVolumeInfo.iFree > thresholdValue) ? (iVolumeInfo.iFree - thresholdValue) : 0; mtpFreeSpace.Set(free); OstTrace1( TRACE_NORMAL, DUP3_CMTPGETSTORAGEINFO_SETFREESPACEINBYTESL, "set free:%ld", free); } OstTraceExt2( TRACE_NORMAL, DUP4_CMTPGETSTORAGEINFO_SETFREESPACEINBYTESL, "SetFreeSpaceInBytesL volume free:%Ld report:%Ld", iVolumeInfo.iFree,mtpFreeSpace.Value()); iStorageInfo->SetL(CMTPTypeStorageInfo::EFreeSpaceInBytes, mtpFreeSpace); }
/** Save the object properties before doing the copy */ void CMTPImageDpCopyObject::GetPreviousPropertiesL(const TDesC& aOldFileName) { OstTraceFunctionEntry0( CMTPIMAGEDPCOPYOBJECT_GETPREVIOUSPROPERTIESL_ENTRY ); LEAVEIFERROR(iFramework.Fs().Modified(aOldFileName, iDateModified), OstTraceExt2( TRACE_ERROR, CMTPIMAGEDPCOPYOBJECT_GETPREVIOUSPROPERTIESL, "Gets the last modification date and time failed for %S! error code %d", aOldFileName, munged_err )); OstTraceFunctionExit0( CMTPIMAGEDPCOPYOBJECT_GETPREVIOUSPROPERTIESL_EXIT ); }
/** Process an SQL statement contained in the configuration file and executes it if it is a supported statement. Currently only 'CREATE INDEX' statements are supported. The statement can contain comments that are understood by SQLite - these can be in the form of an SQL comment or a 'C' comment, as defined at http://www.sqlite.org/lang_comment.html. @param aStmt An SQL statement string, stripped of any whitespace at the beginning of it @param aDbName Logical database name: "main" for the main database or attached database name @leave KErrNoMemory, if an out of memory condition occurs */ void TSqlDbSysSettings::ProcessStatementL(const TDesC& aStmt, const TDesC& aDbName) { SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL_ENTRY, "Entry;0x%X;TSqlDbSysSettings::ProcessStatementL;Processing statement '%S'", (TUint)this, __SQLPRNSTR(aStmt))); //If the statement only contained whitespace then just return if(aStmt.Length() == 0) { SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL_EXIT1, "Exit;0x%X;TSqlDbSysSettings::ProcessStatementL;The statement ignored because contains only whitespace", (TUint)this)); return; } //Check that the statement does not contain an unsupported comment style if(KErrNotFound != aStmt.Find(_L("//"))) { //The statement contains '//' which is an unsupported comment style, but rather //than leave here and cause the full file to fail, we just ignore this statement SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL_EXIT2, "Exit;0x%X;TSqlDbSysSettings::ProcessStatementL;The statement ignored because contains invalid comment style", (TUint)this)); return; } HBufC* stmtBuf = HBufC::NewLC(aStmt.Length() + 1 + aDbName.Length() + 1); TPtr stmtPtr = stmtBuf->Des(); //If the 'aStmt' string is an SQL statement that is supported then execute it if(::IsStatementSupported(aStmt, aDbName, stmtPtr)) { TInt err = ::DbExecStmt16(iDbHandle, stmtPtr); if(KErrNone == err) { SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL1, "0x%X;TSqlDbSysSettings::ProcessStatementL;Successfully executed statement", (TUint)this)); } else { SQL_TRACE_INTERNALS(OstTraceExt2(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL2, "0x%X;TSqlDbSysSettings::ProcessStatementL;Failed to execute the statement;err=%d", (TUint)this, err)); if(err == KErrNoMemory) { __SQLLEAVE(err); } } } else { SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL3, "0x%X;TSqlDbSysSettings::ProcessStatementL;Non-supported statement, will be ignored", (TUint)this)); } CleanupStack::PopAndDestroy(); // stmtBuf SQL_TRACE_INTERNALS(OstTrace1(TRACE_INTERNALS, TSQLDBSYSSETTINGS_PROCESSSTATEMENTL_EXIT3, "Exit;0x%X;TSqlDbSysSettings::ProcessStatementL", (TUint)this)); }
void CUT_PBASE_T_USBDI_0479::DeviceInsertedL(TUint aDeviceHandle) { OstTraceFunctionEntryExt( CUT_PBASE_T_USBDI_0479_DEVICEINSERTEDL_ENTRY, this ); Cancel(); TInt err(KErrNone); // Validate that device is as expected CUsbTestDevice& testDevice = iActorFDF->DeviceL(aDeviceHandle); if(testDevice.SerialNumber().Compare(TestCaseId()) != 0) { // Incorrect device for this test case OstTraceExt3(TRACE_NORMAL, CUT_PBASE_T_USBDI_0479_DEVICEINSERTEDL, "<Warning %d> Incorrect device serial number (%S) connected for this test case (%S)", KErrNotFound,testDevice.SerialNumber(),TestCaseId()); // Start the connection timeout again TimeoutIn(30); OstTraceFunctionExit1( CUT_PBASE_T_USBDI_0479_DEVICEINSERTEDL_EXIT, this ); return; } TUint32 validToken; TUint32 invalidToken(KMaxTUint-1); // The known invalid token err = testDevice.Device().GetTokenForInterface(0,validToken); if(err != KErrNone) { OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_0479_DEVICEINSERTEDL_DUP01, "<Error %d> Token for interface could not be retrieved",err); return TestFailed(err); } err = iUsbInterface0.Open(validToken); // Default interface setting 0 if(err != KErrNone) { OstTraceExt2(TRACE_NORMAL, CUT_PBASE_T_USBDI_0479_DEVICEINSERTEDL_DUP02, "<Error %d> Unable to open interface 0 using token %d",err,validToken); return TestFailed(err); } err = iDuplicateUsbInterface0.Open(invalidToken); if(err == KErrNone) { TBuf<64> msg; msg.Format(_L("<Error %d> Able to open an interface that is not present"),KErrCorrupt); OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0479_DEVICEINSERTEDL_DUP03, msg); iCaseStep = EFailed; TTestCaseFailed request(KErrCorrupt,msg); iClientAction->SendRequest(request,this); } else { OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_0479_DEVICEINSERTEDL_DUP04, "Opening interface with invalid token failed with %d",err); User::After(1000000); iCaseStep = EPassed; TTestCasePassed request; iClientAction->SendRequest(request,this); } OstTraceFunctionExit1( CUT_PBASE_T_USBDI_0479_DEVICEINSERTEDL_EXIT_DUP01, this ); }
/** Connects the RFs. If the operation fails, the program will be terminated. @see TStaticFs */ TStaticFs::TStaticFs() { TInt err = Connect(); if(err != KErrNone) { SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TSTATICFS_TSTATICFS, "OS;0x%X;TStaticFs::TStaticFs;err=%d", (TUint)this, err)); User::Exit(err); } }
/** Creates the static mutexes. If the creation fails, the program will be terminated. @see TStaticMutex */ TStaticMutex::TStaticMutex() { TInt err = Create(); if(err != KErrNone) { SQLITE_TRACE_OS(OstTraceExt2(TRACE_INTERNALS, TSTATICMUTEX_TSTATICMUTEX, "OS;0x%X;TStaticMutex::TStaticMutex;err=%d", (TUint)this, err)); User::Exit(err); } }
// --------------------------------------------------------------------------- // destructor, nothing to destruct // --------------------------------------------------------------------------- // CFlexTimerItem::~CFlexTimerItem() { OstTraceExt2( TRACE_INTERNAL, DUP1_CFLEXTIMERITEM_CFLEXTIMERITEM, "CFlexTimerItem::~CFlexTimerItem;this=%x;iMFlexTimerServiceCB=%x", ( TUint )this, ( TUint )iMFlexTimerServiceCB ); //Nothing to do here }
/** * GetSet * * @param aFunc Function choosed (@see ETraceCoreOstLddIfGetSet) * @return TDfc* if aFunc is EGetDfc, TDes8* EGetBuf and 0 with ESetWriter. */ EXPORT_C TUint32 DTraceCoreOstLddIf::GetSet(TTraceCoreOstLddIfGetSet aFunc, TUint32 aParam) { OstTraceExt2( TRACE_FLOW, DTRACECOREOSTLDDIF_GETSET_ENTRY, "> DTraceCoreOstLddIf::GetSet aFunc:%d, aParam:%d", aFunc, aParam ); TUint32 ret(0); switch(aFunc) { case EGetDfc: { TraceCoreOstLddIf->iTraceCoreOstConnectionRegistered = ETrue; ret = reinterpret_cast<TUint32>(&(TraceCoreOstLddIf->iReceiveDfc)); break; } case EGetBuf: { ret = reinterpret_cast<TUint32>(&(TraceCoreOstLddIf->iReceiveBuffer)); break; } case ESetWriter: { // Set Writer to XTI if parameter is 0, otherwise USB DTraceCore* traceCore = DTraceCore::GetInstance(); if ( traceCore != NULL ) { // TraceSwitch uses 0 for XTI writer and 1 to OST writer // So it is not mapping one to one to enum found in TraceCoreWriter.h // for example to EWriterTypeXTI = 1 // See TraceCoreWriter.h if(aParam==0) { traceCore->SwitchToWriter(EWriterTypeXTI); } else if(aParam==1) { traceCore->SwitchToWriter(EWriterTypeUSBPhonet); } // For other writers (>2) we use same as the enum else if(aParam > EWriterTypeUSBPhonet) { traceCore->SwitchToWriter((TWriterType) aParam); } } break; } case ERegister: { TraceCoreOstLddIf->iTraceCoreOstConnection = (MTraceCoreOstConnectionIf*)aParam; break; } default: __ASSERT_DEBUG( EFalse, Kern::Fault( "DTraceCoreOstLddIf::GetSet: Default case!", KErrArgument ) ); break; } return ret; }
void CHelloTraceFn::PreProcessedFn(TInt aDbgParam) { OstTraceExt2( TRACE_FLOW, CHELLOTRACEFN_PREPROCESSEDFN_ENTRY_1, "CHelloTraceFn::PreProcessedFn: > CHelloTraceFn::PreProcessedFn;aDbgParam=%d;this=%x", (TInt) aDbgParam, (TUint) this); #else void CHelloTraceFn::PreProcessedFn() { OstTrace1( TRACE_FLOW, CHELLOTRACEFN_PREPROCESSEDFN_ENTRY_2, "CHelloTraceFn::PreProcessedFn: > CHelloTraceFn::PreProcessedFn;this=%x", (TUint) this); #endif Simple(); OstTrace1( TRACE_FLOW, CHELLOTRACEFN_PREPROCESSEDFN_EXIT, "CHelloTraceFn::PreProcessedFn: < CHelloTraceFn::PreProcessedFn;this=%x", (TUint) this); }
// ----------------------------------------------------------------------------- // CDpPn2Rx::RunError // Leave in RunL() is handled here. Error code is returned, // when internal error has occured. // ----------------------------------------------------------------------------- // TInt CDpPn2Rx::RunError( TInt aError ) { OstTrace0( TRACE_NORMAL, CDPPN2RX_RUNERROR, "CDpPn2Rx::RunError" ); OstTraceExt2( TRACE_NORMAL, DUP1_CDPPN2RX_RUNERROR, "CDpPn2Rx:: Port: %u, error code: %d", iDataPort.PortUnit(), aError ); LOGM2("CDpPn2Rx::RunError - Port %d, error code: %d", iDataPort.PortUnit(), aError ); return aError; }
/** A helper function of MoveObjectL. @param aNewFileName the new file name after the object is moved. */ void CMTPMoveObject::MoveFileL(const TDesC& aNewFileName) { OstTraceFunctionEntry0( CMTPMOVEOBJECT_MOVEFILEL_ENTRY ); const TDesC& suid(iObjectInfo->DesC(CMTPObjectMetaData::ESuid)); GetPreviousPropertiesL(suid); if(iFramework.StorageMgr().DriveNumber(iObjectInfo->Uint(CMTPObjectMetaData::EStorageId)) == iFramework.StorageMgr().DriveNumber(iStorageId)) //Move file to the same storage { LEAVEIFERROR(iFileMan->Move(suid, *iDest), OstTraceExt2( TRACE_ERROR, CMTPMOVEOBJECT_MOVEFILEL, "move %S to %S failed!", suid, *iDest )); SetPreviousPropertiesL(aNewFileName); iObjectInfo->SetDesCL(CMTPObjectMetaData::ESuid, aNewFileName); iObjectInfo->SetUint(CMTPObjectMetaData::EStorageId, iStorageId); iObjectInfo->SetUint(CMTPObjectMetaData::EParentHandle, iNewParentHandle); iFramework.ObjectMgr().ModifyObjectL(*iObjectInfo); SendResponseL(EMTPRespCodeOK); } else //Move file between different storages { delete iNewFileName; iNewFileName = NULL; iNewFileName = aNewFileName.AllocL(); // Store the new file name LEAVEIFERROR(iFileMan->Move(suid, *iDest, CFileMan::EOverWrite, iStatus), OstTraceExt2( TRACE_ERROR, DUP1_CMTPMOVEOBJECT_MOVEFILEL, "move %S to %S failed!", suid, *iDest)); if ( !IsActive() ) { SetActive(); } delete iTimer; iTimer = NULL; iTimer = CPeriodic::NewL(EPriorityStandard); TTimeIntervalMicroSeconds32 KMoveObjectIntervalNone = 0; iTimer->Start(TTimeIntervalMicroSeconds32(KMoveObjectTimeOut), KMoveObjectIntervalNone, TCallBack(CMTPMoveObject::OnTimeoutL, this)); } OstTraceFunctionExit0( CMTPMOVEOBJECT_MOVEFILEL_EXIT ); }
// --------------------------------------------------------- // CDpMif::RunError // Leave in RunL() is handled here. Error code is returned, // when internal error has occured. // --------------------------------------------------------- // TInt CDpMif::RunError( TInt aError ) { OstTrace0( TRACE_NORMAL, CDPMIF_RUNERROR, "CDpMif::RunError" ); LOGM2("CDpMif::RunError - Port %d, error code: %d", iDataPort.PortUnit(), aError ); OstTraceExt2( TRACE_NORMAL, DUP1_CDPMIF_RUNERROR, "CDpMif:: Port: %u, error code: %d", iDataPort.PortUnit(), aError ); // Message was not necessarily freed, if leave happened. iReceiveMessage.Zero(); return aError; }
// ----------------------------------------------------------------------------- // CDpPn2Rx::RunL // This active object is signalled by Isc Api. // We will renew read to Isc Api. // ----------------------------------------------------------------------------- // void CDpPn2Rx::RunL() { OstTrace0( TRACE_NORMAL, CDPPN2RX_RUNL, "CDpPn2Rx::RunL" ); OstTraceExt2( TRACE_NORMAL, DUP1_CDPPN2RX_RUNL, "CDpPn2Rx:: Port: %u, Status: %d", iDataPort.PortUnit(), iStatus.Int() ); LOGM2("CDpPn2Rx::RunL - Port %d, Status: %d ", iDataPort.PortUnit(), iStatus.Int() ); iRequestActive = EFalse; User::LeaveIfError( Read() ); // don't set iStatus nor set_active here as it is better done in functions }
TInt CUT_PBASE_T_USBDI_1231::Interface0ResumedL(TAny* aPtr) { OstTraceFunctionEntryExt( CUT_PBASE_T_USBDI_1231_INTERFACE0RESUMEDL_ENTRY, 0 ); OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_1231_DCUT_PBASE_T_USBDI_1231_DUP12, "====> Interface0ResumedL entry priority = %d", RThread().Priority()); OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_1231_DCUT_PBASE_T_USBDI_1231_DUP13, "-Interface 0 resumed"); CUT_PBASE_T_USBDI_1231* self = reinterpret_cast<CUT_PBASE_T_USBDI_1231*>(aPtr); TInt completionCode=self->iInterface0Watcher->CompletionCode(); #ifdef OST_TRACE_COMPILER_IN_USE TInt testStep = self->iCaseStep; #endif OstTraceExt2(TRACE_NORMAL, CUT_PBASE_T_USBDI_1231_DCUT_PBASE_T_USBDI_1231_DUP14, " -watcher 0 iStatus = %d <teststep %d>",completionCode, testStep); self->iInterface0Resumed = ETrue; switch (self->iCaseStep) { case EValidResumeWhenSuspending: { if (completionCode == KErrNone) { OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_1231_DCUT_PBASE_T_USBDI_1231_DUP15, "Device resume while suspending succeed!"); self->TimeoutIn(10); self->iCaseStep = EPassed; self->SendEp0Request(); } else { RDebug::Printf( "Device resume while suspending failed,<err %d>", completionCode); self->iCaseStep = EFailed; self->SendEp0Request(); } } break; default: break; }; OstTraceFunctionExitExt( CUT_PBASE_T_USBDI_1231_INTERFACE0RESUMEDL_EXIT, 0, KErrNone ); return KErrNone; }
void CUT_PBASE_T_USBDI_0474::DeviceInsertedL(TUint aDeviceHandle) { OstTraceFunctionEntryExt( CUT_PBASE_T_USBDI_0474_DEVICEINSERTEDL_ENTRY, this ); Cancel(); TInt err(KErrNone); // Validate that device is as expected CUsbTestDevice& testDevice = iActorFDF->DeviceL(aDeviceHandle); if(testDevice.SerialNumber().Compare(TestCaseId()) != 0) { // Incorrect device for this test case OstTraceExt3(TRACE_NORMAL, CUT_PBASE_T_USBDI_0474_DEVICEINSERTEDL, "<Warning %d> Incorrect device serial number (%S) connected for this test case (%S)", KErrNotFound,testDevice.SerialNumber(),TestCaseId()); // Start the connection timeout again TimeoutIn(30); OstTraceFunctionExit1( CUT_PBASE_T_USBDI_0474_DEVICEINSERTEDL_EXIT, this ); return; } // Check tree now TUsbGenericDescriptor deviceDesc = testDevice.DeviceDescriptor(); TUsbGenericDescriptor configDesc = testDevice.ConfigurationDescriptor(); // Check tree now CHECK(CheckTreeAfterDeviceInsertion(testDevice, _L("RDeviceB")) == KErrNone); // Inform client device test case successful TUint32 token0; err = testDevice.Device().GetTokenForInterface(0,token0); if(err != KErrNone) { OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_0474_DEVICEINSERTEDL_DUP01, "<Error %d> Token for interface 0 could not be retrieved",err); return TestFailed(err); } err = iUsbInterface0.Open(token0); // Default interface setting 0 if(err != KErrNone) { OstTraceExt2(TRACE_NORMAL, CUT_PBASE_T_USBDI_0474_DEVICEINSERTEDL_DUP02, "<Error %d> Unable to open interface 1 using token %d",err,token0); return TestFailed(err); } iCaseStep = EPassed; TTestCasePassed request; iClientAction->SendRequest(request,this); OstTraceFunctionExit1( CUT_PBASE_T_USBDI_0474_DEVICEINSERTEDL_EXIT_DUP01, this ); }
TInt CSBEParserProxy::ConvertToUnicodeL( TDes16& aUnicode, const TDesC8& aForeign ) { OstTraceFunctionEntry0( CSBEPARSERPROXY_CONVERTTOUNICODEL_ENTRY ); const TInt error = iConverter->ConvertToUnicode( aUnicode, aForeign, iConverterState ); if ( error != KErrNone ) { HBufC* copy = HBufC::NewL( aForeign.Length() * 2 ); copy->Des().Copy( aForeign ); OstTraceExt2(TRACE_NORMAL, CSBEPARSERPROXY_CONVERTTOUNICODEL, "error: %d when converting: %S", error, *copy ); delete copy; } OstTraceFunctionExit0( CSBEPARSERPROXY_CONVERTTOUNICODEL_EXIT ); return error; }
/** Set the object properties after doing the copy */ void CMTPImageDpCopyObject::SetPreviousPropertiesL(const TDesC& aNewFileName) { OstTraceFunctionEntry0( CMTPIMAGEDPCOPYOBJECT_SETPREVIOUSPROPERTIESL_ENTRY ); LEAVEIFERROR(iFramework.Fs().SetModified(aNewFileName, iDateModified), OstTraceExt2( TRACE_ERROR, CMTPIMAGEDPCOPYOBJECT_SETPREVIOUSPROPERTIESL, "Sets the date and time for %S failed. Error code %d", aNewFileName, munged_err)); iTargetObjectInfo = CMTPObjectMetaData::NewL(); iTargetObjectInfo->SetUint(CMTPObjectMetaData::EDataProviderId, iSrcObjectInfo->Uint(CMTPObjectMetaData::EDataProviderId)); iTargetObjectInfo->SetUint(CMTPObjectMetaData::EFormatCode, iSrcObjectInfo->Uint(CMTPObjectMetaData::EFormatCode)); iTargetObjectInfo->SetUint(CMTPObjectMetaData::EFormatSubCode, iSrcObjectInfo->Uint(CMTPObjectMetaData::EFormatSubCode)); iTargetObjectInfo->SetDesCL(CMTPObjectMetaData::EName, iSrcObjectInfo->DesC(CMTPObjectMetaData::EName)); iTargetObjectInfo->SetUint(CMTPObjectMetaData::ENonConsumable, iSrcObjectInfo->Uint(CMTPObjectMetaData::ENonConsumable)); iTargetObjectInfo->SetUint(CMTPObjectMetaData::EParentHandle, iNewParentHandle); iTargetObjectInfo->SetUint(CMTPObjectMetaData::EStorageId, iStorageId); iTargetObjectInfo->SetDesCL(CMTPObjectMetaData::ESuid, aNewFileName); OstTraceFunctionExit0( CMTPIMAGEDPCOPYOBJECT_SETPREVIOUSPROPERTIESL_EXIT ); }
/** Get a default parent object, ff the request does not specify a parent object, */ void CMTPImageDpCopyObject::SetDefaultParentObjectL() { OstTraceFunctionEntry0( CMTPIMAGEDPCOPYOBJECT_SETDEFAULTPARENTOBJECTL_ENTRY ); TDriveNumber drive(static_cast<TDriveNumber>(iFramework.StorageMgr().DriveNumber(iStorageId))); LEAVEIFERROR(drive, OstTraceExt2( TRACE_ERROR, CMTPIMAGEDPCOPYOBJECT_SETDEFAULTPARENTOBJECTL, "No driver number for %d! error code %d",iStorageId, munged_err)); TChar driveLetter; iFramework.Fs().DriveToChar(drive, driveLetter); TFileName driveBuf; driveBuf.Append(driveLetter); driveBuf = BaflUtils::RootFolderPath(driveBuf.Left(1)); delete iDest; iDest = NULL; iDest = driveBuf.AllocL(); iNewParentHandle = KMTPHandleNoParent; OstTraceFunctionExit0( CMTPIMAGEDPCOPYOBJECT_SETDEFAULTPARENTOBJECTL_EXIT ); }