void CTcpSymbianEngine::StartLookupL()
{
   DBG("StartLookupL");
   SetEngineState(ELookingUp);
   // Initiate DNS
   if(KErrNone == 
#if defined NAV2_CLIENT_SERIES60_V3  && !defined __WINS__ && !defined __WINSCW__
      iResolver.Open(iSocketServ, KAfInet,
                     KProtocolInetUdp, iConnection)
#else
      iResolver.Open(iSocketServ, KAfInet, KProtocolInetUdp)
#endif
      ){

      if(KErrNone == iDNSCache.CacheHostLookup(*iHostName, iNameEntry, iPort)){
         DBG("Host found in cache");
         CompleteSelf(KErrNone);
      } else {
         DBG("Host not found in cache, looking up in DNS");
         // DNS request for name resolution
         iResolver.GetByName(*iHostName, iNameEntry, iStatus);
         SetActive();
      }
      // Request time out
      iTimer->After(iTimeOut);
      //signal state
      iConsole.ConnectionNotify(isab::Module::CONNECTING,
                                 isab::Module::REQUESTED);
      DBG("Starting asynchronous name lookup");
   } else {
      WARN("Lookup failed");
      ResetL(ELookUpFailed, isab::Module::LOOKUP_FAILED);
   }
}
// --------------------------------------------------------------------------
// CUPnPAVRenderingSessionImpl::SetNextURIL
// See upnpavrenderingsessionimpl.h
// --------------------------------------------------------------------------
void CUPnPAVRenderingSessionImpl::SetNextURIL( const TDesC8& aURI,
    const CUpnpItem& aItem )    
    {
    ResetL();
    
    iCommandActive->SetNextURIL( aURI, aItem );     
    }
void CTcpSymbianEngine::ResetL(enum TEchoEngineState aDuring, 
                         enum isab::Module::ConnectionNotifyReason aReason)
{
   SetEngineState(aDuring);
   iConsole.ConnectionNotify(isab::Module::DISCONNECTING, aReason);
   ResetL(aDuring);
}
Exemplo n.º 4
0
void CPopsTestHarness::TestLocalCopyL(const TDesC& aPassText, const TDesC& aFailText)
// ------------------------------------------------------------------
// Test Copying from a Local folder to another Local Folder
// ------------------------------------------------------------------
	{
	iTestError = 0;
	iTestNumber++;

	// Reset the harness & run the Test
	iTestUtils->FileSession().Delete(KMsvTestFillDiskFile);
	ResetL();
	iTestUtils->TestStart(iTestNumber);
	TRAPD(error, DoLocalCopyTestL());

		// Delete the fill file, so we can write to the log
	iTestUtils->FileSession().Delete(KMsvTestFillDiskFile);

	if (error == KErrDiskFull)
		{
		// Test OK = We could not Copy, as the disk was too Full
		iTestUtils->WriteComment(aPassText);
		}
	else if (error == KErrNone)
		{
		// ERROR - The Copy completed, even though the Disk was Full
		iTestUtils->WriteComment(aFailText);
		iTestError = KErrGeneral;
		}

	EndTestL();
	}
Exemplo n.º 5
0
void CPopsTestHarness::SetUpTestL(const TDesC& aScriptFile)
	{
	// Delete any old dummy fill files 
	iTestUtils->FileSession().Delete(KMsvTestFillDiskFile);

	// Reset & Copy the script file before filling the Disk
	ResetL();
	CopyScriptFileL(aScriptFile); 
	}
/**
Reads the URI list from the server. The server stream handle is already setup.
*/
TInt CUriListReadStream::ReadUriListL ()
	{
	// Reset the stream
	ResetL ();
	TPtr8 ptr ( iIpcBuffer->Ptr(0) );
	TInt result = iListSession.ReadQueryResults ( iHandle, ptr );	
	User::LeaveIfError ( result );
	return result;
	}
// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CLbtRamTriggersClientSIDTree::~CLbtRamTriggersClientSIDTree()
    {
    TRAPD(err, ResetL());
    if( KErrNone != err )
        {
        // TODO: Log warning message that entries could not be deleted
        }
    delete iTriggerList;
    delete iPool;
    }
