1 /*

     2 * Copyright (c) 2009-2010 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:  VoIP settings XML parameter handler.

    15 *

    16 */

    17 

    18 

    19 #include "voipxmlparamhandler.h"

    20 #include "voipxmlsiphandler.h"

    21 #include "voipxmlvoiphandler.h"

    22 #include "voipxmlxdmhandler.h"

    23 #include "voipxmlpresencehandler.h"

    24 #include "voipxmlnatfwhandler.h"

    25 #include "voipxmliaphandler.h"

    26 #include "voipxmlprocessordefaults.h"

    27 

    28 // ---------------------------------------------------------------------------

    29 // Default constructor.

    30 // ---------------------------------------------------------------------------

    31 //

    32 CVoipXmlParamHandler::CVoipXmlParamHandler()

    33     {

    34     }

    35 

    36 // ---------------------------------------------------------------------------

    37 // ConstructL

    38 // ---------------------------------------------------------------------------

    39 //

    40 void CVoipXmlParamHandler::ConstructL()

    41     {

    42     iSettingsType         = EUnknown;

    43     iPreviousSettingsType = EUnknown;

    44     iSipHandler      = CVoipXmlSipHandler::NewL();

    45     iVoipHandler     = CVoipXmlVoipHandler::NewL();

    46     iXdmHandler      = CVoipXmlXdmHandler::NewL();

    47     iPresenceHandler = CVoipXmlPresenceHandler::NewL();

    48     iNatFwHandler    = CVoipXmlNatFwHandler::NewL();

    49     iIapHandler      = CVoipXmlIapHandler::NewL();

    50     }

    51 

    52 // ---------------------------------------------------------------------------

    53 // NewL

    54 // ---------------------------------------------------------------------------

    55 //

    56 CVoipXmlParamHandler* CVoipXmlParamHandler::NewL()

    57     {

    58     CVoipXmlParamHandler* self = CVoipXmlParamHandler::NewLC();

    59     CleanupStack::Pop( self );

    60     return self;

    61     }

    62 

    63 // ---------------------------------------------------------------------------

    64 // NewLC

    65 // ---------------------------------------------------------------------------

    66 //

    67 CVoipXmlParamHandler* CVoipXmlParamHandler::NewLC()

    68     {

    69     CVoipXmlParamHandler* self = new( ELeave ) CVoipXmlParamHandler;

    70     CleanupStack::PushL( self );

    71     self->ConstructL();

    72     return self;

    73     }

    74 

    75 // ---------------------------------------------------------------------------

    76 // Destructor.

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

    78 //

    79 CVoipXmlParamHandler::~CVoipXmlParamHandler()

    80     {

    81     delete iSipHandler;

    82     delete iVoipHandler;

    83     delete iXdmHandler;

    84     delete iPresenceHandler;

    85     delete iNatFwHandler;

    86     delete iIapHandler;

    87     }

    88 

    89 // ---------------------------------------------------------------------------

    90 // Marks the currently deployed settings.

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

    92 //

    93 void CVoipXmlParamHandler::SettingsStart( const TDesC& aType )

    94     {

    95     TBuf<KMaxNodeNameLength> type( KNullDesC );

    96     type.Copy( aType );

    97     type.LowerCase();

    98     iPreviousSettingsType = iSettingsType;

    99     if ( KSettingsTypeVoip() == type )

   100         {

   101         iSettingsType = EVoip;

   102         }

   103     else if ( KSettingsTypeSip() == type )

   104         {

   105         iSettingsType = ESip;

   106         }

   107     else if ( KSettingsTypePresence() == type )

   108         {

   109         iSettingsType = EPresence;

   110         }

   111     else if ( KSettingsTypeXdm() == type )

   112         {

   113         iSettingsType = EXdm;

   114         }

   115     else if ( KSettingsTypeNatFw() == type )

   116         {

   117         iSettingsType = ENatFw;

   118         }

   119     else if ( KSettingsTypeCodec() == type )

   120         {

   121         iSettingsType = ECodec;

   122         }

   123     else if ( KSettingsTypeVmbx() == type )

   124         {

   125         iSettingsType = EVmbx;

   126         }

   127     else if ( KSettingsTypeProxy() == type )

   128         {

   129         iSettingsType = EProxy;

   130         }

   131     else if ( KSettingsTypeRegistrar() == type )

   132         {

   133         iSettingsType = ERegistrar;

   134         }

   135     else if ( KSettingsTypeAdditionalStun() == type )

   136         {

   137         iSettingsType = EAdditionalStun;

   138         }

   139     else if ( KSettingsTypeWlan() == type )

   140         {

   141         iSettingsType = EWlan;

   142         }

   143     else if ( KSettingsTypeWepKey() == type )

   144         {

   145         iSettingsType = EWepKey;

   146         }

   147     else if ( KSettingsTypeDestination() == type )

   148         {

   149         iSettingsType = EDestination;

   150         }

   151     else

   152         {

   153         iSettingsType = EUnknown;

   154         }

   155     }

   156 

   157 // ---------------------------------------------------------------------------

   158 // Marks the currently deployed settings as 'ready', i.e. sets current

   159 // settings type to previous one and informs settings handlers.

   160 // ---------------------------------------------------------------------------

   161 //

   162 void CVoipXmlParamHandler::SettingsEnd()

   163     {

   164     iVoipHandler->SettingsEnd( iSettingsType );

   165     iNatFwHandler->SettingsEnd( iSettingsType );

   166     iIapHandler->SettingsEnd( iSettingsType );

   167     iSettingsType = iPreviousSettingsType;

   168     iPreviousSettingsType = EUnknown;

   169     }

   170 

   171 // ---------------------------------------------------------------------------

   172 // Handles XML parameters, i.e. converts parameter names to enum and sets

   173 // the values to setting handlers.

   174 // ---------------------------------------------------------------------------

   175 //

   176 void CVoipXmlParamHandler::HandleParameter( const TDesC& aParam, 

   177     const TDesC& aValue )

   178     {

   179     switch ( iSettingsType )

   180         {

   181         case EVoip:

   182         case EVmbx:

   183         case ECodec:

   184             {

   185             TInt param = ConvertParameter( aParam );

   186             iVoipHandler->SetSetting( iSettingsType, param, aValue );

   187             }

   188             break;

   189         case ESip:

   190         case EProxy:

   191         case ERegistrar:

   192             {

   193             TInt param = ConvertParameter( aParam );

   194             TBuf8<KMaxNodeValueLength> value;

   195             value.Copy( aValue );

   196             iSipHandler->SetSetting( iSettingsType, param, value );

   197             }

   198             break;

   199         case EPresence:

   200             {

   201             TInt param = ConvertParameter( aParam );

   202             iPresenceHandler->SetSetting( param, aValue );

   203             }

   204             break;

   205         case EXdm:

   206             {

   207             TInt param = ConvertParameter( aParam );

   208             iXdmHandler->SetSetting( param, aValue );

   209             }

   210             break;

   211         case ENatFw:

   212         case EAdditionalStun:

   213             {

   214             TInt param = ConvertParameter( aParam );

   215             TBuf8<KMaxNodeValueLength> value;

   216             value.Copy( aValue );

   217             iNatFwHandler->SetSetting( iSettingsType, param, value );

   218             }

   219             break;

   220         case EWlan:

   221         case EWepKey:

   222         case EDestination:

   223             {

   224             TInt param = ConvertParameter( aParam );

   225             iIapHandler->SetSetting( iSettingsType, param, aValue );

   226             }

   227             break;

   228         default:

   229             break;

   230         }

   231     }

   232 

   233 // ---------------------------------------------------------------------------

   234 // Stores settings, i.e. sends store commands to settings handlers.

   235 // ---------------------------------------------------------------------------

   236 //

   237 TInt CVoipXmlParamHandler::StoreSettings()

   238     {

   239     // First send 'basic' store commands.

   240     TInt err( KErrNone );

   241     err = iSipHandler->StoreSettings();

   242     if ( KErrNone != err )

   243         {

   244         return err;

   245         }

   246     err = iVoipHandler->StoreSettings();

   247     if ( KErrNone != err )

   248         {

   249         return err;

   250         }

   251     err = iXdmHandler->StoreSettings();

   252     // If there were no settings, ignore error code.

   253     if ( KErrNotSupported == err )

   254         {

   255         err = KErrNone;

   256         }

   257     err = iPresenceHandler->StoreSettings();

   258     // If there were no settings, ignore error code.

   259     if ( KErrNotSupported == err )

   260         {

   261         err = KErrNone;

   262         }

   263 

   264     err = iNatFwHandler->StoreSettings();

   265     // If there were no settings, ignore error code.

   266     if ( KErrNotSupported == err )

   267         {

   268         err = KErrNone;

   269         }

   270 

   271     err = iIapHandler->StoreSettings();

   272     // If there were no settings, ignore error code.

   273     if ( KErrNotSupported == err )

   274         {

   275         err = KErrNone;

   276         }

   277 

   278     // Send linkage information.

   279     iSipHandler->LinkSettings( EDestination, iIapHandler->SettingsId() );

   280     iVoipHandler->LinkSettings( ESip, iSipHandler->SettingsId() );

   281     iVoipHandler->LinkSettings( EPresence, iPresenceHandler->SettingsId() );

   282     iVoipHandler->LinkSettings( EDestination, iIapHandler->SettingsId() );

   283     iPresenceHandler->LinkSettings( ESip, iSipHandler->SettingsId() );

   284     iPresenceHandler->LinkSettings( EXdm, iXdmHandler->SettingsId() );

   285 

   286     // Send finalizing commands.

   287     iSipHandler->FinalizeSettings(); // Ignore error code.

   288     err = iVoipHandler->FinalizeSettings();

   289     iPresenceHandler->FinalizeSettings(); // Ignore error code.

   290     return err;

   291     }

   292 

   293 // ---------------------------------------------------------------------------

   294 // Returns the VoIP service ID.

   295 // ---------------------------------------------------------------------------

   296 //

   297 TUint32 CVoipXmlParamHandler::ServiceTabId()

   298     {

   299     TUint32 tabId( KErrNone );

   300     TRAP_IGNORE( tabId = iVoipHandler->ServiceTabIdL() );

   301     return tabId;

   302     }

   303 

   304 // ---------------------------------------------------------------------------

   305 // Converts parameter name to enumerated parameter.

   306 // ---------------------------------------------------------------------------

   307 //

   308 TInt CVoipXmlParamHandler::ConvertParameter( const TDesC& aParam )

   309     {

   310     TBuf<KMaxNodeNameLength> name( KNullDesC );

   311     name.Copy( aParam );

   312     name.LowerCase();

   313     // ==============================

   314     // Generic parameters.

   315     // ==============================

   316     //

   317     if ( KParamValueName() == name )

   318         {

   319         return EName;

   320         }

   321     else if ( KParamValueUri() == name )

   322         {

   323         return EUri;

   324         }

   325     else if ( KParamValueTransport() == name )

   326         {

   327         return ETransport;

   328         }

   329     else if ( KParamValuePort() == name )

   330         {

   331         return EPort;

   332         }

   333     else if ( KParamValueUsername() == name )

   334         {

   335         return EUsername;

   336         }

   337     else if ( KParamValuePassword() == name )

   338         {

   339         return EPassword;

   340         }

   341     else if ( KParamValueType() == name )

   342         {

   343         return EType;

   344         }

   345     else if ( KParamValueDomain() == name )

   346         {

   347         return EDomain;

   348         }

   349     else if ( KParamValueStartPort() == name )

   350         {

   351         return EStartPort;

   352         }

   353     else if ( KParamValueEndPort() == name )

   354         {

   355         return EEndPort;

   356         }

   357     // ==============================

   358     // VoIP 'core' parametes.

   359     // ==============================

   360     //

   361     else if ( KParamValueMediaQos() == name )

   362         {

   363         return EMediaQos;

   364         }

   365     else if ( KParamValueDtmfInband() == name )

   366         {

   367         return EDtmfInband;

   368         }

   369     else if ( KParamValueDtmfOutband() == name )

   370         {

   371         return EDtmfOutband;

   372         }

   373     else if ( KParamValueSecureCallPref() == name )

   374         {

   375         return ESecureCallPreference;

   376         }

   377     else if ( KParamValueVoipOverWcdma() == name )

   378         {

   379         return EAllowVoipOverWcdma;

   380         }

   381     else if ( KParamValueRtcp() == name )

   382         {

   383         return ERtcp;

   384         }

   385     else if ( KParamValueUserAgentTerminalType() == name )

   386         {

   387         return EUserAgentHeaderTerminalType;

   388         }

   389     else if ( KParamValueUserAgentWlanMac() == name )

   390         {

   391         return EUserAgentHeaderWlanMac;

   392         }

   393     else if ( KParamValueUserAgentFreeString() == name )

   394         {

   395         return EUserAgentHeaderFreeString;

   396         }

   397     else if ( KParamValueCallerIdDigits() == name )

   398         {

   399         return ECallerIdDigits;

   400         }

   401     else if ( KParamValueIgnoreDomainPart() == name )

   402         {

   403         return EIgnoreDomainPart;

   404         }

   405     else if ( KParamValueAutoAcceptBuddyRequests() == name )

   406         {

   407         return EAutoAcceptBuddyRequests;

   408         }

   409     else if ( KParamValueAddUserPhone() == name )

   410         {

   411         return EAddUserPhone;

   412         }

   413     else if ( KParamValueProviderUrl() == name )

   414         {

   415         return EProviderUrl;

   416         }

   417     else if ( KParamValueMinSessionInterval() == name )

   418         {

   419         return EMinSessionInterval;

   420         }

   421     else if ( KParamValueSessionInterval() == name )

   422         {

   423         return ESessionInterval;

   424         }

   425     else if ( KParamValueBrandingUri() == name )

   426         {

   427         return EBrandingUri;

   428         }

   429     else if ( KParamValueAutoEnable() == name )

   430         {

   431         return EAutoEnable;

   432         }

   433     else if ( KParamValueEnableSipIm() == name )

   434         {

   435         return EEnableSipIm;

   436         }

   437     else if ( KParamValueBrandId() == name )

   438         {

   439         return EBrandId;

   440         }

   441     // ==============================

   442     // VoIP voicemailbox parameters.

   443     // ==============================

   444     //

   445     else if ( KParamValueMwiUri() == name )

   446         {

   447         return EMwiUri;

   448         }

   449     else if ( KParamValueListeningUri() == name )

   450         {

   451         return EListeningUri;

   452         }

   453     else if ( KParamValueReSubscribeInterval() == name )

   454         {

   455         return EReSubscribeInterval;

   456         }

   457     // ==============================

   458     // VoIP codec parameters.

   459     // ==============================

   460     //

   461     else if ( KParamValueJitterBuffer() == name )

   462         {

   463         return EJitterBuffer;

   464         }

   465     else if ( KParamValueOctetAlign() == name )

   466         {

   467         return EOctetAlign;

   468         }

   469     else if ( KParamValuePTime() == name )

   470         {

   471         return EPTime;

   472         }

   473     else if ( KParamValueMaxPTime() == name )

   474         {

   475         return EMaxPTime;

   476         }

   477     else if ( KParamValueModeSet() == name )

   478         {

   479         return EModeSet;

   480         }

   481     else if ( KParamValueModeChangePeriod() == name )

   482         {

   483         return EModeChangePeriod;

   484         }

   485     else if ( KParamValueModeChangeNeighbor() == name )

   486         {

   487         return EModeChangeNeighbor;

   488         }

   489     else if ( KParamValueMaxRed() == name )

   490         {

   491         return EMaxRed;

   492         }

   493     else if ( KParamValueVad() == name )

   494         {

   495         return EVad;

   496         }

   497     else if ( KParamValueAnnexB() == name )

   498         {

   499         return EAnnexb;

   500         }

   501     // ==============================

   502     // SIP parameters.

   503     // ==============================

   504     //

   505     else if ( KParamValueSignalingQos() == name )

   506         {

   507         return ESignalingQos;

   508         }

   509     else if ( KParamValuePublicUserId() == name )

   510         {

   511         return EPublicUserId;

   512         }

   513     else if ( KParamValueSignalCompression() == name )

   514         {

   515         return ESignalCompression;

   516         }

   517     else if ( KParamValueSecurityNegotiation() == name )

   518         {

   519         return ESecurityNegotiation;

   520         }

   521     else if ( KParamValueProfileLock() == name )

   522         {

   523         return EProfileLock;

   524         }

   525     else if ( KParamValueAutoRegistration() == name )

   526         {

   527         return EAutoRegistration;

   528         }

   529     else if ( KParamValueLooseRouting() == name )

   530         {

   531         return ELooseRouting;

   532         }

   533     // ==============================

   534     // Presence parameters.

   535     // ==============================

   536     //

   537     else if ( KParamValueMaxObjectSize() == name )

   538         {

   539         return EMaxObjectSize;

   540         }

   541     else if ( KParamValuePublishInterval() == name )

   542         {

   543         return EPublishInterval;

   544         }

   545     else if ( KParamValueMaxSubscriptions() == name )

   546         {

   547         return EMaxSubscriptions;

   548         }

   549     else if ( KParamValueMaxContacts() == name )

   550         {

   551         return EMaxContacts;

   552         }

   553     else if ( KParamValueDomainSyntax() == name )

   554         {

   555         return EDomainSyntax;

   556         }

   557     // ==============================

   558     // NAT/Firewall parameters.

   559     // ==============================

   560     //

   561     else if ( KParamValueTcpRefreshInterval() == name )

   562         {

   563         return ETcpRefreshInterval;

   564         }

   565     else if ( KParamValueUdpRefreshInterval() == name )

   566         {

   567         return EUdpRefreshInterval;

   568         }

   569     else if ( KParamValueCrlfRefresh() == name )

   570         {

   571         return ECrlfRefresh;

   572         }

   573     else if ( KParamValueStunSharedSecret() == name )

   574         {

   575         return EStunSharedSecret;

   576         }

   577     // ==============================

   578     // WLAN IAP parameters.

   579     // ==============================

   580     //

   581     else if ( KParamSsid() == name )

   582         {

   583         return ESsid;

   584         }

   585     else if ( KParamHidden() == name )

   586         {

   587         return EHidden;

   588         }

   589     else if ( KParamNetworkMode() == name )

   590         {

   591         return ENetworkMode;

   592         }

   593     else if ( KParamPreSharedKey() == name )

   594         {

   595         return EPreSharedKey;

   596         }

   597     else if ( KParamWepAuthMode() == name )

   598         {

   599         return EWepAuthMode;

   600         }

   601     else if ( KParamLength() == name )

   602         {

   603         return ELength;

   604         }

   605     else if ( KParamData() == name )

   606         {

   607         return EData;

   608         }

   609     // ==============================

   610     // Not supported.

   611     // ==============================

   612     //

   613     else

   614         {

   615         return EUnSupported;

   616         }

   617     }

   618 

   619 // End of file.