1 /*

     2 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:    

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 // INCLUDES

    22 #include <e32debug.h>

    23 #include "natfwconnectivityapidefs.h"

    24 #include "natfwconnectivityapi.h"

    25 #include <mmccinterface.h>

    26 #include <mmcccodecinformation.h>

    27 #include "mnatfwsocketmediaconnwrapper.h"

    28 #include "natfwcandidate.h"

    29 #include "natfwcandidatepair.h"

    30 

    31 #include "mediateststubs.h"

    32 #include "stunudpmediatest.h"

    33 #include "testdefinitions.hrh"

    34 #include "natfwtestconsolelogs.h"

    35 #include <cnatfwsettingsapi.h>

    36 

    37 const TInt KAudioPrefVoipAudioUplink           = 0x05220001;

    38 const TInt KAudioPrefVoipAudioDownlink         = 0x05210001;

    39 const TInt KDefaultQos = 46;

    40 const TInt KRunningTime = 500000;

    41 

    42 // ======== MEMBER FUNCTIONS =================================================

    43 

    44 // ---------------------------------------------------------------------------

    45 // CStunUdpMediaTestInterface::CStunUdpMediaTestInterface

    46 // C++ default constructor can NOT contain any code, that

    47 // might leave.

    48 // ---------------------------------------------------------------------------

    49 //

    50 CStunUdpMediaTest::CStunUdpMediaTest( CConsoleBase& aConsole,

    51     CNATFWConnectivityApi& aNat, CMediaTestStubs& aIFStub, TUint aIapId,

    52     TUint32 aDestAddr, TUint aDestPort ) :

    53     iConsole( aConsole ), iNat( aNat ), iIfStub( aIFStub ), iIapId( aIapId ),

    54     iDestAddr( aDestAddr ), iDestPort( aDestPort )

    55     {

    56     }

    57     

    58 // ---------------------------------------------------------------------------

    59 // CStunUdpMediaTest::ConstructL

    60 // Symbian 2nd phase constructor can leave.

    61 // ---------------------------------------------------------------------------

    62 //

    63 void CStunUdpMediaTest::ConstructL( const TDesC8& aDomain )

    64     {

    65     iDomain = aDomain.AllocL();

    66     RDebug::Print( _L("CStunUdpMediaTest::ConstructL IAP: %d"), iIapId );

    67     }

    68     

    69 // ---------------------------------------------------------------------------

    70 // CStunUdpMediaTest::NewL

    71 // Static constructor.

    72 // ---------------------------------------------------------------------------

    73 //   

    74 CStunUdpMediaTest* CStunUdpMediaTest::NewL( CConsoleBase& aConsole,

    75     CNATFWConnectivityApi& aNat, CMediaTestStubs& aIFStub,

    76     const TDesC8& aDomain, TUint aIapId, TUint32 aDestAddr, TUint aDestPort )

    77     {

    78     CStunUdpMediaTest* self 

    79         = new ( ELeave ) CStunUdpMediaTest( aConsole, aNat, aIFStub, aIapId,

    80             aDestAddr, aDestPort );

    81 

    82     CleanupStack::PushL( self );

    83     self->ConstructL( aDomain );

    84     CleanupStack::Pop( self );

    85     return self;

    86     }

    87 

    88 // ---------------------------------------------------------------------------

    89 // CStunUdpMediaTest::~CStunUdpMediaTest

    90 // Destructor.

    91 // ---------------------------------------------------------------------------

    92 //

    93 CStunUdpMediaTest::~CStunUdpMediaTest()

    94     {

    95     delete iMccInterface;

    96     delete iDomain;

    97     iNat.CloseStreamL( iSessionId, iStreamId );

    98     iNat.CloseSessionL( iSessionId );

    99     }

   100 

   101 

   102 // ---------------------------------------------------------------------------

   103 // CStunUdpMediaTest::PrintLocalAddressL

   104 // ---------------------------------------------------------------------------

   105 //

   106 void CStunUdpMediaTest::PrintLocalAddressL()

   107     {

   108     RDebug::Print( _L( "CStunUdpMediaTest::PrintLocalAddressL" ) );

   109     

   110     iConsole.Printf( _L( "Local address resolving started...\n" ) );

   111     

   112     TInt pluginId;

   113     

   114     CNATFWNatSettingsApi* settings = CNATFWNatSettingsApi::NewLC( iDomain->Des() );

   115     

   116     iSessionId = iNat.CreateSessionL( iIapId, iDomain->Des() );

   117     iIfStub.StartActiveSchedulerL();

   118     

   119     // Load plug in

   120     iNat.LoadPluginL( iSessionId, settings->AvailableNatProtocols(), pluginId);

   121     iIfStub.StartActiveSchedulerL( 20000 );

   122     CleanupStack::PopAndDestroy( settings );

   123     

   124     // STREAM

   125     iStreamId = iNat.CreateStreamL( iSessionId, KProtocolInetUdp, KDefaultQos );

   126     

   127     // Get local IP

   128     iNat.FetchCandidateL( iSessionId, iStreamId, KAfInet );

   129     iIfStub.StartActiveSchedulerL();

   130 

   131     TInetAddr localAddr;

   132     TRAPD( err, localAddr = iIfStub.LocalCandidateL().TransportAddr() );

   133     if ( KErrNone != err )

   134         {

   135         iNat.CloseStreamL( iSessionId, iStreamId );

   136         iNat.CloseSessionL( iSessionId );

   137         User::Leave( err );

   138         }

   139     

   140     TBuf<40> buffer;

   141     localAddr.Output( buffer );

   142     _LIT( KPrintLocalAddFormat, "\nLOCAL ADDRESS: %S PORT: %d\n");

   143     

   144     RDebug::Print( KPrintLocalAddFormat, &buffer, localAddr.Port() );

   145     iConsole.Printf( KPrintLocalAddFormat, &buffer, localAddr.Port() );

   146     }

   147 

   148 

   149 // ---------------------------------------------------------------------------

   150 // CStunUdpMediaTest::GetLocalAddressL

   151 // ---------------------------------------------------------------------------

   152 //    

   153 TInt CStunUdpMediaTest::GetLocalAddress( TInetAddr& localAddr )

   154     {

   155     RDebug::Print( _L( "CStunUdpMediaTest::GetLocalAddress" ) );

   156     

   157     CNATFWCandidate* localCandidate = NULL;

   158     

   159     TRAPD( err, localCandidate = &iIfStub.LocalCandidateL() )

   160     if ( KErrNone == err )

   161         {

   162         localAddr.SetAddress( localCandidate->TransportAddr().Address() );

   163         localAddr.SetPort( localCandidate->TransportAddr().Port() );

   164         return KErrNone;        

   165         }

   166     return err;

   167     }

   168     

   169     

   170 // ---------------------------------------------------------------------------

   171 // CStunUdpMediaTest::TestUdpAudioL

   172 // ---------------------------------------------------------------------------

   173 //

   174 void CStunUdpMediaTest::TestUdpAudioStreamingL()

   175     {

   176     TUint sessionId( 0 );

   177     TUint streamId( 0 );

   178     TInt pluginId;

   179     

   180     // UDP SESSIO

   181     RDebug::Print( _L("CStunUdpMediaTest::TestUdpAudioL - start") );

   182      

   183     iSessionId = iNat.CreateSessionL( iIapId, iDomain->Des() );

   184     sessionId = iSessionId;

   185     iIfStub.StartActiveSchedulerL();

   186     

   187     // load plug-in

   188     CNATFWNatSettingsApi* settings = CNATFWNatSettingsApi::NewLC( iDomain->Des() );

   189     iNat.LoadPluginL( iSessionId, settings->AvailableNatProtocols(), pluginId );

   190     iIfStub.StartActiveSchedulerL( 20000 );

   191     CleanupStack::PopAndDestroy( settings );    

   192     

   193     // STREAM

   194     streamId = iNat.CreateStreamL( sessionId, KProtocolInetUdp, KDefaultQos );

   195     iStreamId = streamId;

   196     // Get local IP that receives media

   197     iNat.FetchCandidateL( sessionId, streamId, KAfInet );

   198     iIfStub.StartActiveSchedulerL();

   199     

   200     __NATFWTESTCONSOLE_ADDRLOG( "CStunUdpMediaTest::TestUdpAudioL- LOCAL ADDRESS: ", iReceiveMediaAddress )

   201 

   202     // WRAPPER

   203     MNATFWSocketMediaConnWrapper& mediaWrapper =

   204         iNat.CreateWrapperL( sessionId, streamId );

   205 

   206     TInetAddr destinationAddress;

   207     mediaWrapper.OutgoingAddr( destinationAddress );

   208 

   209     __NATFWTESTCONSOLE_ADDRLOG( "CStunUdpMediaTest::TestUdpAudioL- Wrapper LOCAL ADDRESS: ", destinationAddress )

   210 

   211     // NET settings value

   212     iNetsettings.iRemoteAddress.SetAddress( destinationAddress.Address() );

   213     iNetsettings.iRemoteAddress.SetPort( destinationAddress.Port() );

   214     iNetsettings.iRemoteRtcpPort = KDefaultRtcpPort;

   215 

   216     iNetsettings.iLocalAddress.SetAddress( KInetAddrAny );

   217     iNetsettings.iLocalAddress.SetPort( KDefaultRtpPort );

   218 

   219     iNetsettings.iLocalPublicAddress.SetAddress( KInetAddrAny );

   220     iNetsettings.iLocalRtcpPort = KDefaultRtcpPort;

   221     iNetsettings.iLocalPublicRtcpPort = KDefaultRtcpPort;

   222     iNetsettings.iMediaQosValue = KDefaultMediaQos;

   223     iNetsettings.iIapId = iIapId;

   224 

   225     TUint32 sessionId1;

   226     iMccInterface = CMccInterface::NewL( iIfStub );     

   227     User::LeaveIfError( iMccInterface->CreateSession( sessionId1 ) );

   228 

   229     // Create MCC LINK

   230     TUint32 linkId;

   231     User::LeaveIfError( iMccInterface->CreateLink( sessionId1, KMccLinkGeneral, linkId, iNetsettings ) ); 

   232 

   233     CActiveScheduler::Start();

   234 

   235     iNetsettings.iRemoteAddress.SetAddress( destinationAddress.Address() );

   236     iNetsettings.iRemoteAddress.SetPort( destinationAddress.Port() );

   237  

   238     __NATFWTESTCONSOLE_ADDRLOG( "CStunUdpMediaTest::TestUdpAudioL- iNetsettings.iRemoteAddress: ", iIfStub.NetSettings().iRemoteAddress )

   239     __NATFWTESTCONSOLE_ADDRLOG( "CStunUdpMediaTest::TestUdpAudioL- iNetsettings.iLocalAddress: ", iIfStub.NetSettings().iLocalAddress )

   240 

   241     User::LeaveIfError( iMccInterface->SetRemoteAddress( sessionId1, linkId, iNetsettings.iRemoteAddress ) );

   242     __NATFWTESTCONSOLE_ADDRLOG( "CStunUdpMediaTest::TestUdpAudioL- iNetsettings.iLocalAddress: ", iIfStub.NetSettings().iLocalAddress)

   243 

   244 

   245     RPointerArray<CMccCodecInformation> codecArray;

   246     CleanupResetAndDestroy< RPointerArray<CMccCodecInformation> >::PushL( codecArray );

   247     User::LeaveIfError( iMccInterface->GetCapabilities( codecArray ) );

   248 

   249     

   250     // Create upstream

   251     TUint32 upStream;

   252     TUint32 dataSinkId1;

   253     TUint32 dataSourceId1;

   254     User::LeaveIfError( iMccInterface->AddDataSink( KMccRtpSinkUid, KNullDesC8, dataSinkId1 ) );

   255     User::LeaveIfError( iMccInterface->AddDataSource( KUidMmfAudioInput, KNullDesC8, dataSourceId1 ) );

   256     codecArray[0]->SetPriorityPreference( KAudioPrefVoipAudioUplink );

   257     User::LeaveIfError( iMccInterface->CreateStream( sessionId1, linkId, upStream, 

   258         KMccAudioUplinkStream, *codecArray[0] ) );

   259     

   260     

   261     // Create downstream

   262     TUint32 downStream;

   263     TUint32 dataSinkId2;

   264     TUint32 dataSourceId2;

   265     User::LeaveIfError( iMccInterface->AddDataSink( KUidMmfAudioOutput, KNullDesC8, dataSinkId2 ) );

   266     User::LeaveIfError( iMccInterface->AddDataSource( KMccRtpSourceUid, KNullDesC8, dataSourceId2 ) );

   267     codecArray[0]->SetPriorityPreference( KAudioPrefVoipAudioDownlink );

   268     User::LeaveIfError( iMccInterface->CreateStream( sessionId1, linkId, downStream,

   269         KMccAudioDownlinkStream, *codecArray[0] ) );

   270     

   271     // Set destination address to wrapper

   272     __NATFWTESTCONSOLE_ADDRLOG( "CStunUdpMediaTest::TestUdpAudioL- iNetsettings.iLocalAddress: ",

   273         iIfStub.NetSettings().iLocalAddress )

   274     mediaWrapper.SetIncomingAddrL( iIfStub.NetSettings().iLocalAddress);

   275 

   276     mediaWrapper.SetReceivingStateL( EStreamingStateActive );

   277     mediaWrapper.SetSendingStateL( EStreamingStateActive );  

   278     

   279     TInetAddr destAddr;

   280     if( iDestAddr == 0 )

   281         {

   282         destAddr.SetAddress( destinationAddress.Address() );

   283         destAddr.SetPort( 5000 );

   284         }

   285     else

   286         {

   287         destAddr.SetAddress( iDestAddr );

   288         destAddr.SetPort( iDestPort );

   289         }

   290     

   291     //iNat.SetReceivingStateL( iSessionId, KMediaConnection, EStreamingStateActive );

   292     //iNat.SetSendingStateL( iSessionId, KMediaConnection, destAddr, EStreamingStateActive );

   293 

   294     

   295      // Prepare and start up and downstream  

   296     User::LeaveIfError( iMccInterface->PrepareStream( sessionId1, linkId, downStream ) );

   297     CActiveScheduler::Start();

   298     CActiveScheduler::Start();

   299     

   300     User::LeaveIfError( iMccInterface->PrepareStream( sessionId1, linkId, upStream ) );

   301     CActiveScheduler::Start();

   302     CActiveScheduler::Start();   

   303     

   304     iNat.SetReceivingStateL( iIfStub.LocalCandidateL(), EStreamingStateActive );

   305     iIfStub.StartActiveSchedulerL( KRunningTime );

   306     

   307     iNat.SetSendingStateL( iIfStub.LocalCandidateL(),

   308         EStreamingStateActive, destAddr );

   309     iIfStub.StartActiveSchedulerL( KRunningTime );

   310     

   311     User::LeaveIfError( iMccInterface->StartStream( sessionId1, linkId, downStream ) );

   312     CActiveScheduler::Start();

   313     CActiveScheduler::Start();

   314     

   315     User::LeaveIfError( iMccInterface->StartStream( sessionId1, linkId, upStream ) );

   316     CActiveScheduler::Start();

   317     CActiveScheduler::Start();

   318      

   319     CleanupStack::PopAndDestroy( &codecArray );

   320     }

   321 

   322 

   323 // ---------------------------------------------------------------------------

   324 // CStunUdpMediaTest::PrepareAudioStreamingL

   325 // ---------------------------------------------------------------------------

   326 //

   327 void CStunUdpMediaTest::PrepareAudioStreamingL()

   328     {

   329     TUint sessionId( 0 );

   330     TUint streamId( 0 );

   331     

   332     // UDP SESSIO

   333     RDebug::Print( _L("CStunUdpMediaTest::PrepareAudioStreamingL - start") );

   334     

   335     //iSessionId = 

   336     iNat.CreateSessionL( 6, iDomain->Des() );

   337     //sessionId = iSessionId;

   338     CActiveScheduler::Start();

   339     

   340     iSessionId = iNat.CreateSessionL( iIapId, iDomain->Des() );

   341     sessionId = iSessionId;

   342     iIfStub.StartActiveSchedulerL();

   343        

   344     // STREAM

   345     streamId = iNat.CreateStreamL( sessionId, KProtocolInetUdp, KDefaultQos );

   346     iStreamId = streamId;

   347     // Get local IP that receives media

   348     iNat.FetchCandidateL( sessionId, streamId, KAfInet );

   349     iIfStub.StartActiveSchedulerL();

   350     

   351     __NATFWTESTCONSOLE_ADDRLOG( "CStunUdpMediaTest::TestUdpAudioL- LOCAL ADDRESS: ", iReceiveMediaAddress )

   352 

   353     // WRAPPER

   354     MNATFWSocketMediaConnWrapper& mediaWrapper =

   355         iNat.CreateWrapperL( sessionId, streamId );

   356 

   357     TInetAddr destinationAddress;

   358     mediaWrapper.OutgoingAddr( destinationAddress );

   359 

   360     __NATFWTESTCONSOLE_ADDRLOG( "CStunUdpMediaTest::TestUdpAudioL- Wrapper LOCAL ADDRESS: ", destinationAddress )

   361 

   362     // NET settings value

   363     iNetsettings.iRemoteAddress.SetAddress( destinationAddress.Address() );

   364     iNetsettings.iRemoteAddress.SetPort( destinationAddress.Port() );

   365     iNetsettings.iRemoteRtcpPort = KDefaultRtcpPort;

   366 

   367     iNetsettings.iLocalAddress.SetAddress( KInetAddrAny );

   368     iNetsettings.iLocalAddress.SetPort( KDefaultRtpPort );

   369 

   370     iNetsettings.iLocalPublicAddress.SetAddress( KInetAddrAny );

   371     iNetsettings.iLocalRtcpPort = KDefaultRtcpPort;

   372     iNetsettings.iLocalPublicRtcpPort = KDefaultRtcpPort;

   373     iNetsettings.iMediaQosValue = KDefaultMediaQos;

   374     iNetsettings.iIapId = iIapId;

   375 

   376     TUint32 sessionId1;

   377     iMccInterface = CMccInterface::NewL( iIfStub );     

   378     User::LeaveIfError( iMccInterface->CreateSession( sessionId1 ) );

   379 

   380     // Create MCC LINK

   381     TUint32 linkId;

   382     User::LeaveIfError( iMccInterface->CreateLink( sessionId1, KMccLinkGeneral, linkId, iNetsettings ) ); 

   383 

   384     CActiveScheduler::Start();

   385 

   386     iNetsettings.iRemoteAddress.SetAddress( destinationAddress.Address() );

   387     iNetsettings.iRemoteAddress.SetPort( destinationAddress.Port() );

   388  

   389     __NATFWTESTCONSOLE_ADDRLOG( "CStunUdpMediaTest::TestUdpAudioL- iNetsettings.iRemoteAddress: ", iIfStub.NetSettings().iRemoteAddress )

   390     __NATFWTESTCONSOLE_ADDRLOG( "CStunUdpMediaTest::TestUdpAudioL- iNetsettings.iLocalAddress: ", iIfStub.NetSettings().iLocalAddress )

   391 

   392     User::LeaveIfError( iMccInterface->SetRemoteAddress( sessionId1, linkId, iNetsettings.iRemoteAddress ) );

   393     __NATFWTESTCONSOLE_ADDRLOG( "CStunUdpMediaTest::TestUdpAudioL- iNetsettings.iLocalAddress: ", iIfStub.NetSettings().iLocalAddress)

   394 

   395 

   396     RPointerArray<CMccCodecInformation> codecArray;

   397     CleanupResetAndDestroy< RPointerArray<CMccCodecInformation> >::PushL( codecArray );

   398     User::LeaveIfError( iMccInterface->GetCapabilities( codecArray ) );

   399 

   400     

   401     // Create upstream

   402     TUint32 upStream;

   403     TUint32 dataSinkId1;

   404     TUint32 dataSourceId1;

   405     User::LeaveIfError( iMccInterface->AddDataSink( KMccRtpSinkUid, KNullDesC8, dataSinkId1 ) );

   406     User::LeaveIfError( iMccInterface->AddDataSource( KUidMmfAudioInput, KNullDesC8, dataSourceId1 ) );

   407     codecArray[0]->SetPriorityPreference( KAudioPrefVoipAudioUplink );

   408     User::LeaveIfError( iMccInterface->CreateStream( sessionId1, linkId, upStream, 

   409         KMccAudioUplinkStream, *codecArray[0] ) );

   410     

   411     

   412     // Create downstream

   413     TUint32 downStream;

   414     TUint32 dataSinkId2;

   415     TUint32 dataSourceId2;

   416     User::LeaveIfError( iMccInterface->AddDataSink( KUidMmfAudioOutput, KNullDesC8, dataSinkId2 ) );

   417     User::LeaveIfError( iMccInterface->AddDataSource( KMccRtpSourceUid, KNullDesC8, dataSourceId2 ) );

   418     codecArray[0]->SetPriorityPreference( KAudioPrefVoipAudioDownlink );

   419     User::LeaveIfError( iMccInterface->CreateStream( sessionId1, linkId, downStream,

   420         KMccAudioDownlinkStream, *codecArray[0] ) );

   421     

   422     // Set destination address to wrapper

   423      __NATFWTESTCONSOLE_ADDRLOG( "CStunUdpMediaTest::TestUdpAudioL- iNetsettings.iLocalAddress: ", iIfStub.NetSettings().iLocalAddress )

   424     mediaWrapper.SetIncomingAddrL( iIfStub.NetSettings().iLocalAddress);

   425 

   426     TInetAddr destAddr;

   427     if( iDestAddr == 0 )

   428         {

   429         destAddr.SetAddress( destinationAddress.Address() );

   430         destAddr.SetPort( 5000 );

   431         }

   432     else

   433         {

   434         destAddr.SetAddress( iDestAddr );

   435         destAddr.SetPort( iDestPort );

   436         }

   437     

   438      // Prepare and start up and downstream  

   439     User::LeaveIfError( iMccInterface->PrepareStream( sessionId1, linkId, downStream ) );

   440     CActiveScheduler::Start();

   441     CActiveScheduler::Start();

   442     

   443     User::LeaveIfError( iMccInterface->PrepareStream( sessionId1, linkId, upStream ) );

   444     CActiveScheduler::Start();

   445     CActiveScheduler::Start();   

   446 

   447     User::LeaveIfError( iMccInterface->StartStream( sessionId1, linkId, downStream ) );

   448     CActiveScheduler::Start();

   449     CActiveScheduler::Start();

   450     

   451     User::LeaveIfError( iMccInterface->StartStream( sessionId1, linkId, upStream ) );

   452     CActiveScheduler::Start();

   453     CActiveScheduler::Start();

   454     /*

   455     iNat.SetReceivingStateL( iSessionId, streamId, EStreamingStateActive );

   456     iNat.SetSendingStateL( iSessionId, streamId, destAddr, EStreamingStateActive );

   457     */

   458     CleanupStack::PopAndDestroy( &codecArray );

   459     

   460     RDebug::Print( _L("CStunUdpMediaTest::PrepareAudioStreamingL - stop") );

   461     }

   462