Exemplo n.º 8
0
/*
-------------------------------------------------------------------------------

    Class: COomTestHarness

    Method: ConstructL

    Description: Symbian 2nd phase constructor that can leave.

    Note: If OOM test case uses STIF Logger, then STIF Logger must be created
    with static buffer size parameter (aStaticBufferSize). Otherwise Logger 
    allocates memory from heap and therefore causes error situations with OOM 
    testing. For more information about STIF Logger construction, see STIF 
    Users Guide.

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Approved

-------------------------------------------------------------------------------
*/
void COomTestHarness::ConstructL()
    {
    //Read logger settings to check whether test case name is to be
    //appended to log file name.
    RSettingServer settingServer;
    TInt ret = settingServer.Connect();
    if(ret != KErrNone)
        {
        User::Leave(ret);
        }
    // Struct to StifLogger settigs.
    TLoggerSettings loggerSettings; 
    // Parse StifLogger defaults from STIF initialization file.
    ret = settingServer.GetLoggerSettings(loggerSettings);
    if(ret != KErrNone)
        {
        User::Leave(ret);
        } 
    // Close Setting server session
    settingServer.Close();
    iAddTestCaseTitleToLogName = loggerSettings.iAddTestCaseTitle;
    
    // Constructing static buffer size logger, needed with OOM testing because
    // normally logger allocates memory from heap!
    iStdLog = CStifLogger::NewL( KT_OomHarnessLogPath, 
                              KT_OomHarnessLogFile,
                              CStifLogger::ETxt,
                              CStifLogger::EFile,
                              ETrue,
                              ETrue,
                              ETrue,
                              EFalse,
                              ETrue,
                              EFalse,
                              100 );
    iLog = iStdLog;
    
    // Sample how to use logging
    _LIT( KLogInfo, "t_oomharness logging starts!" );
    iLog->Log( KLogInfo );
    
	User::LeaveIfError(iAllocServer.Connect());
	User::LeaveIfError(iOomSession.Connect());
	
	User::LeaveIfError(iChunk.CreateLocal(KOomHarnessInitialEatenMemory, KOomHarnessMaxEatenMemory));
	iChunkSize = KOomHarnessInitialEatenMemory;
	
    iScheduler = new (ELeave) CActiveScheduler;
    CActiveScheduler::Install( iScheduler );
    
    iStatusWatcher = CMemoryMonitorStatusWatcher::NewL();
    iTimeoutWatcher = CMemoryMonitorTimeoutWatcher::NewL();
    
	ResetL();
    }
void COggVorbisFile::CBody::ConstructL()
    {
#ifdef SEP_HEAP    
    User::LeaveIfError(iVorbisChunk.CreateLocal(0x4000, 0x20000, EOwnerThread));
    iVorbisHeap = User::ChunkHeap(iVorbisChunk, 0x2000);
    
    iDefaultHeap = &User::Heap();
#endif
    
    ResetL();
    }
void CVBookmarkConverter::ImportDbItemL( const CFolderItem& aItem )
    {
    ResetL();
    
    if( aItem.IsFolder() )
        {
        User::Leave( KErrNotSupported );
        }
    
    SetVersionL( KVBMKVer );
    SetUrlL( aItem.SourceUrl() );
    SetInternetShortcutL( aItem.SourceUrl() );
    SetTitleL( aItem.Name() );
    }
void CVBookmarkConverter::ImportDbItemL( const CFavouritesItem& aItem )
    {
    ResetL();
    
    if( aItem.Type() != CFavouritesItem::EItem )
        {
        User::Leave( KErrNotSupported );
        }
    
    SetVersionL( KVBMKVer );
    SetUrlL( aItem.Url() );
    SetInternetShortcutL( aItem.Url() );
    SetTitleL( aItem.Name() );
    }
Exemplo n.º 12
0
/** Implements CAnimator::DataEventL.*/
void CBitmapAnimator::DataEventL(TInt aEvent, TAny* aData, TInt aDataLength)
	{
	switch (aEvent)
		{
		case EBitmapAnimationNewFrame:
			__ASSERT_ALWAYS(aDataLength==sizeof(CAnimationFrame::THandles),User::Leave(KErrArgument));
			AppendFrameL(*static_cast<CAnimationFrame::THandles*>(aData));
			break;
		case EBitmapAnimationComplete:
			InitialisedL();
			break;
		case EAnimationDataChanged:
			ResetL();
			break;
		default:
			break;
		}
	}
