1 /*

     2 * Copyright (c) 2009 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:  Implementation of internet access point handling.

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include "HtiMessagesServicePlugin.h"

    21 #include "HtiIAPHandler.h"

    22 

    23 #include <HtiDispatcherInterface.h>

    24 #include <HtiLogging.h>

    25 #include <cmconnectionmethodext.h>

    26 #include <cmconnectionmethoddef.h>

    27 #include <cmdestinationext.h>

    28 #include <cmmanagerext.h>

    29 #include <cmplugincsddef.h>

    30 #include <cmpluginhscsddef.h>

    31 #include <cmpluginpacketdatadef.h>

    32 #include <cmpluginwlandef.h>

    33 #include <rconnmon.h>

    34 

    35 using namespace CMManager;

    36 

    37 // EXTERNAL DATA STRUCTURES

    38 

    39 // EXTERNAL FUNCTION PROTOTYPES

    40 

    41 // CONSTANTS

    42 const TInt KMinCreateMsgLength = 5;

    43 const TInt KMinDeleteMsgLength = 3;

    44 const TInt KMinCreateDestMsgLength = 3;

    45 const TInt KMinDeleteDestMsgLength = 3;

    46 const TInt KMinModifyDestMsgLength = 5;

    47 const TInt KMinSetDefConMsgLength = 3;

    48 

    49 // MACROS

    50 

    51 // LOCAL CONSTANTS AND MACROS

    52 _LIT8( KErrorInvalidParameters, "Invalid command parameters" );

    53 _LIT8( KErrorCreateFailed, "Access Point creation failed" );

    54 _LIT8( KErrorDeleteFailed, "Access Point deletion failed" );

    55 _LIT8( KErrorDestCreateFailed, "Destination creation failed" );

    56 _LIT8( KErrorDestDeleteFailed, "Destination deletion failed" );

    57 _LIT8( KErrorApAlreadyExists, "Access Point with same name already exists" );

    58 _LIT8( KErrorApNotFound, "Access Point with given name not found" );

    59 _LIT8( KErrorConnCloseFailed,

    60            "Failed to close a connection using the Access Point" );

    61 _LIT8( KErrorAddToDestFailed, "Adding to destination failed" );

    62 _LIT8( KErrorRemoveFromDestFailed, "Removing from destination failed" );

    63 _LIT8( KErrorDestNotFound, "Destination with given name not found" );

    64 _LIT8( KErrorSetDefConFailed, "Setting default connection failed" );

    65 

    66 // MODULE DATA STRUCTURES

    67 

    68 // LOCAL FUNCTION PROTOTYPES

    69 

    70 // FORWARD DECLARATIONS

    71 

    72 // ============================ MEMBER FUNCTIONS ===============================

    73 

    74 // -----------------------------------------------------------------------------

    75 // CHtiIAPHandler::NewL

    76 // Two-phased constructor.

    77 // -----------------------------------------------------------------------------

    78 CHtiIAPHandler* CHtiIAPHandler::NewL()

    79     {

    80     HTI_LOG_FUNC_IN( "CHtiIAPHandler::NewL" );

    81     CHtiIAPHandler* self = new (ELeave) CHtiIAPHandler();

    82     CleanupStack::PushL ( self );

    83     self->ConstructL();

    84     CleanupStack::Pop();

    85     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::NewL" );

    86     return self;

    87     }

    88 

    89 

    90 // ----------------------------------------------------------------------------

    91 // CHtiIAPHandler::CHtiIAPHandler

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

    93 // might leave.

    94 // ----------------------------------------------------------------------------

    95 CHtiIAPHandler::CHtiIAPHandler()

    96     {

    97     HTI_LOG_FUNC_IN( "CHtiIAPHandler::CHtiIAPHandler" );

    98 

    99     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::CHtiIAPHandler" );

   100     }

   101 

   102 

   103 // -----------------------------------------------------------------------------

   104 // CHtiIAPHandler::~CHtiIAPHandler

   105 // Destructor.

   106 // -----------------------------------------------------------------------------

   107 CHtiIAPHandler::~CHtiIAPHandler()

   108     {

   109     HTI_LOG_FUNC_IN( "CHtiIAPHandler::~CHtiIAPHandler" );

   110 

   111     for ( TInt i = 0; i < iFields.Count(); i++ )

   112         {

   113         delete iFields[i].iData;

   114         }

   115     iFields.Reset();

   116     iFields.Close();

   117 

   118     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::~CHtiIAPHandler" );

   119     }

   120 

   121 

   122 // -----------------------------------------------------------------------------

   123 // CHtiIAPHandler::ConstructL

   124 // Symbian 2nd phase constructor can leave.

   125 // -----------------------------------------------------------------------------

   126 void CHtiIAPHandler::ConstructL()

   127     {

   128     HTI_LOG_FUNC_IN( "CHtiIAPHandler::ConstructL" );

   129 

   130     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::ConstructL" );

   131     }

   132 

   133 

   134 // -----------------------------------------------------------------------------

   135 // CHtiIAPHandler::SetDispatcher

   136 // Sets the dispatcher pointer.

   137 // -----------------------------------------------------------------------------

   138 

   139 void CHtiIAPHandler::SetDispatcher( MHtiDispatcher* aDispatcher )

   140     {

   141     HTI_LOG_FUNC_IN( "CHtiIAPHandler::SetDispatcher" );

   142     iDispatcher = aDispatcher;

   143     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::SetDispatcher" );

   144     }

   145 

   146 

   147 // -----------------------------------------------------------------------------

   148 // CHtiIAPHandler::ProcessMessageL

   149 // Parses the received message and calls handler functions.

   150 // -----------------------------------------------------------------------------

   151 void CHtiIAPHandler::ProcessMessageL( const TDesC8& aMessage,

   152     THtiMessagePriority /*aPriority*/ )

   153     {

   154     HTI_LOG_FUNC_IN( "CHtiIAPHandler::ProcessMessageL" );

   155 

   156     for ( TInt i = 0; i < iFields.Count(); i++ )

   157         delete iFields[i].iData;

   158     iFields.Reset();

   159     iFields.Close();

   160     iConnName.Zero();

   161     iBearerType = 0;

   162 

   163     // Zero length message and command code validity already checked

   164     // in HtiMessagesServicePlugin.

   165 

   166     if ( aMessage[0] == CHtiMessagesServicePlugin::ECreateIAP )

   167         {

   168         if ( aMessage.Length() < KMinCreateMsgLength )

   169             {

   170             SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

   171             }

   172         else

   173             {

   174             TRAPD( err, HandleCreateIapL( aMessage.Mid( 1 ) ) );

   175             if ( err != KErrNone )

   176                 {

   177                 SendErrorMessageL( err, KErrorCreateFailed );

   178                 }

   179             }

   180         }

   181 

   182     else if ( aMessage[0] == CHtiMessagesServicePlugin::EDeleteIAP )

   183         {

   184         if ( aMessage.Length() < KMinDeleteMsgLength )

   185             {

   186             SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

   187             }

   188         else

   189             {

   190             TRAPD( err, HandleDeleteIapL( aMessage.Mid( 1 ) ) );

   191             if ( err != KErrNone )

   192                 {

   193                 SendErrorMessageL( err, KErrorDeleteFailed );

   194                 }

   195             }

   196         }

   197 

   198     else if ( aMessage[0] == CHtiMessagesServicePlugin::ECreateDestination )

   199         {

   200         if ( aMessage.Length() < KMinCreateDestMsgLength )

   201             {

   202             SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

   203             }

   204         else

   205             {

   206             TRAPD( err, HandleCreateDestinationL( aMessage.Mid( 1 ) ) );

   207             if ( err != KErrNone )

   208                 {

   209                 SendErrorMessageL( err, KErrorDestCreateFailed );

   210                 }

   211             }

   212         }

   213 

   214     else if ( aMessage[0] == CHtiMessagesServicePlugin::EDeleteDestination )

   215         {

   216         if ( aMessage.Length() < KMinDeleteDestMsgLength )

   217             {

   218             SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

   219             }

   220         else

   221             {

   222             TRAPD( err, HandleDeleteDestinationL( aMessage.Mid( 1 ) ) );

   223             if ( err != KErrNone )

   224                 {

   225                 SendErrorMessageL( err, KErrorDestDeleteFailed );

   226                 }

   227             }

   228         }

   229 

   230     else if ( aMessage[0] == CHtiMessagesServicePlugin::EAddToDestination ||

   231             aMessage[0] == CHtiMessagesServicePlugin::ERemoveFromDestination )

   232         {

   233         if ( aMessage.Length() < KMinModifyDestMsgLength )

   234             {

   235             SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

   236             }

   237         else

   238             {

   239             TRAPD( err, ModifyDestinationL( aMessage[0], aMessage.Mid( 1 ) ) );

   240             if ( err != KErrNone )

   241                 {

   242                 if ( aMessage[0] == CHtiMessagesServicePlugin::EAddToDestination )

   243                     {

   244                     SendErrorMessageL( err, KErrorAddToDestFailed );

   245                     }

   246                 else

   247                     {

   248                     SendErrorMessageL( err, KErrorRemoveFromDestFailed );

   249                     }

   250                 }

   251             }

   252         }

   253     else if ( aMessage[0] == CHtiMessagesServicePlugin::ESetDefaultConnection )

   254         {

   255         if ( aMessage.Length() < KMinSetDefConMsgLength )

   256             {

   257             SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

   258             }

   259         else

   260             {

   261             TRAPD( err, SetDefaultConnectionL( aMessage.Mid( 1 ) ) );

   262             if ( err != KErrNone )

   263                 {

   264                 SendErrorMessageL( err, KErrorSetDefConFailed );

   265                 }

   266             }

   267         }

   268 

   269     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::ProcessMessageL" );

   270     }

   271 

   272 

   273 // ----------------------------------------------------------------------------

   274 // CHtiIAPHandler::HandleCreateIapL

   275 // Creates new Internet Access Point.

   276 // ----------------------------------------------------------------------------

   277 void CHtiIAPHandler::HandleCreateIapL( const TDesC8& aData )

   278     {

   279     HTI_LOG_FUNC_IN( "CHtiIAPHandler::HandleCreateIapL" );

   280 

   281     TRAPD( err, ParseCreateMessageL( aData ) );

   282     if ( err != KErrNone )

   283         {

   284         SendErrorMessageL( err, KErrorInvalidParameters );

   285         return;

   286         }

   287 

   288     if ( GetAccessPointUIDL() != KErrNotFound )

   289         {

   290         SendErrorMessageL( KErrAlreadyExists, KErrorApAlreadyExists );

   291         return;

   292         }

   293 

   294     MapLegacyFieldIDs();

   295     ResolveFieldDataTypes();

   296 

   297     RCmManagerExt cmManager;

   298     cmManager.OpenL();

   299     CleanupClosePushL( cmManager );

   300 

   301     RCmConnectionMethodExt cm = cmManager.CreateConnectionMethodL( iBearerType );

   302     CleanupClosePushL( cm );

   303     HTI_LOG_TEXT( "Connection method created" );

   304 

   305     cm.SetStringAttributeL( ECmName, iConnName );

   306     HTI_LOG_TEXT( "Name set" );

   307 

   308     TUint32 requestedSeamlessness = 1; // default

   309 

   310     // Set attributes

   311     HTI_LOG_FORMAT( "Fields to write: %d", iFields.Count() );

   312     for ( TInt i = 0; i < iFields.Count(); i++ )

   313         {

   314         if ( err != KErrNone ) break;

   315 

   316         HTI_LOG_FORMAT( "Writing field %d", ( i + 1 ) );

   317         TApField field = iFields[i];

   318         HTI_LOG_FORMAT( "Field ID = %d", field.iId );

   319 

   320         switch ( field.iDataType )

   321             {

   322             case EDataTypeText:

   323                 {

   324                 TRAP( err, cm.SetStringAttributeL( field.iId, *field.iData ) );

   325                 break;

   326                 }

   327             case EDataTypeBool:

   328                 {

   329                 TLex lex( *field.iData );

   330                 TInt result = 0;

   331                 lex.Val( result );

   332                 TRAP( err, cm.SetBoolAttributeL( field.iId, ( TBool ) result ) );

   333                 break;

   334                 }

   335             case EDataTypeUint:

   336                 {

   337                 TLex lex( *field.iData );

   338                 TUint32 result;

   339                 err = lex.Val( result, EDecimal );

   340                 if ( err == KErrNone )

   341                     TRAP( err, cm.SetIntAttributeL( field.iId, result ) );

   342                 if ( field.iId == ECmSeamlessnessLevel )

   343                     requestedSeamlessness = result;

   344                 break;

   345                 }

   346             case EDataTypeText8:

   347                 {

   348                 HBufC8* buf8 = HBufC8::NewL( field.iData->Length() );

   349                 buf8->Des().Copy( *field.iData );

   350                 TRAP( err, cm.SetString8AttributeL( field.iId, *buf8 ) );

   351                 delete buf8;

   352                 buf8 = NULL;

   353                 break;

   354                 }

   355             default:

   356                 {

   357                 HTI_LOG_FORMAT( "Unsupported field type %d", field.iDataType );

   358                 err = KErrNotSupported;

   359                 break;

   360                 }

   361             }

   362         }

   363 

   364     if ( err != KErrNone )

   365         {

   366         HTI_LOG_FORMAT( "Error occurred %d", err );

   367         User::Leave( err );

   368         }

   369 

   370     cm.UpdateL();

   371     TUint32 uid = cm.GetIntAttributeL( ECmId );

   372     CleanupStack::PopAndDestroy(); // cm

   373 

   374     // The seamlessness value is not always set correctly when the connection

   375     // method is created. Have to update seamlessness value separately after

   376     // creation.

   377     cm = cmManager.ConnectionMethodL( uid );

   378     CleanupClosePushL( cm );

   379     TUint32 currentSeamlessness = cm.GetIntAttributeL( ECmSeamlessnessLevel );

   380     HTI_LOG_FORMAT( "Requested seamlessness = %d", requestedSeamlessness );

   381     HTI_LOG_FORMAT( "Current seamlessness = %d", currentSeamlessness );

   382     if ( currentSeamlessness != requestedSeamlessness )

   383         {

   384         cm.SetIntAttributeL( ECmSeamlessnessLevel, requestedSeamlessness );

   385         cm.UpdateL();

   386         HTI_LOG_TEXT( "Seamlessness value updated" );

   387         }

   388     CleanupStack::PopAndDestroy(); // cm

   389     CleanupStack::PopAndDestroy(); // cmManager

   390 

   391     HTI_LOG_FORMAT( "AP created with uid %d", uid );

   392 

   393     TBuf8<4> idBuf;

   394     idBuf.Append( ( TUint8* ) &uid, 4 );

   395     SendOkMsgL( idBuf );

   396 

   397     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::HandleCreateIapL" );

   398     }

   399 

   400 

   401 // ----------------------------------------------------------------------------

   402 // CHtiIAPHandler::HandleDeleteIapL

   403 // Deletes the named Internet Access Point

   404 // ----------------------------------------------------------------------------

   405 void CHtiIAPHandler::HandleDeleteIapL( const TDesC8& aData )

   406     {

   407     HTI_LOG_FUNC_IN( "CHtiIAPHandler::HandleDeleteIapL" );

   408     if ( aData.Length() < KMinDeleteMsgLength )

   409         {

   410         SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

   411         return;

   412         }

   413 

   414     TInt nameLength = aData[0];

   415     if ( nameLength > KMaxConnNameLength ||

   416          aData.Length() != ( nameLength + 1 ) )

   417         {

   418         SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

   419         return;

   420         }

   421 

   422     iConnName.Copy( aData.Mid( 1, nameLength ) );

   423     HTI_LOG_FORMAT( "Searching connection with name: %S", &iConnName );

   424     TInt uid = GetAccessPointUIDL();

   425 

   426     if ( uid == KErrNotFound )

   427         {

   428         SendErrorMessageL( KErrNotFound, KErrorApNotFound );

   429         return;

   430         }

   431 

   432     RCmManagerExt cmManagerExt;

   433     cmManagerExt.OpenL();

   434     CleanupClosePushL( cmManagerExt );

   435     RCmConnectionMethodExt connMethod = cmManagerExt.ConnectionMethodL( uid );

   436     CleanupClosePushL( connMethod );

   437     if ( connMethod.GetBoolAttributeL( ECmConnected ) )

   438         {

   439         HTI_LOG_TEXT( "AP in use - trying to close connections" );

   440         TRAPD( err, CloseActiveConnectionsL() );

   441         if ( err != KErrNone )

   442             {

   443             SendErrorMessageL( err, KErrorConnCloseFailed );

   444             CleanupStack::PopAndDestroy( 2 ); // connMethod, cmManagerExt

   445             return;

   446             }

   447         }

   448 

   449     HTI_LOG_TEXT( "AP not in use - unlinking from all destinations" );

   450     cmManagerExt.RemoveAllReferencesL( connMethod );

   451     HTI_LOG_TEXT( "Deleting the AP" );

   452     TBool deleted = connMethod.DeleteL(); // returns ETrue if really deleted

   453     if ( !deleted )

   454         {

   455         HTI_LOG_TEXT( "Delete failed" );

   456         User::Leave( KErrGeneral );

   457         }

   458     HTI_LOG_FORMAT( "AP deleted with uid %d", uid );

   459     CleanupStack::PopAndDestroy(); // connMethod

   460     CleanupStack::PopAndDestroy(); // cmManagerExt

   461 

   462     SendOkMsgL( KNullDesC8 );

   463     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::HandleDeleteIapL" );

   464     }

   465 

   466 

   467 // ----------------------------------------------------------------------------

   468 // CHtiIAPHandler::HandleCreateDestinationL

   469 // Creates a new Destination.

   470 // ----------------------------------------------------------------------------

   471 void CHtiIAPHandler::HandleCreateDestinationL( const TDesC8& aData )

   472     {

   473     HTI_LOG_FUNC_IN( "CHtiIAPHandler::HandleCreateDestinationL" );

   474 

   475     TInt nameLength = aData[0];

   476     if ( aData.Length() - 1 != nameLength || nameLength > KMaxConnNameLength )

   477         {

   478         SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

   479         return;

   480         }

   481 

   482     RCmManagerExt cmManager;

   483     cmManager.OpenL();

   484     CleanupClosePushL( cmManager );

   485 

   486     iDestName.Copy( aData.Mid( 1 ) );

   487 

   488     RCmDestinationExt dest = cmManager.CreateDestinationL( iDestName );

   489     CleanupClosePushL( dest );

   490     dest.UpdateL();

   491 

   492     CleanupStack::PopAndDestroy( 2 ); // dest, cmManager

   493     SendOkMsgL( KNullDesC8 );

   494 

   495     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::HandleCreateDestinationL" );

   496     }

   497 

   498 

   499 // ----------------------------------------------------------------------------

   500 // CHtiIAPHandler::HandleDeleteDestinationL

   501 // Deletes a named Destination.

   502 // ----------------------------------------------------------------------------

   503 void CHtiIAPHandler::HandleDeleteDestinationL( const TDesC8& aData )

   504     {

   505     HTI_LOG_FUNC_IN( "CHtiIAPHandler::HandleDeleteDestinationL" );

   506 

   507     TInt nameLength = aData[0];

   508     if ( aData.Length() - 1 != nameLength || nameLength > KMaxConnNameLength )

   509         {

   510         SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

   511         return;

   512         }

   513 

   514     iDestName.Copy( aData.Mid( 1 ) );

   515     TInt id = GetDestinationIDL( iDestName );

   516 

   517     RCmManagerExt cmManager;

   518     cmManager.OpenL();

   519     CleanupClosePushL( cmManager );

   520 

   521     RCmDestinationExt dest = cmManager.DestinationL ( id );

   522     dest.DeleteLD();

   523 

   524     CleanupStack::PopAndDestroy(); // cmManager

   525     SendOkMsgL( KNullDesC8 );

   526 

   527     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::HandleDeleteDestinationL" );

   528     }

   529 

   530 

   531 // ----------------------------------------------------------------------------

   532 // CHtiIAPHandler::ModifyDestinationL

   533 // Adds or removes IAP to/from a Destination.

   534 // ----------------------------------------------------------------------------

   535 void CHtiIAPHandler::ModifyDestinationL( const TInt aCommand, const TDesC8& aData )

   536     {

   537     HTI_LOG_FUNC_IN( "CHtiIAPHandler::ModifyDestinationL" );

   538 

   539     TInt dataLength = aData.Length();

   540     TInt offset = 0;

   541     TInt cmNameLength = aData[offset];

   542     offset++;

   543     if ( dataLength < cmNameLength + 3 || cmNameLength > KMaxConnNameLength )

   544         {

   545         SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

   546         return;

   547         }

   548     iConnName.Copy( aData.Mid( offset, cmNameLength ) );

   549     offset += cmNameLength;

   550     TInt destNameLength = aData[offset];

   551     offset++;

   552     if ( dataLength != cmNameLength + destNameLength + 2 ||

   553             destNameLength > KMaxConnNameLength )

   554         {

   555         SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

   556         return;

   557         }

   558 

   559     iDestName.Copy( aData.Mid( offset, destNameLength ) );

   560 

   561     TInt cmId = GetAccessPointUIDL();

   562     if ( cmId == KErrNotFound )

   563         {

   564         SendErrorMessageL( KErrNotFound, KErrorApNotFound );

   565         return;

   566         }

   567     TInt destId = GetDestinationIDL( iDestName );

   568     if ( destId == KErrNotFound )

   569         {

   570         SendErrorMessageL( KErrNotFound, KErrorDestNotFound );

   571         return;

   572         }

   573 

   574     RCmManagerExt cmManager;

   575     cmManager.OpenL();

   576     CleanupClosePushL( cmManager );

   577 

   578     RCmConnectionMethodExt cm = cmManager.ConnectionMethodL( cmId );

   579     CleanupClosePushL( cm );

   580     HTI_LOG_TEXT( "Got Connection Method" );

   581 

   582     RCmDestinationExt dest = cmManager.DestinationL( destId );

   583     CleanupClosePushL( dest );

   584     HTI_LOG_TEXT( "Got Destination" );

   585 

   586     if ( aCommand == CHtiMessagesServicePlugin::EAddToDestination )

   587         {

   588         dest.AddConnectionMethodL( cm );

   589         }

   590     else if ( aCommand == CHtiMessagesServicePlugin::ERemoveFromDestination)

   591         {

   592         dest.RemoveConnectionMethodL( cm );

   593         }

   594     else

   595         {

   596         // Programming error

   597         User::Panic( _L( "CHtiIAPHandler"), 1 );

   598         }

   599     dest.UpdateL();

   600     HTI_LOG_TEXT( "Destination updated" );

   601 

   602     CleanupStack::PopAndDestroy( 3 ); // dest, cm, cmManager

   603     SendOkMsgL( KNullDesC8 );

   604 

   605     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::ModifyDestinationL" );

   606     }

   607 

   608 

   609 // ----------------------------------------------------------------------------

   610 // CHtiIAPHandler::SetDefaultConnectionL

   611 // Sets the default connection setting.

   612 // ----------------------------------------------------------------------------

   613 void CHtiIAPHandler::SetDefaultConnectionL( const TDesC8& aData )

   614     {

   615     HTI_LOG_FUNC_IN( "CHtiIAPHandler::SetDefaultConnectionL" );

   616 

   617     if ( aData[0] > 3 || aData.Length() != aData[1] + 2 )

   618         {

   619         User::Leave( KErrArgument );

   620         }

   621 

   622     TCmDefConnValue defConnValue;

   623     defConnValue.iType = ( TCmDefConnType ) aData[0]; // cmdefconnvalues.h

   624     HTI_LOG_FORMAT( "Requested type: %d", defConnValue.iType );

   625 

   626     TInt id = 0;

   627     if ( defConnValue.iType == ECmDefConnDestination )

   628         {

   629         if ( aData[1] == 0 || aData[1] > KMaxConnNameLength )

   630             {

   631             User::Leave( KErrArgument );

   632             }

   633         iDestName.Copy( aData.Mid( 2 ) );

   634         HTI_LOG_FORMAT( "Destination name: %S", &iDestName );

   635         id = GetDestinationIDL( iDestName );

   636         if ( id == KErrNotFound )

   637             {

   638             SendErrorMessageL( KErrNotFound, KErrorDestNotFound );

   639             return;

   640             }

   641         }

   642 

   643     else if ( defConnValue.iType == ECmDefConnConnectionMethod )

   644         {

   645         if ( aData[1] == 0 || aData[1] > KMaxConnNameLength )

   646             {

   647             User::Leave( KErrArgument );

   648             }

   649         iConnName.Copy( aData.Mid( 2 ) );

   650         HTI_LOG_FORMAT( "Connection method name: %S", &iConnName );

   651         id = GetAccessPointUIDL();

   652         if ( id == KErrNotFound )

   653             {

   654             SendErrorMessageL( KErrNotFound, KErrorApNotFound );

   655             return;

   656             }

   657         }

   658 

   659     defConnValue.iId = id;

   660 

   661     RCmManagerExt cmManager;

   662     cmManager.OpenL();

   663     CleanupClosePushL( cmManager );

   664     cmManager.WriteDefConnL( defConnValue );

   665     CleanupStack::PopAndDestroy();

   666     SendOkMsgL( KNullDesC8 );

   667 

   668     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::SetDefaultConnectionL" );

   669     }

   670 

   671 

   672 // ----------------------------------------------------------------------------

   673 // CHtiIAPHandler::ParseCreateMessageL

   674 // Parses the parameters from the create IAP message. Leaves on error.

   675 // ----------------------------------------------------------------------------

   676 void CHtiIAPHandler::ParseCreateMessageL( const TDesC8& aData )

   677     {

   678     HTI_LOG_FUNC_IN( "CHtiIAPHandler::ParseCreateMessageL" );

   679 

   680     TInt dataLength = aData.Length();

   681     TInt offset = 0;

   682 

   683     iBearerType = GetBearerUID( aData[offset] );

   684     offset++;

   685     HTI_LOG_FORMAT( "Bearer type %d", iBearerType );

   686     if ( iBearerType == 0 )

   687         {

   688         User::Leave( KErrArgument );

   689         }

   690 

   691     TInt nameLength = aData[offset];

   692     offset++;

   693     if ( dataLength < ( nameLength + offset + 1 ) ||

   694          nameLength > KMaxConnNameLength )

   695         {

   696         User::Leave( KErrArgument );

   697         }

   698     iConnName.Copy( aData.Mid( offset, nameLength ) );

   699     offset += nameLength;

   700     HTI_LOG_FORMAT( "Connection name: %S", &iConnName );

   701 

   702     TInt fieldCount = aData[offset];

   703     offset++;

   704     HTI_LOG_FORMAT( "Field count %d", fieldCount );

   705 

   706     for ( TInt i = 0; i < fieldCount; i++ )

   707         {

   708         if ( dataLength < ( offset + 3 ) )

   709             {

   710             User::Leave( KErrArgument );

   711             }

   712         HTI_LOG_FORMAT( "Parsing field %d", i + 1 );

   713         TApField field;

   714         field.iId = aData[offset];

   715         offset++;

   716         TInt fieldLength = aData[offset];

   717         offset++;

   718         HTI_LOG_FORMAT( "Field data length %d", fieldLength );

   719         if ( fieldLength < 1 || dataLength < ( fieldLength + offset ) )

   720             {

   721             User::Leave( KErrArgument );

   722             }

   723         field.iData = HBufC::NewL( fieldLength );

   724         field.iData->Des().Copy( aData.Mid( offset, fieldLength ) );

   725         offset += fieldLength;

   726         HTI_LOG_FORMAT( "Field data: %S", field.iData );

   727         field.iDataType = EDataTypeUnknown; // set later

   728         User::LeaveIfError( iFields.Append( field ) );

   729         }

   730 

   731     if ( offset != dataLength )  // too much data

   732         {

   733         User::Leave( KErrArgument );

   734         }

   735 

   736     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::ParseCreateMessageL" );

   737     }

   738 

   739 // ----------------------------------------------------------------------------

   740 // CHtiIAPHandler::GetAccessPointUIDL

   741 // Gets the UID of Access Point named by iConnName.

   742 // Returns KErrNotFound if AP not found.

   743 // ----------------------------------------------------------------------------

   744 TInt CHtiIAPHandler::GetAccessPointUIDL()

   745     {

   746     HTI_LOG_FUNC_IN( "CHtiIAPHandler::GetAccessPointUIDL" );

   747     TInt uid = KErrNotFound;

   748 

   749     RCmManagerExt cmManager;

   750     cmManager.OpenL();

   751     CleanupClosePushL( cmManager );

   752 

   753     // Search from uncategorised first

   754     RArray<TUint32> array = RArray<TUint32>();

   755     cmManager.ConnectionMethodL( array );

   756     CleanupClosePushL( array );

   757     TInt i = 0;

   758     while ( i < array.Count() && uid == KErrNotFound )

   759         {

   760         RCmConnectionMethodExt cm = cmManager.ConnectionMethodL( array[i] );

   761         CleanupClosePushL( cm );

   762         HBufC* name = cm.GetStringAttributeL( ECmName );

   763         HTI_LOG_FORMAT( "Found name: %S", name );

   764         CleanupStack::PushL( name );

   765         if ( iConnName.Compare( *name ) == 0 )

   766             {

   767             uid = cm.GetIntAttributeL( ECmId );

   768             HTI_LOG_FORMAT( "Match: UID = %d", uid );

   769             }

   770         CleanupStack::PopAndDestroy(); // name

   771         CleanupStack::PopAndDestroy(); // cm

   772         i++;

   773         }

   774     CleanupStack::PopAndDestroy(); // array

   775 

   776     // If not found from uncategorised, search from all destinations

   777     if ( uid == KErrNotFound )

   778         {

   779         HTI_LOG_TEXT( "Not found from uncategorised" );

   780         RArray<TUint32> destIdArray = RArray<TUint32>();

   781         cmManager.AllDestinationsL( destIdArray );

   782         CleanupClosePushL( destIdArray );

   783         i = 0;

   784         while ( i < destIdArray.Count() && uid == KErrNotFound )

   785             {

   786             RCmDestinationExt dest = cmManager.DestinationL( destIdArray[i] );

   787             CleanupClosePushL( dest );

   788             TInt j = 0;

   789             while ( j < dest.ConnectionMethodCount() && uid == KErrNotFound )

   790                 {

   791                 HBufC* name = dest.ConnectionMethodL( j ).GetStringAttributeL(

   792                         ECmName );

   793                 CleanupStack::PushL( name );

   794                 HTI_LOG_FORMAT( "Found name: %S", name );

   795                 if ( iConnName.Compare( *name ) == 0 )

   796                     {

   797                     uid = dest.ConnectionMethodL( j ).GetIntAttributeL(

   798                             ECmId );

   799                     HTI_LOG_FORMAT( "Match: UID = %d", uid );

   800                     }

   801                 CleanupStack::PopAndDestroy(); // name

   802                 j++;

   803                 }

   804             CleanupStack::PopAndDestroy(); // dest

   805             i++;

   806             }

   807         CleanupStack::PopAndDestroy(); // destIdArray

   808         }

   809 

   810     CleanupStack::PopAndDestroy(); // cmManager

   811     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::GetAccessPointUIDL" );

   812     return uid;

   813     }

   814 

   815 // ----------------------------------------------------------------------------

   816 // CHtiIAPHandler::GetDestinationIDL

   817 // Gets the ID of Destination named by aName.

   818 // Returns KErrNotFound if Destination is not found.

   819 // ----------------------------------------------------------------------------

   820 TInt CHtiIAPHandler::GetDestinationIDL( const TDesC& aName )

   821     {

   822     HTI_LOG_FUNC_IN( "CHtiIAPHandler::GetDestinationIDL" );

   823     HTI_LOG_FORMAT( "Searching Destination %S", &aName );

   824 

   825     RCmManagerExt cmManager;

   826     cmManager.OpenL();

   827     CleanupClosePushL( cmManager );

   828 

   829     TInt id = KErrNotFound;

   830     RArray<TUint32> destIdArray = RArray<TUint32>( 8 );

   831     CleanupClosePushL( destIdArray );

   832 

   833     cmManager.AllDestinationsL( destIdArray );

   834     TInt i = 0;

   835     while ( i < destIdArray.Count() && id == KErrNotFound )

   836         {

   837         RCmDestinationExt dest = cmManager.DestinationL( destIdArray[i] );

   838         CleanupClosePushL( dest );

   839         HBufC* destName = dest.NameLC();

   840         HTI_LOG_FORMAT( "Found Destination: %S", destName );

   841         if ( destName->Compare( aName ) == 0 )

   842             {

   843             id = dest.Id();

   844             HTI_LOG_FORMAT( "Match: ID = %d", id );

   845             }

   846         CleanupStack::PopAndDestroy( 2 ); // destName, dest

   847         i++;

   848         }

   849 

   850     CleanupStack::PopAndDestroy( 2 ); // destIdArray, cmManager

   851     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::GetDestinationIDL" );

   852     return id;

   853     }

   854 

   855 

   856 // ----------------------------------------------------------------------------

   857 // CHtiIAPHandler::CloseActiveConnectionsL

   858 // Closes connection(s) that are using the Access Point named by iConnName.

   859 // Leaves if closing fails.

   860 // ----------------------------------------------------------------------------

   861 void CHtiIAPHandler::CloseActiveConnectionsL()

   862     {

   863     HTI_LOG_FUNC_IN( "CHtiIAPHandler::CloseActiveConnectionsL" );

   864 

   865     RConnectionMonitor monitor;

   866     monitor.ConnectL();

   867     CleanupClosePushL( monitor );

   868     HTI_LOG_TEXT( "RConnectionMonitor connected" );

   869 

   870     TUint connCount = 0;

   871     TUint subConnCount = 0;

   872     TUint connId = 0;

   873     //TUint iapId = 0;

   874     TName iapName;

   875     TRequestStatus status;

   876 

   877     monitor.GetConnectionCount( connCount, status );

   878     User::WaitForRequest( status );

   879     User::LeaveIfError( status.Int() );

   880     HTI_LOG_FORMAT( "Found %d connections", connCount );

   881 

   882     for ( TUint i = 1; i <= connCount; i++ )

   883         {

   884         HTI_LOG_FORMAT( "Connection %d", i );

   885         User::LeaveIfError(

   886             monitor.GetConnectionInfo( i, connId, subConnCount ) );

   887         HTI_LOG_FORMAT( " Connection ID = %d", connId );

   888         HTI_LOG_FORMAT( " Sub connections = %d", subConnCount );

   889         /*

   890         monitor.GetUintAttribute( connId, 0, KIAPId, iapId, status );

   891         User::WaitForRequest( status );

   892         User::LeaveIfError( status.Int() );

   893         HTI_LOG_FORMAT( " IAP ID = %d", iapId );

   894         */

   895         monitor.GetStringAttribute( connId, 0, KIAPName, iapName, status );

   896         User::WaitForRequest( status );

   897         User::LeaveIfError( status.Int() );

   898         HTI_LOG_FORMAT( " IAP name = %S", &iapName );

   899         if ( iapName.Compare( iConnName ) == 0 )

   900             {

   901             HTI_LOG_TEXT( " Match: Trying to close this connection" );

   902             User::LeaveIfError(

   903                 monitor.SetBoolAttribute( connId, 0, KConnectionStop, ETrue ) );

   904             }

   905         }

   906 

   907     CleanupStack::PopAndDestroy(); // monitor

   908     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::CloseActiveConnectionsL" );

   909     }

   910 

   911 // ----------------------------------------------------------------------------

   912 // CHtiIAPHandler::GetBearerUID

   913 // Helper function for mapping old TApBearerType value to new bearer type

   914 // ECom UID.

   915 // ----------------------------------------------------------------------------

   916 TUint CHtiIAPHandler::GetBearerUID( const TInt aBearerType )

   917     {

   918     HTI_LOG_FUNC_IN( "CHtiIAPHandler::GetBearerUID" );

   919     TUint uid = 0;

   920     switch ( aBearerType )

   921         {

   922         case 0x01:  // CSD

   923             uid = KUidCSDBearerType;

   924             break;

   925         case 0x02:  // GPRS

   926             uid = KUidPacketDataBearerType;

   927             break;

   928         case 0x04:  // HSCSD

   929             uid = KUidHSCSDBearerType;

   930             break;

   931         case 0x10:  // CDMA

   932             uid = KUidPacketDataBearerType;

   933             break;

   934         case 0x20:  // WLAN

   935             uid = KUidWlanBearerType;

   936             break;

   937         default:

   938             break;

   939 

   940         }

   941     HTI_LOG_FUNC_OUT( "CHtiIAPHandler::GetBearerUID" );

   942     return uid;

   943     }

   944 

   945 // ----------------------------------------------------------------------------

   946 // CHtiIAPHandler::MapLegacyFieldIDs

   947 // Helper function for mapping the old access point field ID numbers to

   948 // new ones.

   949 // ----------------------------------------------------------------------------

   950 void CHtiIAPHandler::MapLegacyFieldIDs()

   951     {

   952     HTI_LOG_FUNC_IN( "CHtiIAPHandler::MapLegacyFieldIDs" );

   953 

   954     for ( TInt i = 0; i < iFields.Count(); i++ )

   955         {

   956         TApField field = iFields[i];

   957         switch ( field.iId )

   958             {

   959             case EApWapStartPage:

   960                 {

   961                 field.iId = ECmStartPage;

   962                 break;

   963                 }

   964             case EApIspDefaultTelNumber:

   965                 {

   966                 field.iId = EDialDefaultTelNum;

   967                 break;

   968                 }

   969             case EApIspUseLoginScript:

   970                 {

   971                 field.iId = EDialUseLoginScript;

   972                 break;

   973                 }

   974             case EApIspLoginScript:

   975                 {

   976                 field.iId = EDialLoginScript;

   977                 break;

   978                 }

   979             case EApIspLoginName:

   980                 {

   981                 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType )

   982                     field.iId = EDialIFAuthName;

   983                 else if ( iBearerType == KUidPacketDataBearerType )

   984                     field.iId = EPacketDataIFAuthName;

   985                 else

   986                     field.iId = ECmIFAuthName;

   987                 break;

   988                 }

   989             case EApIspLoginPass:

   990                 {

   991                 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType )

   992                     field.iId = EDialIFAuthPass;

   993                 else if ( iBearerType == KUidPacketDataBearerType )

   994                     field.iId = EPacketDataIFAuthPass;

   995                 else

   996                     field.iId = ECmIFAuthPass;

   997                 break;

   998                 }

   999             case EApIspIfPromptForAuth:

  1000                 {

  1001                 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType )

  1002                     field.iId = EDialIFPromptForAuth;

  1003                 else if ( iBearerType == KUidPacketDataBearerType )

  1004                     field.iId = EPacketDataIFPromptForAuth;

  1005                 else

  1006                     field.iId = ECmIFPromptForAuth;

  1007                 break;

  1008                 }

  1009             case EApIspIfCallbackEnabled:

  1010                 {

  1011                 field.iId = EDialIFCallbackEnabled;

  1012                 break;

  1013                 }

  1014             case EApIspIfCallbackType:

  1015                 {

  1016                 field.iId = EDialIFCallbackType;

  1017                 break;

  1018                 }

  1019             case EApIspIfCallbackInfo:

  1020                 {

  1021                 field.iId = EDialIFCallbackInfo;

  1022                 break;

  1023                 }

  1024             case EApIspIPAddr:

  1025                 {

  1026                 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType )

  1027                     field.iId = EDialIPAddress;

  1028                 else if ( iBearerType == KUidPacketDataBearerType )

  1029                     field.iId = EPacketDataIPAddr;

  1030                 else if ( iBearerType == KUidWlanBearerType )

  1031                     field.iId = EWlanIpAddr;

  1032                 else

  1033                     field.iId = ECmIPAddress;

  1034                 break;

  1035                 }

  1036             case EApIspIPNameServer1:

  1037                 {

  1038                 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType )

  1039                     field.iId = EDialIPNameServer1;

  1040                 else if ( iBearerType == KUidPacketDataBearerType )

  1041                     field.iId = EPacketDataIPNameServer1;

  1042                 else if ( iBearerType == KUidWlanBearerType )

  1043                     field.iId = EWlanIpNameServer1;

  1044                 else

  1045                     field.iId = ECmIPNameServer1;

  1046                 break;

  1047                 }

  1048             case EApIspIPNameServer2:

  1049                 {

  1050                 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType )

  1051                     field.iId = EDialIPNameServer2;

  1052                 else if ( iBearerType == KUidPacketDataBearerType )

  1053                     field.iId = EPacketDataIPNameServer2;

  1054                 else if ( iBearerType == KUidWlanBearerType )

  1055                     field.iId = EWlanIpNameServer2;

  1056                 else

  1057                     field.iId = ECmIPNameServer2;

  1058                 break;

  1059                 }

  1060             case EApIspEnableIpHeaderComp:

  1061                 {

  1062                 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType )

  1063                     field.iId = EDialEnableIPHeaderComp;

  1064                 else if ( iBearerType == KUidPacketDataBearerType )

  1065                     field.iId = EPacketDataHeaderCompression;

  1066                 break;

  1067                 }

  1068             case EApIspDisablePlainTextAuth:

  1069                 {

  1070                 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType )

  1071                     field.iId = EDialDisablePlainTextAuth;

  1072                 else if ( iBearerType == KUidPacketDataBearerType )

  1073                     field.iId = EPacketDataDisablePlainTextAuth;

  1074                 else

  1075                     field.iId = ECmDisablePlainTextAuth;

  1076                 break;

  1077                 }

  1078             case EApIspBearerSpeed:

  1079                 {

  1080                 field.iId = EDialMaxConnSpeed;

  1081                 break;

  1082                 }

  1083             case EApIspBearerCallTypeIsdn:

  1084                 {

  1085                 field.iId = EDialCallType;

  1086                 break;

  1087                 }

  1088             case EApIspInitString:

  1089                 {

  1090                 field.iId = EDialInitString;

  1091                 break;

  1092                 }

  1093             case EApGprsAccessPointName:

  1094                 {

  1095                 field.iId = EPacketDataAPName;

  1096                 break;

  1097                 }

  1098             case EApGprsPdpType:

  1099                 {

  1100                 field.iId = EPacketDataPDPType;

  1101                 break;

  1102                 }

  1103             case EApProxyServerAddress:

  1104                 {

  1105                 field.iId = ECmProxyServerName;

  1106                 break;

  1107                 }

  1108             case EApProxyPortNumber:

  1109                 {

  1110                 field.iId = ECmProxyPortNumber;

  1111                 break;

  1112                 }

  1113             case EApIP6NameServer1:

  1114                 {

  1115                 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType )

  1116                     field.iId = EDialIP6NameServer1;

  1117                 else if ( iBearerType == KUidPacketDataBearerType )

  1118                     field.iId = EPacketDataIPIP6NameServer1;

  1119                 else if ( iBearerType == KUidWlanBearerType )

  1120                     field.iId = EWlanIp6NameServer1;

  1121                 else

  1122                     field.iId = ECmIP6NameServer1;

  1123                 break;

  1124                 }

  1125             case EApIP6NameServer2:

  1126                 {

  1127                 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType )

  1128                     field.iId = EDialIP6NameServer2;

  1129                 else if ( iBearerType == KUidPacketDataBearerType )

  1130                     field.iId = EPacketDataIPIP6NameServer2;

  1131                 else if ( iBearerType == KUidWlanBearerType )

  1132                     field.iId = EWlanIp6NameServer2;

  1133                 else

  1134                     field.iId = ECmIP6NameServer2;