// --------------------------------------------------------------------------
// CUPnPAVRenderingSessionImpl::ReleaseLocalMSServicesL
// See upnpavrenderingsessionimpl.h
// --------------------------------------------------------------------------
void CUPnPAVRenderingSessionImpl::ReleaseLocalMSServicesL()
    {  
    ResetL();
    
    iCommandActive->ReleaseLocalMSServicesL();
    }
TInt CVBookmarkConverter::ImportVBookmarkL( const TDesC8& aBuffer )
    {
    LOGGER_ENTERFN( "CVBookmarkConverter::ImportVBookmarkL" );
    
    ResetL();
        
    TInt error = KErrNone;
    TInt position = 0;
    TPtrC8 tag;
    TPtrC8 value;
    TPtrC8 properties;
    error = ReadTagAndValue( aBuffer, position, tag, value, properties );
    if( error != KErrNone )
        {
        LOGGER_WRITE_1( "ReadTagAndValue err: %d", error );
        return error;
        }
        
    if ( ( tag != KVBMKBegin ) || ( value != KVBMKVbkm ) )
        {
        LOGGER_WRITE( "Invalid tag" );
        return KErrNotFound;
        }
    
    while ( ( error = ReadTagAndValue( aBuffer, position, tag, value, properties ) ) == KErrNone )
        {
        // Version
        if ( tag == KVBMKVersion )
            {
            SetVersionL( value );
            }
        
        // Url
        else if ( tag == KVBMKUrl )
            {
            SetUrlL( value );
            }
        
        // Title
        else if ( tag == KVBMKTitle )
            {
            TBookmarkEncoding encoding = Encoding( properties );
            SetTitleL( value, encoding );
            }
            
        // Beginning of envelope    
        else if ( ( tag == KVBMKBegin ) && ( value == KVBMKEnv ) )
            {
            // Read the envelope, quit if error
            error = ReadEnvelopeL( aBuffer, position );
            if( error != KErrNone )
                {
                return error;
                }
            }       
                
        // End of Bookmark
        else if ( ( tag == KVBMKEnd ) && ( value == KVBMKVbkm ) )
            {
            return error;
            }
        
        else
            {
            // Unknown data, skip
            }
        }

    LOGGER_LEAVEFN( "CVBookmarkConverter::ImportVBookmarkL" );      
    return error;
    }
void CTcpSymbianEngine::RunL()
{
   DBG("RunL, EngineState: %d, iStatus: %d", EngineState(), iStatus.Int());
   iTimer->Cancel(); // Cancel TimeOut timer before handling completion
   switch(EngineState()){
   case EConnecting:
      // IP connection request
      if (iStatus == KErrNone){
         DBG("Connection completed Ok");
         // Connection completed sucessfully   
         iConsole.ConnectionNotify(isab::Module::CONNECTED,
                                    isab::Module::REQUESTED);
         SetEngineState(EConnected);
         Read(); //Start CTcpSymbianRead Active object
      } else {
         WARN("Unable to connect, removing host from cache.");
         iDNSCache.Remove(*iHostName);
         if (iStatus == KErrCouldNotConnect){
            ResetL(EConnectFailed, isab::Module::NO_RESPONSE);
         } else if (iStatus == KErrTimedOut) {
            ResetL(ETimedOut, isab::Module::NO_RESPONSE);
         } else{
            WARN("EConnectFailed, INTERNAL_ERROR");
            ResetL(EConnectFailed, isab::Module::INTERNAL_ERROR);
            //XXX handle the different cases
         }
      }
      break;
   case ELookingUp:
      iResolver.Close();
      if (iStatus == KErrNone) {
         DBG("Name lookup ok");
         // DNS look up successful
         // Extract domain name and IP address from name record
         class TInetAddr addr = TInetAddr::Cast(iNameEntry().iAddr);
         //cache the ip for later.
         TInt cacheStat = iDNSCache.CacheHost(*iHostName, addr.Address());
         DBG("Host cached with result %d", cacheStat);
         cacheStat = cacheStat;
         // And connect to the IP address
         Connect(addr.Address(), iPort); //setactive here
      } else { //includes KErrTimedOut
         WARN("Lookup failed");
         ResetL(ELookUpFailed, isab::Module::LOOKUP_FAILED);
      }
      break;
   case ELinking:
      if(iStatus == KErrNone){
         DBG("Link layer setup ok");
         OpenSocketL();  //cannot open socket until here. We need RConnection.
         StartLookupL(); //setactive here
      } else { //includes KErrCanceled and KErrTimedOut
         WARN("Link layer setup failed");
         ResetL(ELinkFailed, isab::Module::TRANSPORT_FAILED);
      }
      break;
   case EBroken:
      DBG("Broken");
      ResetL( EngineState(), isab::Module::CHANNEL_FAILED );
      break;
   case EClosing:
      if(iStatus == KErrNone){
         DBG("Closing ok");
         ResetL(EComplete, isab::Module::REQUESTED);
      } else if(iStatus == KErrTimedOut){
         ResetL(ETimedOut);
      } else {
         ResetL(EngineState());
         //XXX ???
      }
      break;
   case ESwitching:
      if(iStatus == KErrNone){
         //the connection has been closed, start a new connection
         //using the values in iHostName, iPort, and iIAP.
         SetEngineState(EComplete);
         ConnectL();
      } else if(iStatus == KErrTimedOut){
         ResetL(ETimedOut);
      } else {
         ResetL(EngineState());
      }
      break;
   case EClosed:
      DBG("Closed");
      ResetL( EngineState(), isab::Module::BY_PEER );
      break;
   default:
      ERR("PANIC KEchoEngine EBadEngineState (%d)", TInt(EBadEngineState));
      User::Panic(KEchoEngine, EBadEngineState);
      break;
   };
   if(!IsActive()){
      DBG("Signal OperationComplete");
      iConsole.OperationComplete();
      DBG("Signaled OperationComplete");
   }
}
// --------------------------------------------------------------------------
// CUPnPAVRenderingSessionImpl::GetMuteL
// See upnpavrenderingsessionimpl.h
// --------------------------------------------------------------------------
void CUPnPAVRenderingSessionImpl::GetMuteL()
    {
    ResetL();
    
    iSettingActive->GetMuteL();           
    }
// --------------------------------------------------------------------------
// CUPnPAVRenderingSessionImpl::GetPositionInfoL
// See upnpavrenderingsessionimpl.h
// --------------------------------------------------------------------------
void CUPnPAVRenderingSessionImpl::GetPositionInfoL()
    {
    ResetL();
    
    iSettingActive->GetPositionInfoL();               
    }
// --------------------------------------------------------------------------
// CUPnPAVRenderingSessionImpl::SetMuteL
// See upnpavrenderingsessionimpl.h
// --------------------------------------------------------------------------
void CUPnPAVRenderingSessionImpl::SetMuteL( TBool aMute )
    {
    ResetL();
    
    iSettingActive->SetMuteL( aMute );
    }
// --------------------------------------------------------------------------
// CUPnPAVRenderingSessionImpl::SetVolumeL
// See upnpavrenderingsessionimpl.h
// --------------------------------------------------------------------------
void CUPnPAVRenderingSessionImpl::SetVolumeL( TInt aVolumeLevel )
    {
    ResetL();
    
    iSettingActive->SetVolumeL( aVolumeLevel );
    }
// --------------------------------------------------------------------------
// CUPnPAVRenderingSessionImpl::PauseL
// See upnpavrenderingsessionimpl.h
// --------------------------------------------------------------------------
void CUPnPAVRenderingSessionImpl::PauseL()
    {
    ResetL();
    
    iCommandActive->PauseL();   
    }
// --------------------------------------------------------------------------
// CUPnPAVRenderingSessionImpl::StopL
// See upnpavrenderingsessionimpl.h
// --------------------------------------------------------------------------
void CUPnPAVRenderingSessionImpl::StopL()
    {
    ResetL();
    
    iCommandActive->StopL(); 
    }
// --------------------------------------------------------------------------
// CUPnPAVRenderingSessionImpl::CancelReserveLocalMSServicesL
// See upnpavrenderingsessionimpl.h
// --------------------------------------------------------------------------
void CUPnPAVRenderingSessionImpl::CancelReserveLocalMSServicesL()
    {
    ResetL();
    
    iCommandActive->CancelReserveLocalMSServicesL();  
    }