dbcreator/commsdatcreator/src/cdcreaderxml.cpp
author hgs
Thu, 16 Sep 2010 12:50:24 +0300
changeset 61 8b0c979bbe8c
parent 56 dd6aaa97e7b1
permissions -rw-r--r--
201037
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
56
hgs
parents:
diff changeset
     1
/*
hgs
parents:
diff changeset
     2
* Copyright (c) 2004-2010 Nokia Corporation and/or its subsidiary(-ies). 
hgs
parents:
diff changeset
     3
* All rights reserved.
hgs
parents:
diff changeset
     4
* This component and the accompanying materials are made available
hgs
parents:
diff changeset
     5
* under the terms of "Eclipse Public License v1.0"
hgs
parents:
diff changeset
     6
* which accompanies this distribution, and is available
hgs
parents:
diff changeset
     7
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
hgs
parents:
diff changeset
     8
*
hgs
parents:
diff changeset
     9
* Initial Contributors:
hgs
parents:
diff changeset
    10
* Nokia Corporation - initial contribution.
hgs
parents:
diff changeset
    11
*
hgs
parents:
diff changeset
    12
* Contributors:
hgs
parents:
diff changeset
    13
*
hgs
parents:
diff changeset
    14
* Description:
hgs
parents:
diff changeset
    15
* Implementation of the class CReaderXML
hgs
parents:
diff changeset
    16
*/
hgs
parents:
diff changeset
    17
 
hgs
parents:
diff changeset
    18
// INCLUDE FILES
hgs
parents:
diff changeset
    19
hgs
parents:
diff changeset
    20
#include "cdcreaderxml.h"
hgs
parents:
diff changeset
    21
#include "cdclogger.h"
hgs
parents:
diff changeset
    22
hgs
parents:
diff changeset
    23
#include <utf.h>
hgs
parents:
diff changeset
    24
#include <cmpluginpacketdatadef.h>
hgs
parents:
diff changeset
    25
#include <cmplugindialcommondefs.h>
hgs
parents:
diff changeset
    26
#include <cmpluginlandef.h>
hgs
parents:
diff changeset
    27
#include <cmpluginwlandef.h>
hgs
parents:
diff changeset
    28
#include <cmpluginvpndef.h>
hgs
parents:
diff changeset
    29
#include <cmconnectionmethoddef.h>
hgs
parents:
diff changeset
    30
hgs
parents:
diff changeset
    31
using namespace CMManager;
hgs
parents:
diff changeset
    32
hgs
parents:
diff changeset
    33
//TYPE DECLARATION
hgs
parents:
diff changeset
    34
hgs
parents:
diff changeset
    35
//CONSTANTS
hgs
parents:
diff changeset
    36
//
hgs
parents:
diff changeset
    37
// Literals in XML header
hgs
parents:
diff changeset
    38
_LIT16( KXmlVersion,       "xml version" );
hgs
parents:
diff changeset
    39
_LIT16( KEncoding,         "encoding" );
hgs
parents:
diff changeset
    40
_LIT16( KEncodingUtf8,     "UTF-8" );
hgs
parents:
diff changeset
    41
hgs
parents:
diff changeset
    42
// File tail marker
hgs
parents:
diff changeset
    43
_LIT16( KFileTail,         "</Variant>");
hgs
parents:
diff changeset
    44
_LIT16( KFileTail2,         "</Data>");
hgs
parents:
diff changeset
    45
hgs
parents:
diff changeset
    46
// Feature head markers
hgs
parents:
diff changeset
    47
_LIT16( KFeatureHeadPacketData, "<APs>" );
hgs
parents:
diff changeset
    48
_LIT16( KFeatureHeadWLAN,       "<WLAN_APs>" );
hgs
parents:
diff changeset
    49
_LIT16( KFeatureHeadLAN,        "<LAN_APs>" );
hgs
parents:
diff changeset
    50
_LIT16( KFeatureHeadVPN,        "<VPN_APs>" );
hgs
parents:
diff changeset
    51
_LIT16( KFeatureHeadGlobal,     "<Global>" );
hgs
parents:
diff changeset
    52
_LIT16( KFeatureHeadDN,         "<DNs>" );
hgs
parents:
diff changeset
    53
hgs
parents:
diff changeset
    54
// Feature tail markers
hgs
parents:
diff changeset
    55
_LIT16( KFeatureTailPacketData, "</APs>" );
hgs
parents:
diff changeset
    56
_LIT16( KFeatureTailWLAN,       "</WLAN_APs>" );
hgs
parents:
diff changeset
    57
_LIT16( KFeatureTailLAN,        "</LAN_APs>" );
hgs
parents:
diff changeset
    58
_LIT16( KFeatureTailVPN,        "</VPN_APs>" );
hgs
parents:
diff changeset
    59
_LIT16( KFeatureTailGlobal,     "</Global>" );
hgs
parents:
diff changeset
    60
_LIT16( KFeatureTailDN,         "</DNs>" );
hgs
parents:
diff changeset
    61
hgs
parents:
diff changeset
    62
// Feature data head markers
hgs
parents:
diff changeset
    63
_LIT16( KDataHeadPacketData, "<AP>" );
hgs
parents:
diff changeset
    64
_LIT16( KDataHeadWLAN,       "<WLAN_AP>" );
hgs
parents:
diff changeset
    65
_LIT16( KDataHeadLAN,        "<LAN_AP>" );
hgs
parents:
diff changeset
    66
_LIT16( KDataHeadVPN,        "<VPN_AP>" );
hgs
parents:
diff changeset
    67
_LIT16( KDataHeadDN,         "<DN>" );
hgs
parents:
diff changeset
    68
hgs
parents:
diff changeset
    69
// Feature data tail markers
hgs
parents:
diff changeset
    70
_LIT16( KDataTailPacketData, "</AP>" );
hgs
parents:
diff changeset
    71
_LIT16( KDataTailWLAN,       "</WLAN_AP>" );
hgs
parents:
diff changeset
    72
_LIT16( KDataTailLAN,        "</LAN_AP>" );
hgs
parents:
diff changeset
    73
_LIT16( KDataTailVPN,        "</VPN_AP>" );
hgs
parents:
diff changeset
    74
_LIT16( KDataTailDN,         "</DN>" );
hgs
parents:
diff changeset
    75
hgs
parents:
diff changeset
    76
// Parameter Markers
hgs
parents:
diff changeset
    77
// <ParamName>ParamValue</ParamName>
hgs
parents:
diff changeset
    78
_LIT16( KParamValueHead,        ">" );
hgs
parents:
diff changeset
    79
_LIT16( KParamValueTail,        "</" );
hgs
parents:
diff changeset
    80
_LIT16( KParamNameHead,         "<" );
hgs
parents:
diff changeset
    81
_LIT16( KParamNameTail,         ">" );
hgs
parents:
diff changeset
    82
hgs
parents:
diff changeset
    83
hgs
parents:
diff changeset
    84
//maximum line size
hgs
parents:
diff changeset
    85
const TInt16 KMaxLineSize   = 1024;
hgs
parents:
diff changeset
    86
//maximum item (tag) size
hgs
parents:
diff changeset
    87
const TInt16 KMaxItemLength = 100;
hgs
parents:
diff changeset
    88
hgs
parents:
diff changeset
    89
// ratio between ascii and unicode character sizes
hgs
parents:
diff changeset
    90
const TUint KAsciiUnicodeRatio = 2;
hgs
parents:
diff changeset
    91
hgs
parents:
diff changeset
    92
//  Following table contains the input parameter names:
hgs
parents:
diff changeset
    93
//
hgs
parents:
diff changeset
    94
//    Name                Type    Description
hgs
parents:
diff changeset
    95
//----------------------------------------------------------------------------
hgs
parents:
diff changeset
    96
//General & Gprs specific:
hgs
parents:
diff changeset
    97
//========================
hgs
parents:
diff changeset
    98
//KConnectionName         string    The name of the access point.
hgs
parents:
diff changeset
    99
//KProtected              string    Protection
hgs
parents:
diff changeset
   100
//KHidden                 string    CM/DN is hidden
hgs
parents:
diff changeset
   101
//KHiddenAgent            string    CM/DN is not shown in CConnDlg
hgs
parents:
diff changeset
   102
//KHighlighted            string    CM/DN is highlighted in CConnDlg
hgs
parents:
diff changeset
   103
//KSeamlessness           string    Seamlessness value
hgs
parents:
diff changeset
   104
//KGprs_AP_Name           string    Access point name.
hgs
parents:
diff changeset
   105
//KUserName               string    Login user name
hgs
parents:
diff changeset
   106
//KPromptPassword         string    Prompts the user for username and 
hgs
parents:
diff changeset
   107
//                                  password
hgs
parents:
diff changeset
   108
//KPassword               string    Login password.
hgs
parents:
diff changeset
   109
//KPasswordAuthType       string    Disables plain text authentication.
hgs
parents:
diff changeset
   110
//KWAPGatewayIP           string    WAP gateway address (IP address).
hgs
parents:
diff changeset
   111
//KStartingPage           string    WAP start page URL.
hgs
parents:
diff changeset
   112
//KWTLS_Security          string    Attempts a secure WTLS connection 
hgs
parents:
diff changeset
   113
//                                  to the gateway.
hgs
parents:
diff changeset
   114
//KWAP_ConnectionType     string    Indicates whether a connection-
hgs
parents:
diff changeset
   115
//                                  oriented or connectionless API 
hgs
parents:
diff changeset
   116
//                                  should be used.
hgs
parents:
diff changeset
   117
//KPhoneIP                string    IP address of the interface.
hgs
parents:
diff changeset
   118
//KPrimaryNameServer      string    IP address of the primary name 
hgs
parents:
diff changeset
   119
//                                  server.
hgs
parents:
diff changeset
   120
//KSecondaryNameServer    string    IP address of the secondary name
hgs
parents:
diff changeset
   121
//                                  server.
hgs
parents:
diff changeset
   122
//KProxyServerAddress     string    Proxy server address.
hgs
parents:
diff changeset
   123
//KProxyPortNumber        string    Proxy port number.
hgs
parents:
diff changeset
   124
//KProxyProtocolName      string    Proxy protocol name.
hgs
parents:
diff changeset
   125
//KPrimaryIP6NameServer   string    IP address of the primary IPv6 
hgs
parents:
diff changeset
   126
//                                  name server.
hgs
parents:
diff changeset
   127
//KSecondaryIP6NameServer string    IP address of the secondary IPv6 
hgs
parents:
diff changeset
   128
//                                  name server.
hgs
parents:
diff changeset
   129
//KNetworkType            string    Network type: IPv4 or IPv6
hgs
parents:
diff changeset
   130
//KGprsUseEdge            string    Sets the GprsUseEdge parameter
hgs
parents:
diff changeset
   131
//=============
hgs
parents:
diff changeset
   132
//LAN specific:
hgs
parents:
diff changeset
   133
//=============
hgs
parents:
diff changeset
   134
//KLanIfNetworks          string    Network protcols
hgs
parents:
diff changeset
   135
//KLanIpNetMask           string    IP net mask of interface
hgs
parents:
diff changeset
   136
//KLanIpGateway           string    IP address of gateway
hgs
parents:
diff changeset
   137
//==============
hgs
parents:
diff changeset
   138
//WLAN specific:
hgs
parents:
diff changeset
   139
//==============
hgs
parents:
diff changeset
   140
//KNetworkName            string    The name of the WLAN network 
hgs
parents:
diff changeset
   141
//KNetworkMode            string    The WLAN network mode 
hgs
parents:
diff changeset
   142
//KSecurityMode           string    The security mode of the WLAN network
hgs
parents:
diff changeset
   143
//KWlanIpGatewayAddress   string    IP address of gateway 
hgs
parents:
diff changeset
   144
//KWlanIpNetMask          string    IP net mask of interface 
hgs
parents:
diff changeset
   145
//KWlanChannelId          integer   802.11 Channel ID (1-14) 
hgs
parents:
diff changeset
   146
hgs
parents:
diff changeset
   147
//---------------
hgs
parents:
diff changeset
   148
//WEP security 
hgs
parents:
diff changeset
   149
//---------------
hgs
parents:
diff changeset
   150
//WEPKeyInUse             integer   Index of the default WEP key
hgs
parents:
diff changeset
   151
//WEPAuthType             string    WEP authentication mode. 
hgs
parents:
diff changeset
   152
//WEPKey1Length           string    Key length of WEP key1. 64, 128, 256 bit.
hgs
parents:
diff changeset
   153
//WEPKey1Format           string    Format of WEP key 1. ASCII or Hexadecimal
hgs
parents:
diff changeset
   154
//WEPKey1Data             string    Data  of WEP key1
hgs
parents:
diff changeset
   155
//WEPKey2Length           string    Key length of WEP key2. 64, 128, 256 bit.
hgs
parents:
diff changeset
   156
//WEPKey2Format           string    Format of WEP key 2. ASCII or Hexadecimal
hgs
parents:
diff changeset
   157
//WEPKey2Data             string    Data  of WEP key2
hgs
parents:
diff changeset
   158
//WEPKey3Length           string    Key length of WEP key3. 64, 128, 256 bit.
hgs
parents:
diff changeset
   159
//WEPKey3Format           string    Format of WEP key 3. ASCII or Hexadecimal
hgs
parents:
diff changeset
   160
//WEPKey3Data             string    Data  of WEP key3
hgs
parents:
diff changeset
   161
//WEPKey4Length           string    Key length of WEP key4. 64, 128, 256 bit.
hgs
parents:
diff changeset
   162
//WEPKey4Format           string    Format of WEP key 4. ASCII or Hexadecimal
hgs
parents:
diff changeset
   163
//WEPKey4Data             string    Data  of WEP key4
hgs
parents:
diff changeset
   164
//---------------
hgs
parents:
diff changeset
   165
//WPA security
hgs
parents:
diff changeset
   166
//---------------
hgs
parents:
diff changeset
   167
//WPAPresharedKey         string    WPA/WPA2 pre-shared key in plain text. 
hgs
parents:
diff changeset
   168
//WPAKeyLength            integer   The length of the WPA/WPA2 pre-shared key.
hgs
parents:
diff changeset
   169
//WPAEapMethod            string    A EAP method in use
hgs
parents:
diff changeset
   170
//WPAUseOfPresharedKey    string    WPA/WPA2 pre-shared key usage.
hgs
parents:
diff changeset
   171
//=============
hgs
parents:
diff changeset
   172
//VPN specific:
hgs
parents:
diff changeset
   173
//=============
hgs
parents:
diff changeset
   174
//KVpnIapName             string    IAP name used for the connection
hgs
parents:
diff changeset
   175
//KVpnServicePolicy       string    Service policy ID
hgs
parents:
diff changeset
   176
//====================
hgs
parents:
diff changeset
   177
//Destination Networks
hgs
parents:
diff changeset
   178
//====================
hgs
parents:
diff changeset
   179
//KDN_Name                string    The name of the Destination Network
hgs
parents:
diff changeset
   180
//KDN_Icon                integer   Index of icon assigned to the DN
hgs
parents:
diff changeset
   181
//KDN_Metadata            string    Destination type
hgs
parents:
diff changeset
   182
//KDN_Protection          integer   Protection level of the DN
hgs
parents:
diff changeset
   183
//KDN_Hidden              integer   Shows whether DN is hidden or not
hgs
parents:
diff changeset
   184
//KDN_IAPName             string    Name of a Connection Method that is
hgs
parents:
diff changeset
   185
//                                  bound to the DN
hgs
parents:
diff changeset
   186
//KDN_IAPName2..10        string    Same as above
hgs
parents:
diff changeset
   187
//KDN_EmbeddedDN          string    Name of an Embedded DN that is bound
hgs
parents:
diff changeset
   188
//                                  to the DN
hgs
parents:
diff changeset
   189
//===============
hgs
parents:
diff changeset
   190
//Global settings
hgs
parents:
diff changeset
   191
//===============
hgs
parents:
diff changeset
   192
//KAttachMode             string    Gprs attach mode
hgs
parents:
diff changeset
   193
//KDefaultAP              string    Default Gprs access point
hgs
parents:
diff changeset
   194
//KTableProtection        string    Table level protection
hgs
parents:
diff changeset
   195
//KDefaultDnIcon          integer   Default icon for DNs
hgs
parents:
diff changeset
   196
//KPriorityLan            integer   Default priority for Lan bearer type
hgs
parents:
diff changeset
   197
//KPriorityWlan           integer   Default priority for WLan bearer type
hgs
parents:
diff changeset
   198
//KPriorityPan            integer   Default priority for Pan bearer type
hgs
parents:
diff changeset
   199
//KPriorityGprsOut        integer   Default priority for outgoing Gprs
hgs
parents:
diff changeset
   200
//                                  bearer type
hgs
parents:
diff changeset
   201
//KPriorityGprsIn         integer   Default priority for incoming Gprs
hgs
parents:
diff changeset
   202
//                                  bearer type
hgs
parents:
diff changeset
   203
//KPriorityCdma2k         integer   Default priority for CDMA2000 bearer type
hgs
parents:
diff changeset
   204
//KPriorityDialOut        integer   Default priority for incoming dial
hgs
parents:
diff changeset
   205
//                                  bearer type
hgs
parents:
diff changeset
   206
//KPriorityDialIn         integer   Default priority for outgoing dial
hgs
parents:
diff changeset
   207
//                                  bearer type
hgs
parents:
diff changeset
   208
//KPriorityVpn            integer   Default priority for Vpn bearer type
hgs
parents:
diff changeset
   209
//KPriorityMip            integer   Default priority for Mip bearer type
hgs
parents:
diff changeset
   210
//KUIPriorityLan          integer   Default UI priority for Lan bearer type
hgs
parents:
diff changeset
   211
//KUIPriorityWlan         integer   Default UI priority for WLan bearer type
hgs
parents:
diff changeset
   212
//KUIPriorityPan          integer   Default UI priority for Pan bearer type
hgs
parents:
diff changeset
   213
//KUIPriorityGprsOut      integer   Default UI priority for outgoing Gprs
hgs
parents:
diff changeset
   214
//                                  bearer type
hgs
parents:
diff changeset
   215
//KUIPriorityGprsIn       integer   Default UI priority for incoming Gprs
hgs
parents:
diff changeset
   216
//                                  bearer type
hgs
parents:
diff changeset
   217
//KUIPriorityCdma2k       integer   Default UI priority for CDMA2000
hgs
parents:
diff changeset
   218
//                                  bearer type
hgs
parents:
diff changeset
   219
//KUIPriorityDialOut      integer   Default UI priority for incoming dial
hgs
parents:
diff changeset
   220
//                                  bearer type
hgs
parents:
diff changeset
   221
//KUIPriorityDialIn       integer   Default UI priority for outgoing dial
hgs
parents:
diff changeset
   222
//                                  bearer type
hgs
parents:
diff changeset
   223
//KUIPriorityVpn          integer   Default UI priority for Vpn bearer type
hgs
parents:
diff changeset
   224
//KUIPriorityMip          integer   Default UI priority for Mip bearer type
hgs
parents:
diff changeset
   225
hgs
parents:
diff changeset
   226
//KDefaultConnectionType  integer   Default connection method type
hgs
parents:
diff changeset
   227
//KDefaultConnectionName  string    Default connection method name
hgs
parents:
diff changeset
   228
hgs
parents:
diff changeset
   229
//KUsageOfWlan            integer   Usage of known WLAN networks, automatical or manual
hgs
parents:
diff changeset
   230
//KSeamlessnessHome       integer   Cellular data usage in home network
hgs
parents:
diff changeset
   231
//KSeamlessnessVisitor    integer   Cellular data usage in foreign networks
hgs
parents:
diff changeset
   232
hgs
parents:
diff changeset
   233
hgs
parents:
diff changeset
   234
//KGprsLastSocketActivityTimeout    integer
hgs
parents:
diff changeset
   235
//KGprsLastSessionClosedTimeout     integer The time how long Gprs PDP context stays active 
hgs
parents:
diff changeset
   236
//                                          after the last application using the connection was closed.
hgs
parents:
diff changeset
   237
//KGprsLastSocketClosedTimeout      integer
hgs
parents:
diff changeset
   238
//KCsdLastSocketActivityTimeout     integer
hgs
parents:
diff changeset
   239
//KCsdLastSessionClosedTimeout      integer
hgs
parents:
diff changeset
   240
//KCsdLastSocketClosedTimeout       integer
hgs
parents:
diff changeset
   241
//KWlanLastSocketActivityTimeout    integer
hgs
parents:
diff changeset
   242
//KWlanLastSessionClosedTimeout     integer
hgs
parents:
diff changeset
   243
//KWlanLastSocketClosedTimeout      integer
hgs
parents:
diff changeset
   244
//KWlanBGScanInterval               integer
hgs
parents:
diff changeset
   245
//KWlanUseDefSettings               integer
hgs
parents:
diff changeset
   246
//KWlanLongRetry                    integer
hgs
parents:
diff changeset
   247
//KWlanShortRetry                   integer
hgs
parents:
diff changeset
   248
//KWlanRTS                          integer
hgs
parents:
diff changeset
   249
//KWlanTxPowerLevel                 integer
hgs
parents:
diff changeset
   250
//KWlanRadioMeasurements            integer
hgs
parents:
diff changeset
   251
//KWlanPowerMode                    integer Whether WLAN power save is on or off
hgs
parents:
diff changeset
   252
hgs
parents:
diff changeset
   253
hgs
parents:
diff changeset
   254
//String literals defined for input parameters
hgs
parents:
diff changeset
   255
hgs
parents:
diff changeset
   256
//General & Gprs specific
hgs
parents:
diff changeset
   257
_LIT16( KConnectionName,            "ConnectionName" );
hgs
parents:
diff changeset
   258
_LIT16( KConnectionId,              "ConnectionId" );
hgs
parents:
diff changeset
   259
_LIT16( KProtected,                 "Protected" );
hgs
parents:
diff changeset
   260
_LIT16( KHidden,                    "Hidden" );
hgs
parents:
diff changeset
   261
_LIT16( KHiddenAgent,               "HiddenAgent" );
hgs
parents:
diff changeset
   262
_LIT16( KHighlighted,               "Highlighted" );
hgs
parents:
diff changeset
   263
_LIT16( KSeamlessness,              "Seamlessness" );
hgs
parents:
diff changeset
   264
_LIT16( KGprs_AP_Name,              "Gprs_AP_Name" );
hgs
parents:
diff changeset
   265
_LIT16( KUserName,                  "UserName" );
hgs
parents:
diff changeset
   266
_LIT16( KPromptPassword,            "PromptPassword" );
hgs
parents:
diff changeset
   267
_LIT16( KPassword,                  "Password" );
hgs
parents:
diff changeset
   268
_LIT16( KPasswordAuthType,          "PasswordAuthenticationType" );
hgs
parents:
diff changeset
   269
_LIT16( KWAPGatewayIP,              "WAPGatewayIP" );
hgs
parents:
diff changeset
   270
_LIT16( KStartingPage,              "StartingPage" );
hgs
parents:
diff changeset
   271
_LIT16( KWTLS_Security,             "WTLS_Security" );
hgs
parents:
diff changeset
   272
_LIT16( KWAP_ConnectionType,        "WAP_ConnectionType" );
hgs
parents:
diff changeset
   273
_LIT16( KPhoneIP,                   "PhoneIP" );
hgs
parents:
diff changeset
   274
_LIT16( KPrimaryNameServer,         "PrimaryNameServer" );
hgs
parents:
diff changeset
   275
_LIT16( KSecondaryNameServer,       "SecondaryNameServer" );
hgs
parents:
diff changeset
   276
_LIT16( KProxyServerAddress,        "ProxyServerAddress" );
hgs
parents:
diff changeset
   277
_LIT16( KProxyPortNumber,           "ProxyPortNumber" );
hgs
parents:
diff changeset
   278
_LIT16( KProxyProtocolName,         "ProxyProtocolName");
hgs
parents:
diff changeset
   279
_LIT16( KPrimaryIP6NameServer,      "PrimaryIP6NameServer" );
hgs
parents:
diff changeset
   280
_LIT16( KSecondaryIP6NameServer,    "SecondaryIP6NameServer" );
hgs
parents:
diff changeset
   281
_LIT16( KNetworkType,               "NetworkType");
hgs
parents:
diff changeset
   282
_LIT16( KIspType,                   "IspType" );
hgs
parents:
diff changeset
   283
_LIT16( KGprsUseEdge,               "GprsUseEdge");
hgs
parents:
diff changeset
   284
_LIT16( KLinger,                    "Linger");
hgs
parents:
diff changeset
   285
hgs
parents:
diff changeset
   286
//Lan specific
hgs
parents:
diff changeset
   287
_LIT16( KLanIfNetworks,             "LanIfNetworks" );
hgs
parents:
diff changeset
   288
_LIT16( KLanIpNetMask,              "LanIpNetMask" );
hgs
parents:
diff changeset
   289
_LIT16( KLanIpGateway,              "LanIpGateway" );
hgs
parents:
diff changeset
   290
_LIT16( KLanIpAddrFromServer,       "IpAddrFromServer" );
hgs
parents:
diff changeset
   291
_LIT16( KLanIpDNSAddrFromServer,    "IpDNSAddrFromServer" ); 
hgs
parents:
diff changeset
   292
_LIT16( KLanConfigDaemonManagerName,"ConfigDaemonManagerName" );
hgs
parents:
diff changeset
   293
_LIT16( KLanConfigDaemonName,       "ConfigDaemonName" );
hgs
parents:
diff changeset
   294
hgs
parents:
diff changeset
   295
//Wlan specific
hgs
parents:
diff changeset
   296
_LIT16( KNetworkName,               "NetworkName" );
hgs
parents:
diff changeset
   297
_LIT16( KNetworkMode,               "NetworkMode" );
hgs
parents:
diff changeset
   298
_LIT16( KSecurityMode,              "SecurityMode" );
hgs
parents:
diff changeset
   299
_LIT16( KWlanIpGatewayAddress,      "WlanIpGatewayAddress" );
hgs
parents:
diff changeset
   300
_LIT16( KWlanIpNetMask,             "WlanIpNetMask" );
hgs
parents:
diff changeset
   301
_LIT16( KWlanScanSSId,              "WlanScanSSId" );
hgs
parents:
diff changeset
   302
_LIT16( KWlanChannelId,             "WlanChannelId" );
hgs
parents:
diff changeset
   303
hgs
parents:
diff changeset
   304
//WEP security
hgs
parents:
diff changeset
   305
_LIT16( KWEPKeyInUse,               "WEPKeyInUse" );
hgs
parents:
diff changeset
   306
_LIT16( KWEPAuthType,               "WEPAuthType" );
hgs
parents:
diff changeset
   307
_LIT16( KWEPKey1Length,             "WEPKey1Length" );
hgs
parents:
diff changeset
   308
_LIT16( KWEPKey1Format,             "WEPKey1Format" );
hgs
parents:
diff changeset
   309
_LIT16( KWEPKey1Data,               "WEPKey1Data" );
hgs
parents:
diff changeset
   310
_LIT16( KWEPKey2Length,             "WEPKey2Length" );
hgs
parents:
diff changeset
   311
_LIT16( KWEPKey2Format,             "WEPKey2Format" );
hgs
parents:
diff changeset
   312
_LIT16( KWEPKey2Data,               "WEPKey2Data" );
hgs
parents:
diff changeset
   313
_LIT16( KWEPKey3Length,             "WEPKey3Length" );
hgs
parents:
diff changeset
   314
_LIT16( KWEPKey3Format,             "WEPKey3Format" );
hgs
parents:
diff changeset
   315
_LIT16( KWEPKey3Data,               "WEPKey3Data" );
hgs
parents:
diff changeset
   316
_LIT16( KWEPKey4Length,             "WEPKey4Length" );
hgs
parents:
diff changeset
   317
_LIT16( KWEPKey4Format,             "WEPKey4Format" );
hgs
parents:
diff changeset
   318
_LIT16( KWEPKey4Data,               "WEPKey4Data" );
hgs
parents:
diff changeset
   319
hgs
parents:
diff changeset
   320
//WPA security
hgs
parents:
diff changeset
   321
_LIT16( KWPAPresharedKey,           "WPAPresharedKey" );
hgs
parents:
diff changeset
   322
_LIT16( KWPAKeyLength,              "WPAKeyLength" );
hgs
parents:
diff changeset
   323
_LIT16( KWPAEapMethod,              "WPAEapMethod");
hgs
parents:
diff changeset
   324
_LIT16( KWPAUseOfPresharedKey,      "WPAUseOfPresharedKey" );
hgs
parents:
diff changeset
   325
hgs
parents:
diff changeset
   326
//EAP security
hgs
parents:
diff changeset
   327
_LIT16( KEapGtcUsername,            "EapGtcUsername" );
hgs
parents:
diff changeset
   328
_LIT16( KEapGtcSessionValidityTime, "EapGtcSessionValidityTime" );
hgs
parents:
diff changeset
   329
_LIT16( KEapGtcEncapsulation,       "EapGtcEncapsulation" );
hgs
parents:
diff changeset
   330
hgs
parents:
diff changeset
   331
hgs
parents:
diff changeset
   332
_LIT16( KEapTlsUsername,            "EapTlsUsername" );
hgs
parents:
diff changeset
   333
_LIT16( KEapTlsRealm,               "EapTlsRealm" );
hgs
parents:
diff changeset
   334
_LIT16( KEapTlsVerifyServerRealm,   "EapTlsVerifyServerRealm" );
hgs
parents:
diff changeset
   335
_LIT16( KEapTlsRequireClientAuth,   "EapTlsRequireClientAuth" );
hgs
parents:
diff changeset
   336
_LIT16( KEapTlsSessionValidityTime, "EapTlsSessionValidityTime" );
hgs
parents:
diff changeset
   337
_LIT16( KEapTlsCipherSuites,        "EapTlsCipherSuites" );
hgs
parents:
diff changeset
   338
_LIT16( KEapTlsUserCertSubjectKeyId,"EapTlsUserCertSubjectKeyId" );
hgs
parents:
diff changeset
   339
_LIT16( KEapTlsUserCertIssuerName,  "EapTlsUserCertIssuerName" );
hgs
parents:
diff changeset
   340
_LIT16( KEapTlsUserCertSerialNumber,"EapTlsUserCertSerialNumber" );
hgs
parents:
diff changeset
   341
_LIT16( KEapTlsCaCertSubjectKeyId,  "EapTlsCaCertSubjectKeyId" );
hgs
parents:
diff changeset
   342
_LIT16( KEapTlsCaCertIssuerName,    "EapTlsCaCertIssuerName" );
hgs
parents:
diff changeset
   343
_LIT16( KEapTlsCaCertSerialNumber,  "EapTlsCaCertSerialNumber" );
hgs
parents:
diff changeset
   344
_LIT16( KEapTlsEncapsulation,       "EapTlsEncapsulation" );
hgs
parents:
diff changeset
   345
hgs
parents:
diff changeset
   346
hgs
parents:
diff changeset
   347
_LIT16( KEapLeapUsername,           "EapLeapUsername" );
hgs
parents:
diff changeset
   348
_LIT16( KEapLeapPassword,           "EapLeapPassword" );
hgs
parents:
diff changeset
   349
_LIT16( KEapLeapSessionValidityTime,"EapLeapSessionValidityTime" );
hgs
parents:
diff changeset
   350
hgs
parents:
diff changeset
   351
hgs
parents:
diff changeset
   352
_LIT16( KEapSimUsername,            "EapSimUsername" );
hgs
parents:
diff changeset
   353
_LIT16( KEapSimRealm,               "EapSimRealm" );
hgs
parents:
diff changeset
   354
_LIT16( KEapSimUsePseudonyms,       "EapSimUsePseudonyms" );
hgs
parents:
diff changeset
   355
_LIT16( KEapSimSessionValidityTime, "EapSimSessionValidityTime" );
hgs
parents:
diff changeset
   356
_LIT16( KEapSimEncapsulation,       "EapSimEncapsulation" );
hgs
parents:
diff changeset
   357
hgs
parents:
diff changeset
   358
_LIT16( KEapTtlsUsername,           "EapTtlsUsername" );
hgs
parents:
diff changeset
   359
_LIT16( KEapTtlsRealm,              "EapTtlsRealm" );
hgs
parents:
diff changeset
   360
_LIT16( KEapTtlsVerifyServerRealm,  "EapTtlsVerifyServerRealm" );
hgs
parents:
diff changeset
   361
_LIT16( KEapTtlsRequireClientAuth,  "EapTtlsRequireClientAuth" );
hgs
parents:
diff changeset
   362
_LIT16( KEapTtlsSessionValidityTime,"EapTtlsSessionValidityTime" );
hgs
parents:
diff changeset
   363
_LIT16( KEapTtlsCipherSuites,       "EapTtlsCipherSuites" );
hgs
parents:
diff changeset
   364
_LIT16( KEapTtlsEncapsulatedTypes,  "EapTtlsEncapsulatedTypes" );
hgs
parents:
diff changeset
   365
_LIT16( KEapTtlsUserCertSubjectKeyId,"EapTtlsUserCertSubjectKeyId" );
hgs
parents:
diff changeset
   366
_LIT16( KEapTtlsUserCertIssuerName, "EapTtlsUserCertIssuerName" );
hgs
parents:
diff changeset
   367
_LIT16( KEapTtlsUserCertSerialNumber,"EapTtlsUserCertSerialNumber" );
hgs
parents:
diff changeset
   368
_LIT16( KEapTtlsCaCertSubjectKeyId, "EapTtlsCaCertSubjectKeyId" );
hgs
parents:
diff changeset
   369
_LIT16( KEapTtlsCaCertIssuerName,   "EapTtlsCaCertIssuerName" );
hgs
parents:
diff changeset
   370
_LIT16( KEapTtlsCaCertSerialNumber, "EapTtlsCaCertSerialNumber" );
hgs
parents:
diff changeset
   371
hgs
parents:
diff changeset
   372
_LIT16( KEapAkaUsername,            "EapAkaUsername" );
hgs
parents:
diff changeset
   373
_LIT16( KEapAkaRealm,               "EapAkaRealm" );
hgs
parents:
diff changeset
   374
_LIT16( KEapAkaUsePseudonyms,       "EapAkaUsePseudonyms" );
hgs
parents:
diff changeset
   375
_LIT16( KEapAkaSessionValidityTime, "EapAkaSessionValidityTime" );
hgs
parents:
diff changeset
   376
_LIT16( KEapAkaEncapsulation,       "EapAkaEncapsulation" );
hgs
parents:
diff changeset
   377
hgs
parents:
diff changeset
   378
_LIT16( KEapPeapUsername,           "EapPeapUsername" );
hgs
parents:
diff changeset
   379
_LIT16( KEapPeapRealm,              "EapPeapRealm" );
hgs
parents:
diff changeset
   380
_LIT16( KEapPeapVerifyServerRealm,  "EapPeapVerifyServerRealm" );
hgs
parents:
diff changeset
   381
_LIT16( KEapPeapRequireClientAuth,  "EapPeapRequireClientAuth" );
hgs
parents:
diff changeset
   382
_LIT16( KEapPeapSessionValidityTime,"EapPeapSessionValidityTime" );
hgs
parents:
diff changeset
   383
_LIT16( KEapPeapCipherSuites,       "EapPeapCipherSuites" );
hgs
parents:
diff changeset
   384
_LIT16( KEapPeapV0Allowed,          "EapPeapV0Allowed" );
hgs
parents:
diff changeset
   385
_LIT16( KEapPeapV1Allowed,          "EapPeapV1Allowed" );
hgs
parents:
diff changeset
   386
_LIT16( KEapPeapV2Allowed,          "EapPeapV2Allowed" );
hgs
parents:
diff changeset
   387
_LIT16( KEapPeapEncapsulatedTypes,  "EapPeapEncapsulatedTypes" );
hgs
parents:
diff changeset
   388
_LIT16( KEapPeapUserCertSubjectKeyId,"EapPeapUserCertSubjectKeyId" );
hgs
parents:
diff changeset
   389
_LIT16( KEapPeapUserCertIssuerName, "EapPeapUserCertIssuerName" );
hgs
parents:
diff changeset
   390
_LIT16( KEapPeapUserCertSerialNumber,"EapPeapUserCertSerialNumber" );
hgs
parents:
diff changeset
   391
_LIT16( KEapPeapCaCertSubjectKeyId, "EapPeapCaCertSubjectKeyId" );
hgs
parents:
diff changeset
   392
_LIT16( KEapPeapCaCertIssuerName,   "EapPeapCaCertIssuerName" );
hgs
parents:
diff changeset
   393
_LIT16( KEapPeapCaCertSerialNumber, "EapPeapCaCertSerialNumber" );
hgs
parents:
diff changeset
   394
hgs
parents:
diff changeset
   395
_LIT16( KEapMschapv2Username,       "EapMschapv2Username" );
hgs
parents:
diff changeset
   396
_LIT16( KEapMschapv2Password,       "EapMschapv2Password" );
hgs
parents:
diff changeset
   397
_LIT16( KEapMschapv2SessionValidityTime,"EapMschapv2SessionValidityTime" );
hgs
parents:
diff changeset
   398
_LIT16( KEapMschapv2Encapsulation,  "EapMschapv2Encapsulation" );
hgs
parents:
diff changeset
   399
hgs
parents:
diff changeset
   400
_LIT16( KEapFastUsername,           "EapFastUsername" );
hgs
parents:
diff changeset
   401
_LIT16( KEapFastRealm,              "EapFastRealm" );
hgs
parents:
diff changeset
   402
_LIT16( KEapFastVerifyServerRealm,  "EapFastVerifyServerRealm" );
hgs
parents:
diff changeset
   403
_LIT16( KEapFastRequireClientAuth,  "EapFastRequireClientAuth" );
hgs
parents:
diff changeset
   404
_LIT16( KEapFastSessionValidityTime,"EapFastSessionValidityTime" );
hgs
parents:
diff changeset
   405
_LIT16( KEapFastCipherSuites,       "EapFastCipherSuites" );
hgs
parents:
diff changeset
   406
_LIT16( KEapFastEncapsulatedTypes,  "EapFastEncapsulatedTypes" );
hgs
parents:
diff changeset
   407
_LIT16( KEapFastAuthProvModeAllowed,"EapFastAuthProvModeAllowed" );
hgs
parents:
diff changeset
   408
_LIT16( KEapFastUnauthProvModeAllowed,"EapFastUnauthProvModeAllowed" );
hgs
parents:
diff changeset
   409
_LIT16( KEapFastWarnADHPNoPAC,      "EapFastWarnADHPNoPAC" );
hgs
parents:
diff changeset
   410
_LIT16( KEapFastWarnADHPNoMatchingPAC,"EapFastWarnADHPNoMatchingPAC" );
hgs
parents:
diff changeset
   411
_LIT16( KEapFastWarnNotDefaultServer,"EapFastWarnNotDefaultServer" );
hgs
parents:
diff changeset
   412
_LIT16( KEapFastUserCertSubjectKeyId,"EapFastUserCertSubjectKeyId" );
hgs
parents:
diff changeset
   413
_LIT16( KEapFastUserCertIssuerName, "EapFastUserCertIssuerName" );
hgs
parents:
diff changeset
   414
_LIT16( KEapFastUserCertSerialNumber,"EapFastUserCertSerialNumber" );
hgs
parents:
diff changeset
   415
_LIT16( KEapFastCaCertSubjectKeyId, "EapFastCaCertSubjectKeyId" );
hgs
parents:
diff changeset
   416
_LIT16( KEapFastCaCertIssuerName,   "EapFastCaCertIssuerName" );
hgs
parents:
diff changeset
   417
_LIT16( KEapFastCaCertSerialNumber, "EapFastCaCertSerialNumber" );
hgs
parents:
diff changeset
   418
hgs
parents:
diff changeset
   419
_LIT16( KMschapv2Username,          "Mschapv2Username" );
hgs
parents:
diff changeset
   420
_LIT16( KMschapv2Password,          "Mschapv2Password" );
hgs
parents:
diff changeset
   421
_LIT16( KMschapv2SessionValidityTime,"Mschapv2SessionValidityTime" );
hgs
parents:
diff changeset
   422
_LIT16( KMschapv2Encapsulation,     "Mschapv2Encapsulation" );
hgs
parents:
diff changeset
   423
hgs
parents:
diff changeset
   424
hgs
parents:
diff changeset
   425
//VPN specific
hgs
parents:
diff changeset
   426
_LIT16( KVpnIapName,                "IAP_Name" );
hgs
parents:
diff changeset
   427
_LIT16( KVpnServicePolicy,          "Policy_ID" );
hgs
parents:
diff changeset
   428
hgs
parents:
diff changeset
   429
//DN specific
hgs
parents:
diff changeset
   430
_LIT16( KDN_Name,                   "Name" );
hgs
parents:
diff changeset
   431
_LIT16( KDN_Id,                     "DNId" );
hgs
parents:
diff changeset
   432
_LIT16( KDN_Icon,                   "Icon" );
hgs
parents:
diff changeset
   433
_LIT16( KDN_Metadata,               "Metadata" );
hgs
parents:
diff changeset
   434
_LIT16( KDN_Protection,             "Protection" );
hgs
parents:
diff changeset
   435
_LIT16( KDN_EmbeddedDNName,         "EmbeddedDN" );
hgs
parents:
diff changeset
   436
_LIT16( KDN_IAPName,                "IAP" );
hgs
parents:
diff changeset
   437
hgs
parents:
diff changeset
   438
// Needed because of Customization Tool limitations
hgs
parents:
diff changeset
   439
_LIT16( KDN_IAPName2,               "IAP2" );
hgs
parents:
diff changeset
   440
_LIT16( KDN_IAPName3,               "IAP3" );
hgs
parents:
diff changeset
   441
_LIT16( KDN_IAPName4,               "IAP4" );
hgs
parents:
diff changeset
   442
_LIT16( KDN_IAPName5,               "IAP5" );
hgs
parents:
diff changeset
   443
_LIT16( KDN_IAPName6,               "IAP6" );
hgs
parents:
diff changeset
   444
_LIT16( KDN_IAPName7,               "IAP7" );
hgs
parents:
diff changeset
   445
_LIT16( KDN_IAPName8,               "IAP8" );
hgs
parents:
diff changeset
   446
_LIT16( KDN_IAPName9,               "IAP9" );
hgs
parents:
diff changeset
   447
_LIT16( KDN_IAPName10,              "IAP10" );
hgs
parents:
diff changeset
   448
hgs
parents:
diff changeset
   449
//Global settings
hgs
parents:
diff changeset
   450
_LIT16( KAttachMode,                "Attachmode" );
hgs
parents:
diff changeset
   451
_LIT16( KDefaultAP,                 "DefaultAP" );
hgs
parents:
diff changeset
   452
_LIT16( KDefaultDnIcon,             "DefaultDnIcon" );
hgs
parents:
diff changeset
   453
_LIT16( KPriorityLan,               "PriorityLan" );
hgs
parents:
diff changeset
   454
_LIT16( KPriorityWlan,              "PriorityWlan" );
hgs
parents:
diff changeset
   455
_LIT16( KPriorityPan,               "PriorityPan" );
hgs
parents:
diff changeset
   456
_LIT16( KPriorityGprsOut,           "PriorityGprsOut" );
hgs
parents:
diff changeset
   457
_LIT16( KPriorityGprsIn,            "PriorityGprsIn" );
hgs
parents:
diff changeset
   458
_LIT16( KPriorityCdma2k,            "PriorityCdma2k" );
hgs
parents:
diff changeset
   459
_LIT16( KPriorityDialOut,           "PriorityDialOut" );
hgs
parents:
diff changeset
   460
_LIT16( KPriorityDialIn,            "PriorityDialIn" );
hgs
parents:
diff changeset
   461
_LIT16( KPriorityVpn,               "PriorityVpn" );
hgs
parents:
diff changeset
   462
_LIT16( KPriorityMip,               "PriorityMip" );
hgs
parents:
diff changeset
   463
_LIT16( KUIPriorityLan,             "UIPriorityLan" );
hgs
parents:
diff changeset
   464
_LIT16( KUIPriorityWlan,            "UIPriorityWlan" );
hgs
parents:
diff changeset
   465
_LIT16( KUIPriorityPan,             "UIPriorityPan" );
hgs
parents:
diff changeset
   466
_LIT16( KUIPriorityGprsOut,         "UIPriorityGprsOut" );
hgs
parents:
diff changeset
   467
_LIT16( KUIPriorityGprsIn,          "UIPriorityGprsIn" );
hgs
parents:
diff changeset
   468
_LIT16( KUIPriorityCdma2k,          "UIPriorityCdma2k" );
hgs
parents:
diff changeset
   469
_LIT16( KUIPriorityDialOut,         "UIPriorityDialOut" );
hgs
parents:
diff changeset
   470
_LIT16( KUIPriorityDialIn,          "UIPriorityDialIn" );
hgs
parents:
diff changeset
   471
_LIT16( KUIPriorityVpn,             "UIPriorityVpn" );
hgs
parents:
diff changeset
   472
_LIT16( KUIPriorityMip,             "UIPriorityMip" );
hgs
parents:
diff changeset
   473
_LIT16( KUsageOfWlan,               "UsageOfWlan" );
hgs
parents:
diff changeset
   474
_LIT16( KCellularDataUsageHome,     "CellularDataUsageHome" );
hgs
parents:
diff changeset
   475
_LIT16( KCellularDataUsageVisitor,  "CellularDataUsageVisitor" );
hgs
parents:
diff changeset
   476
_LIT16( KGprsLastSocketActivityTimeout, "GprsLastSocketActivityTimeout" );
hgs
parents:
diff changeset
   477
_LIT16( KGprsLastSessionClosedTimeout,  "GprsLastSessionClosedTimeout" );
hgs
parents:
diff changeset
   478
_LIT16( KGprsLastSocketClosedTimeout,   "GprsLastSocketClosedTimeout" );
hgs
parents:
diff changeset
   479
_LIT16( KWlanLastSocketActivityTimeout, "WlanLastSocketActivityTimeout" );
hgs
parents:
diff changeset
   480
_LIT16( KWlanLastSessionClosedTimeout,  "WlanLastSessionClosedTimeout" );
hgs
parents:
diff changeset
   481
_LIT16( KWlanLastSocketClosedTimeout,   "WlanLastSocketClosedTimeout" );
hgs
parents:
diff changeset
   482
_LIT16( KWlanBGScanInterval,        "WlanBGScanInterval" );
hgs
parents:
diff changeset
   483
_LIT16( KWlanUseDefSettings,        "WlanUseDefSettings" );
hgs
parents:
diff changeset
   484
_LIT16( KWlanLongRetry,             "WlanLongRetry" );
hgs
parents:
diff changeset
   485
_LIT16( KWlanShortRetry,            "WlanShortRetry" );
hgs
parents:
diff changeset
   486
_LIT16( KWlanRTS,                   "WlanRTS" );
hgs
parents:
diff changeset
   487
_LIT16( KWlanTxPowerLevel,          "WlanTxPowerLevel" );
hgs
parents:
diff changeset
   488
_LIT16( KWlanRadioMeasurements,     "WlanRadioMeasurements" );
hgs
parents:
diff changeset
   489
_LIT16( KWlanPowerMode,             "WlanPowerMode" );
hgs
parents:
diff changeset
   490
hgs
parents:
diff changeset
   491
hgs
parents:
diff changeset
   492
// ================= MEMBER FUNCTIONS =======================
hgs
parents:
diff changeset
   493
hgs
parents:
diff changeset
   494
// ---------------------------------------------------------
hgs
parents:
diff changeset
   495
// CReaderXML::NewL
hgs
parents:
diff changeset
   496
// ---------------------------------------------------------
hgs
parents:
diff changeset
   497
//
hgs
parents:
diff changeset
   498
CReaderXML* CReaderXML::NewLC( const TDesC& aInFileName,
hgs
parents:
diff changeset
   499
                               const TDbCreatorInputCharSet aCharSet )
hgs
parents:
diff changeset
   500
    {
hgs
parents:
diff changeset
   501
    CReaderXML* self = new ( ELeave ) CReaderXML( aCharSet );
hgs
parents:
diff changeset
   502
hgs
parents:
diff changeset
   503
    CleanupStack::PushL( self );
hgs
parents:
diff changeset
   504
hgs
parents:
diff changeset
   505
    self->CReaderBase::ConstructL( aInFileName );
hgs
parents:
diff changeset
   506
    self->ConstructL();
hgs
parents:
diff changeset
   507
hgs
parents:
diff changeset
   508
    return self;
hgs
parents:
diff changeset
   509
    }
hgs
parents:
diff changeset
   510
hgs
parents:
diff changeset
   511
hgs
parents:
diff changeset
   512
// ---------------------------------------------------------
hgs
parents:
diff changeset
   513
// CReaderXML::ConstructL
hgs
parents:
diff changeset
   514
// ---------------------------------------------------------
hgs
parents:
diff changeset
   515
//
hgs
parents:
diff changeset
   516
void CReaderXML::ConstructL()
hgs
parents:
diff changeset
   517
    {
hgs
parents:
diff changeset
   518
    //if charset is not given as a parameter - detect it
hgs
parents:
diff changeset
   519
    if ( iCharSet == ECharSetUnknown )
hgs
parents:
diff changeset
   520
        {
hgs
parents:
diff changeset
   521
        DetectEncodingL();
hgs
parents:
diff changeset
   522
        }
hgs
parents:
diff changeset
   523
        
hgs
parents:
diff changeset
   524
    FillPacketDataParams();
hgs
parents:
diff changeset
   525
    FillLanParams();
hgs
parents:
diff changeset
   526
    FillWLanParams();
hgs
parents:
diff changeset
   527
    FillVpnParams();
hgs
parents:
diff changeset
   528
    FillGlobalParams();
hgs
parents:
diff changeset
   529
    FillDNParams();                
hgs
parents:
diff changeset
   530
    }
hgs
parents:
diff changeset
   531
hgs
parents:
diff changeset
   532
hgs
parents:
diff changeset
   533
// ---------------------------------------------------------
hgs
parents:
diff changeset
   534
// CReaderXML::CReaderXML
hgs
parents:
diff changeset
   535
// ---------------------------------------------------------
hgs
parents:
diff changeset
   536
//
hgs
parents:
diff changeset
   537
CReaderXML::CReaderXML( const TDbCreatorInputCharSet aCharSet ) :
hgs
parents:
diff changeset
   538
    CReaderBase( EFileXML, EFeatureNone ),
hgs
parents:
diff changeset
   539
    iCharSet( aCharSet ),
hgs
parents:
diff changeset
   540
    iLine ( NULL ),
hgs
parents:
diff changeset
   541
    iFoundGlobal( EFalse )
hgs
parents:
diff changeset
   542
    {
hgs
parents:
diff changeset
   543
    //no implementation required
hgs
parents:
diff changeset
   544
    }
hgs
parents:
diff changeset
   545
    
hgs
parents:
diff changeset
   546
    
hgs
parents:
diff changeset
   547
// ---------------------------------------------------------
hgs
parents:
diff changeset
   548
// CReaderXML::~CReaderXML
hgs
parents:
diff changeset
   549
// ---------------------------------------------------------
hgs
parents:
diff changeset
   550
//
hgs
parents:
diff changeset
   551
CReaderXML::~CReaderXML()
hgs
parents:
diff changeset
   552
    {
hgs
parents:
diff changeset
   553
    delete iLine;
hgs
parents:
diff changeset
   554
    
hgs
parents:
diff changeset
   555
    iPDParams.Close();
hgs
parents:
diff changeset
   556
    iLanParams.Close();
hgs
parents:
diff changeset
   557
    iWLanParams.Close();
hgs
parents:
diff changeset
   558
    iVpnParams.Close();
hgs
parents:
diff changeset
   559
    iGlobalParams.Close();
hgs
parents:
diff changeset
   560
    iDNParams.Close();
hgs
parents:
diff changeset
   561
    }
hgs
parents:
diff changeset
   562
hgs
parents:
diff changeset
   563
hgs
parents:
diff changeset
   564
// ---------------------------------------------------------
hgs
parents:
diff changeset
   565
// CReaderXML::LocateFeature
hgs
parents:
diff changeset
   566
// ---------------------------------------------------------
hgs
parents:
diff changeset
   567
//
hgs
parents:
diff changeset
   568
void CReaderXML::LocateFeatureL()
hgs
parents:
diff changeset
   569
    {
hgs
parents:
diff changeset
   570
    iCurrentFeature = EFeatureNone;
hgs
parents:
diff changeset
   571
    TInt result( KErrNone );
hgs
parents:
diff changeset
   572
    TBool eof( EFalse );
hgs
parents:
diff changeset
   573
    
hgs
parents:
diff changeset
   574
    //looks for the next feature
hgs
parents:
diff changeset
   575
    while ( !eof && CurrentFeature() == EFeatureNone )
hgs
parents:
diff changeset
   576
        {
hgs
parents:
diff changeset
   577
        //reads the next line
hgs
parents:
diff changeset
   578
        result = ReadLineL();
hgs
parents:
diff changeset
   579
        
hgs
parents:
diff changeset
   580
        if ( result == KErrEof )
hgs
parents:
diff changeset
   581
            {
hgs
parents:
diff changeset
   582
            //end of file
hgs
parents:
diff changeset
   583
            eof = ETrue;    
hgs
parents:
diff changeset
   584
            }
hgs
parents:
diff changeset
   585
        else if ( result )    
hgs
parents:
diff changeset
   586
            {
hgs
parents:
diff changeset
   587
            //other error
hgs
parents:
diff changeset
   588
            User::Leave( result );    
hgs
parents:
diff changeset
   589
            }
hgs
parents:
diff changeset
   590
        else
hgs
parents:
diff changeset
   591
            {
hgs
parents:
diff changeset
   592
            //no error
hgs
parents:
diff changeset
   593
            if ( iLine->FindF( KFileTail ) == KErrNone || 
hgs
parents:
diff changeset
   594
                 iLine->FindF( KFileTail2 ) == KErrNone )
hgs
parents:
diff changeset
   595
                {
hgs
parents:
diff changeset
   596
                //end of file is reached ("/variantvariant" found)
hgs
parents:
diff changeset
   597
                eof = ETrue;            
hgs
parents:
diff changeset
   598
                }
hgs
parents:
diff changeset
   599
            else
hgs
parents:
diff changeset
   600
                {
hgs
parents:
diff changeset
   601
                //try to recognize a feature
hgs
parents:
diff changeset
   602
                iCurrentFeature = DetectFeatureHead();
hgs
parents:
diff changeset
   603
                }//else
hgs
parents:
diff changeset
   604
            }//else        
hgs
parents:
diff changeset
   605
        }//while
hgs
parents:
diff changeset
   606
    }
hgs
parents:
diff changeset
   607
hgs
parents:
diff changeset
   608
hgs
parents:
diff changeset
   609
// ---------------------------------------------------------
hgs
parents:
diff changeset
   610
// CReaderXML::LocateAP
hgs
parents:
diff changeset
   611
// ---------------------------------------------------------
hgs
parents:
diff changeset
   612
//
hgs
parents:
diff changeset
   613
TBool CReaderXML::LocateAPL()
hgs
parents:
diff changeset
   614
    {
hgs
parents:
diff changeset
   615
    TBool found( EFalse );    //found feature data
hgs
parents:
diff changeset
   616
    TBool eofea( EFalse );    //end of feature
hgs
parents:
diff changeset
   617
    
hgs
parents:
diff changeset
   618
    if ( CurrentFeature() == EFeatureGlobal )
hgs
parents:
diff changeset
   619
        {
hgs
parents:
diff changeset
   620
        //for Global settings there is no feature data header
hgs
parents:
diff changeset
   621
        found = iFoundGlobal;
hgs
parents:
diff changeset
   622
        iFoundGlobal = EFalse;
hgs
parents:
diff changeset
   623
        }
hgs
parents:
diff changeset
   624
    else
hgs
parents:
diff changeset
   625
        {
hgs
parents:
diff changeset
   626
        //looks for the next feature header
hgs
parents:
diff changeset
   627
        while ( !eofea && !found )
hgs
parents:
diff changeset
   628
            {
hgs
parents:
diff changeset
   629
            User::LeaveIfError( ReadLineL() );
hgs
parents:
diff changeset
   630
            
hgs
parents:
diff changeset
   631
            if ( DetectFeatureTail() )
hgs
parents:
diff changeset
   632
                {
hgs
parents:
diff changeset
   633
                //feature tail is detected - no more data to process
hgs
parents:
diff changeset
   634
                eofea = ETrue;    
hgs
parents:
diff changeset
   635
                }
hgs
parents:
diff changeset
   636
            else
hgs
parents:
diff changeset
   637
                {
hgs
parents:
diff changeset
   638
                //looks for feature data header
hgs
parents:
diff changeset
   639
                switch ( CurrentFeature() )
hgs
parents:
diff changeset
   640
                    {
hgs
parents:
diff changeset
   641
                    case EFeaturePacketData:
hgs
parents:
diff changeset
   642
                        found = ( iLine->FindF( KDataHeadPacketData ) != KErrNotFound ); 
hgs
parents:
diff changeset
   643
                        break;
hgs
parents:
diff changeset
   644
                    case EFeatureWLAN:
hgs
parents:
diff changeset
   645
                        found = ( iLine->FindF( KDataHeadWLAN ) != KErrNotFound );
hgs
parents:
diff changeset
   646
                        break;
hgs
parents:
diff changeset
   647
                    case EFeatureLAN:
hgs
parents:
diff changeset
   648
                        found = ( iLine->FindF( KDataHeadLAN ) != KErrNotFound );
hgs
parents:
diff changeset
   649
                        break;
hgs
parents:
diff changeset
   650
                    case EFeatureVPN:
hgs
parents:
diff changeset
   651
                        found = ( iLine->FindF( KDataHeadVPN ) != KErrNotFound );
hgs
parents:
diff changeset
   652
                        break;
hgs
parents:
diff changeset
   653
                    case EFeatureDN:
hgs
parents:
diff changeset
   654
                        found = ( iLine->FindF( KDataHeadDN ) != KErrNotFound );
hgs
parents:
diff changeset
   655
                        break;
hgs
parents:
diff changeset
   656
                    }//switch
hgs
parents:
diff changeset
   657
                }//else
hgs
parents:
diff changeset
   658
            }//while
hgs
parents:
diff changeset
   659
        }//else
hgs
parents:
diff changeset
   660
            
hgs
parents:
diff changeset
   661
    return found;
hgs
parents:
diff changeset
   662
    
hgs
parents:
diff changeset
   663
    }
hgs
parents:
diff changeset
   664
           
hgs
parents:
diff changeset
   665
hgs
parents:
diff changeset
   666
// ---------------------------------------------------------
hgs
parents:
diff changeset
   667
// CReaderXML::ParseAPL
hgs
parents:
diff changeset
   668
// ---------------------------------------------------------
hgs
parents:
diff changeset
   669
//
hgs
parents:
diff changeset
   670
void CReaderXML::ParseAPL()
hgs
parents:
diff changeset
   671
    {
hgs
parents:
diff changeset
   672
    do
hgs
parents:
diff changeset
   673
        {            
hgs
parents:
diff changeset
   674
        User::LeaveIfError( ReadLineL() );
hgs
parents:
diff changeset
   675
        TInt fieldId = DetectParam();
hgs
parents:
diff changeset
   676
        
hgs
parents:
diff changeset
   677
        if ( fieldId != KErrNotFound )
hgs
parents:
diff changeset
   678
            {
hgs
parents:
diff changeset
   679
            HBufC16* param = ReadParam( EParamValue );
hgs
parents:
diff changeset
   680
            if ( param )
hgs
parents:
diff changeset
   681
                {
hgs
parents:
diff changeset
   682
                ConvertSpecialXMLChars( param );
hgs
parents:
diff changeset
   683
                CleanupStack::PushL( param );
hgs
parents:
diff changeset
   684
                TagContainer().AddL( param , fieldId );        
hgs
parents:
diff changeset
   685
                CleanupStack::Pop( param );
hgs
parents:
diff changeset
   686
                }    
hgs
parents:
diff changeset
   687
            else
hgs
parents:
diff changeset
   688
                {
hgs
parents:
diff changeset
   689
                //simply skip line
hgs
parents:
diff changeset
   690
                }        
hgs
parents:
diff changeset
   691
            }
hgs
parents:
diff changeset
   692
        
hgs
parents:
diff changeset
   693
        }
hgs
parents:
diff changeset
   694
    while ( !DetectTailAP() );
hgs
parents:
diff changeset
   695
    }
hgs
parents:
diff changeset
   696
    
hgs
parents:
diff changeset
   697
// ---------------------------------------------------------
hgs
parents:
diff changeset
   698
// CReaderXML::Reset
hgs
parents:
diff changeset
   699
// ---------------------------------------------------------
hgs
parents:
diff changeset
   700
//
hgs
parents:
diff changeset
   701
TInt CReaderXML::Reset()
hgs
parents:
diff changeset
   702
    {
hgs
parents:
diff changeset
   703
    iFilePos = 0;
hgs
parents:
diff changeset
   704
    return InputFile().Seek( ESeekStart, iFilePos );
hgs
parents:
diff changeset
   705
    }
hgs
parents:
diff changeset
   706
              
hgs
parents:
diff changeset
   707
        
hgs
parents:
diff changeset
   708
// ---------------------------------------------------------
hgs
parents:
diff changeset
   709
// CReaderXML::ToDoLog
hgs
parents:
diff changeset
   710
// ---------------------------------------------------------
hgs
parents:
diff changeset
   711
//
hgs
parents:
diff changeset
   712
void CReaderXML::ToDoLog()
hgs
parents:
diff changeset
   713
    {
hgs
parents:
diff changeset
   714
    CLOG_WRITE( "Line :" )
hgs
parents:
diff changeset
   715
    FileLogger().Write( *iLine );
hgs
parents:
diff changeset
   716
    CLOG_WRITE( "--------------------------------------------\n\n" )
hgs
parents:
diff changeset
   717
    }
hgs
parents:
diff changeset
   718
    
hgs
parents:
diff changeset
   719
// ---------------------------------------------------------
hgs
parents:
diff changeset
   720
// Private methods
hgs
parents:
diff changeset
   721
// ---------------------------------------------------------
hgs
parents:
diff changeset
   722
 
hgs
parents:
diff changeset
   723
// ---------------------------------------------------------
hgs
parents:
diff changeset
   724
// CReaderXML::ReadLine
hgs
parents:
diff changeset
   725
// ---------------------------------------------------------
hgs
parents:
diff changeset
   726
//  
hgs
parents:
diff changeset
   727
TInt CReaderXML::ReadLineL()
hgs
parents:
diff changeset
   728
    {
hgs
parents:
diff changeset
   729
    //go to the actual position
hgs
parents:
diff changeset
   730
    TInt result = InputFile().Seek(ESeekStart, iFilePos);
hgs
parents:
diff changeset
   731
    
hgs
parents:
diff changeset
   732
    //temporary buffer for line
hgs
parents:
diff changeset
   733
    TBuf8<KMaxLineSize> buf;
hgs
parents:
diff changeset
   734
hgs
parents:
diff changeset
   735
    if (result == KErrNone) 
hgs
parents:
diff changeset
   736
        {
hgs
parents:
diff changeset
   737
        result = InputFile().Read(buf, buf.MaxSize());
hgs
parents:
diff changeset
   738
        }
hgs
parents:
diff changeset
   739
hgs
parents:
diff changeset
   740
    //if seeking and reading both succesful extract one line form the buffer
hgs
parents:
diff changeset
   741
    if (result == KErrNone)
hgs
parents:
diff changeset
   742
        {
hgs
parents:
diff changeset
   743
        TPtrC8 ptrBuf8;
hgs
parents:
diff changeset
   744
        ptrBuf8.Set( buf );
61
hgs
parents: 56
diff changeset
   745
         
hgs
parents: 56
diff changeset
   746
        switch ( iCharSet )
hgs
parents: 56
diff changeset
   747
            {
hgs
parents: 56
diff changeset
   748
            case ECharSetUnicode:
hgs
parents: 56
diff changeset
   749
                {                     
hgs
parents: 56
diff changeset
   750
                //simply copy to a Unicode descriptor
hgs
parents: 56
diff changeset
   751
                TPtrC16 ptrBuf16( ( TText16* )ptrBuf8.Ptr(), \
hgs
parents: 56
diff changeset
   752
                                    ptrBuf8.Length() / KAsciiUnicodeRatio );
56
hgs
parents:
diff changeset
   753
                                        
61
hgs
parents: 56
diff changeset
   754
                TPtrC16 ptrLine;
hgs
parents: 56
diff changeset
   755
                result = ExtractLine(ptrBuf16, ptrLine);  
56
hgs
parents:
diff changeset
   756
                    
61
hgs
parents: 56
diff changeset
   757
                if ( result == KErrNone ) 
hgs
parents: 56
diff changeset
   758
                    {
hgs
parents: 56
diff changeset
   759
                    delete iLine;
hgs
parents: 56
diff changeset
   760
                    iLine = NULL;
hgs
parents: 56
diff changeset
   761
                    iLine = ptrLine.AllocL();
56
hgs
parents:
diff changeset
   762
                    
61
hgs
parents: 56
diff changeset
   763
                    //Increment the file position
hgs
parents: 56
diff changeset
   764
                    iFilePos += iLine->Length() * KAsciiUnicodeRatio;
hgs
parents: 56
diff changeset
   765
                    }
hgs
parents: 56
diff changeset
   766
                
hgs
parents: 56
diff changeset
   767
                break;
hgs
parents: 56
diff changeset
   768
                } 
hgs
parents: 56
diff changeset
   769
            case ECharSetAscii:
hgs
parents: 56
diff changeset
   770
            case ECharSetUtf8:
hgs
parents: 56
diff changeset
   771
            default:
hgs
parents: 56
diff changeset
   772
                {                    
hgs
parents: 56
diff changeset
   773
                //conversion to Unicode is needed
hgs
parents: 56
diff changeset
   774
                HBufC16* hBuf16 = HBufC16::NewLC( KMaxLineSize );
hgs
parents: 56
diff changeset
   775
                TPtr16 ptrBuf16( hBuf16->Des() );
hgs
parents: 56
diff changeset
   776
                
hgs
parents: 56
diff changeset
   777
                if( iCharSet == ECharSetUtf8 )
hgs
parents: 56
diff changeset
   778
                    {
hgs
parents: 56
diff changeset
   779
                    CnvUtfConverter::ConvertToUnicodeFromUtf8
hgs
parents: 56
diff changeset
   780
                                                ( ptrBuf16, ptrBuf8 );
hgs
parents: 56
diff changeset
   781
                    }
hgs
parents: 56
diff changeset
   782
                else
hgs
parents: 56
diff changeset
   783
                    {
hgs
parents: 56
diff changeset
   784
                    ptrBuf16.Copy( ptrBuf8 );
hgs
parents: 56
diff changeset
   785
                    }
56
hgs
parents:
diff changeset
   786
                    
61
hgs
parents: 56
diff changeset
   787
                TPtrC16 ptrLine;
hgs
parents: 56
diff changeset
   788
                result = ExtractLine(ptrBuf16, ptrLine); 
hgs
parents: 56
diff changeset
   789
                    
hgs
parents: 56
diff changeset
   790
                if ( result == KErrNone ) 
hgs
parents: 56
diff changeset
   791
                    {
hgs
parents: 56
diff changeset
   792
                    delete iLine;
hgs
parents: 56
diff changeset
   793
                    iLine = NULL;
hgs
parents: 56
diff changeset
   794
                    iLine = ptrLine.AllocL();
56
hgs
parents:
diff changeset
   795
                        
61
hgs
parents: 56
diff changeset
   796
                    // Increment the file position
hgs
parents: 56
diff changeset
   797
                    // Line in unicode format converted back to UTF-8
hgs
parents: 56
diff changeset
   798
                    // for getting the right lenght and osition in file
hgs
parents: 56
diff changeset
   799
                    CnvUtfConverter::ConvertFromUnicodeToUtf8( 
hgs
parents: 56
diff changeset
   800
                                        buf, iLine->Des() );
hgs
parents: 56
diff changeset
   801
                    iFilePos += buf.Length();
hgs
parents: 56
diff changeset
   802
                    }
56
hgs
parents:
diff changeset
   803
                    
61
hgs
parents: 56
diff changeset
   804
                CleanupStack::PopAndDestroy( hBuf16 ); 
56
hgs
parents:
diff changeset
   805
                    
61
hgs
parents: 56
diff changeset
   806
                break;
hgs
parents: 56
diff changeset
   807
                }//case
hgs
parents: 56
diff changeset
   808
            }//switch
56
hgs
parents:
diff changeset
   809
        }//if
hgs
parents:
diff changeset
   810
hgs
parents:
diff changeset
   811
    return result;
hgs
parents:
diff changeset
   812
    }
hgs
parents:
diff changeset
   813
 
hgs
parents:
diff changeset
   814
 
hgs
parents:
diff changeset
   815
// ---------------------------------------------------------
hgs
parents:
diff changeset
   816
// CReaderXML::ExtractLine
hgs
parents:
diff changeset
   817
// ---------------------------------------------------------
hgs
parents:
diff changeset
   818
//     
hgs
parents:
diff changeset
   819
TInt CReaderXML::ExtractLine(const TPtrC16& aBuffer, TPtrC16& aLine)
hgs
parents:
diff changeset
   820
    {
hgs
parents:
diff changeset
   821
    // Whitespace characters
hgs
parents:
diff changeset
   822
    const TChar KSpace = ' ';
hgs
parents:
diff changeset
   823
    const TChar KNewLine = '\n';
hgs
parents:
diff changeset
   824
    const TChar KCarriageReturn = '\r';
hgs
parents:
diff changeset
   825
    const TChar KTab = '\t';
hgs
parents:
diff changeset
   826
    const TChar KTagStart = '<';
hgs
parents:
diff changeset
   827
    
hgs
parents:
diff changeset
   828
    
hgs
parents:
diff changeset
   829
    // A line is considered to contain one parameter. It starts from the
hgs
parents:
diff changeset
   830
    // current position and lasts until the end of the current parameter.
hgs
parents:
diff changeset
   831
    // The end is detected by looking for the characters ">" and "<" with
hgs
parents:
diff changeset
   832
    // any number of white spaces between them. The next line will start at
hgs
parents:
diff changeset
   833
    // the "<" character.
hgs
parents:
diff changeset
   834
    TBool lineEndFound( EFalse );
hgs
parents:
diff changeset
   835
    TBool tagEndFound( EFalse );
hgs
parents:
diff changeset
   836
    TInt pos( 0 );
hgs
parents:
diff changeset
   837
    while( !lineEndFound && pos < aBuffer.Length() )
hgs
parents:
diff changeset
   838
        {
hgs
parents:
diff changeset
   839
        if( !tagEndFound && KParamNameTail.iBuf[ 0 ] == aBuffer[ pos ] )
hgs
parents:
diff changeset
   840
            {
hgs
parents:
diff changeset
   841
            tagEndFound = ETrue;
hgs
parents:
diff changeset
   842
            }
hgs
parents:
diff changeset
   843
        else if( tagEndFound && KParamNameHead.iBuf[ 0 ] == aBuffer[ pos ] )
hgs
parents:
diff changeset
   844
            {
hgs
parents:
diff changeset
   845
            lineEndFound = ETrue;
hgs
parents:
diff changeset
   846
            break;
hgs
parents:
diff changeset
   847
            }
hgs
parents:
diff changeset
   848
        
hgs
parents:
diff changeset
   849
        else if( ( KSpace != aBuffer[ pos ] ) &&
hgs
parents:
diff changeset
   850
                 ( KNewLine != aBuffer[ pos ] ) &&
hgs
parents:
diff changeset
   851
                 ( KCarriageReturn != aBuffer[ pos ] ) &&
hgs
parents:
diff changeset
   852
                 ( KTab != aBuffer[ pos ] ) && 
hgs
parents:
diff changeset
   853
                   tagEndFound )
hgs
parents:
diff changeset
   854
            {
hgs
parents:
diff changeset
   855
            tagEndFound = EFalse;
hgs
parents:
diff changeset
   856
            }
hgs
parents:
diff changeset
   857
        ++pos;
hgs
parents:
diff changeset
   858
        }
hgs
parents:
diff changeset
   859
    
hgs
parents:
diff changeset
   860
    if( !lineEndFound )
hgs
parents:
diff changeset
   861
        {
hgs
parents:
diff changeset
   862
        //End of line not found--malformed xml file or no more data
hgs
parents:
diff changeset
   863
        //get highest file position; and check EoF
hgs
parents:
diff changeset
   864
        TInt hiPos = 0;
hgs
parents:
diff changeset
   865
        
hgs
parents:
diff changeset
   866
        if (InputFile().Size(hiPos) != KErrNone) 
hgs
parents:
diff changeset
   867
            {
hgs
parents:
diff changeset
   868
            return KErrGeneral;    
hgs
parents:
diff changeset
   869
            }
hgs
parents:
diff changeset
   870
        
hgs
parents:
diff changeset
   871
        //check for end of file
hgs
parents:
diff changeset
   872
        if ( aBuffer.Length() < KMaxLineSize )
hgs
parents:
diff changeset
   873
            {
hgs
parents:
diff changeset
   874
            aLine.Set( aBuffer );
hgs
parents:
diff changeset
   875
            return KErrEof;
hgs
parents:
diff changeset
   876
            }
hgs
parents:
diff changeset
   877
        else
hgs
parents:
diff changeset
   878
            {
hgs
parents:
diff changeset
   879
            return KErrNotFound;    
hgs
parents:
diff changeset
   880
            }
hgs
parents:
diff changeset
   881
        }
hgs
parents:
diff changeset
   882
hgs
parents:
diff changeset
   883
    aLine.Set( aBuffer.Left( pos ) );
hgs
parents:
diff changeset
   884
hgs
parents:
diff changeset
   885
    return KErrNone ;
hgs
parents:
diff changeset
   886
    }
hgs
parents:
diff changeset
   887
hgs
parents:
diff changeset
   888
// ---------------------------------------------------------
hgs
parents:
diff changeset
   889
// CReaderXML::DetectFeatureHead
hgs
parents:
diff changeset
   890
// ---------------------------------------------------------
hgs
parents:
diff changeset
   891
//     
hgs
parents:
diff changeset
   892
TDbCreatorFeatures CReaderXML::DetectFeatureHead()
hgs
parents:
diff changeset
   893
    {
hgs
parents:
diff changeset
   894
    TDbCreatorFeatures feature( EFeatureNone );
hgs
parents:
diff changeset
   895
    
hgs
parents:
diff changeset
   896
    if ( iLine->FindF( KFeatureHeadPacketData ) != KErrNotFound )
hgs
parents:
diff changeset
   897
        {
hgs
parents:
diff changeset
   898
        CLOG_WRITE( "CReaderXML::DetectFeatureHead(): EFeaturePacketData" );
hgs
parents:
diff changeset
   899
        feature = EFeaturePacketData;
hgs
parents:
diff changeset
   900
        }
hgs
parents:
diff changeset
   901
    else if ( iLine->FindF( KFeatureHeadWLAN ) != KErrNotFound )
hgs
parents:
diff changeset
   902
        {
hgs
parents:
diff changeset
   903
        CLOG_WRITE( "CReaderXML::DetectFeatureHead(): EFeatureWLAN" );
hgs
parents:
diff changeset
   904
        feature = EFeatureWLAN;
hgs
parents:
diff changeset
   905
        }
hgs
parents:
diff changeset
   906
    else if ( iLine->FindF( KFeatureHeadLAN ) != KErrNotFound )
hgs
parents:
diff changeset
   907
        {
hgs
parents:
diff changeset
   908
        CLOG_WRITE( "CReaderXML::DetectFeatureHead(): EFeatureLAN" );
hgs
parents:
diff changeset
   909
        feature = EFeatureLAN;
hgs
parents:
diff changeset
   910
        }
hgs
parents:
diff changeset
   911
    else if ( iLine->FindF( KFeatureHeadVPN ) != KErrNotFound )
hgs
parents:
diff changeset
   912
        {
hgs
parents:
diff changeset
   913
        CLOG_WRITE( "CReaderXML::DetectFeatureHead(): EFeatureVPN" );
hgs
parents:
diff changeset
   914
        feature = EFeatureVPN;
hgs
parents:
diff changeset
   915
        }
hgs
parents:
diff changeset
   916
    else if ( iLine->FindF( KFeatureHeadDN ) != KErrNotFound )
hgs
parents:
diff changeset
   917
        {
hgs
parents:
diff changeset
   918
        CLOG_WRITE( "CReaderXML::DetectFeatureHead(): EFeatureDN" );
hgs
parents:
diff changeset
   919
        feature = EFeatureDN;
hgs
parents:
diff changeset
   920
        }
hgs
parents:
diff changeset
   921
    else if ( iLine->FindF( KFeatureHeadGlobal ) != KErrNotFound )
hgs
parents:
diff changeset
   922
        {
hgs
parents:
diff changeset
   923
        CLOG_WRITE( "CReaderXML::DetectFeatureHead(): EFeatureGlobal" );
hgs
parents:
diff changeset
   924
        feature = EFeatureGlobal;
hgs
parents:
diff changeset
   925
        iFoundGlobal = ETrue;        
hgs
parents:
diff changeset
   926
        }
hgs
parents:
diff changeset
   927
    else
hgs
parents:
diff changeset
   928
        {
hgs
parents:
diff changeset
   929
        //feature not found            
hgs
parents:
diff changeset
   930
        }
hgs
parents:
diff changeset
   931
    
hgs
parents:
diff changeset
   932
    return feature;
hgs
parents:
diff changeset
   933
hgs
parents:
diff changeset
   934
    }
hgs
parents:
diff changeset
   935
    
hgs
parents:
diff changeset
   936
    
hgs
parents:
diff changeset
   937
// ---------------------------------------------------------
hgs
parents:
diff changeset
   938
// CReaderXML::DetectFeatureTail
hgs
parents:
diff changeset
   939
// ---------------------------------------------------------
hgs
parents:
diff changeset
   940
//     
hgs
parents:
diff changeset
   941
TBool CReaderXML::DetectFeatureTail()
hgs
parents:
diff changeset
   942
    {
hgs
parents:
diff changeset
   943
    TBool found( EFalse );
hgs
parents:
diff changeset
   944
        
hgs
parents:
diff changeset
   945
    switch ( CurrentFeature() )        
hgs
parents:
diff changeset
   946
        {
hgs
parents:
diff changeset
   947
        case EFeaturePacketData:
hgs
parents:
diff changeset
   948
            found = ( iLine->FindF( KFeatureTailPacketData ) != KErrNotFound ); 
hgs
parents:
diff changeset
   949
            break;
hgs
parents:
diff changeset
   950
        case EFeatureWLAN:
hgs
parents:
diff changeset
   951
            found = ( iLine->FindF( KFeatureTailWLAN ) != KErrNotFound );
hgs
parents:
diff changeset
   952
            break;
hgs
parents:
diff changeset
   953
        case EFeatureLAN:
hgs
parents:
diff changeset
   954
            found = ( iLine->FindF( KFeatureTailLAN ) != KErrNotFound );
hgs
parents:
diff changeset
   955
            break;
hgs
parents:
diff changeset
   956
        case EFeatureVPN:
hgs
parents:
diff changeset
   957
            found = ( iLine->FindF( KFeatureTailVPN ) != KErrNotFound );
hgs
parents:
diff changeset
   958
            break;
hgs
parents:
diff changeset
   959
        case EFeatureDN:
hgs
parents:
diff changeset
   960
            found = ( iLine->FindF( KFeatureTailDN ) != KErrNotFound );
hgs
parents:
diff changeset
   961
            break;
hgs
parents:
diff changeset
   962
        case EFeatureGlobal:
hgs
parents:
diff changeset
   963
            found = ( iLine->FindF( KFeatureTailGlobal ) != KErrNotFound );
hgs
parents:
diff changeset
   964
            break;
hgs
parents:
diff changeset
   965
        }
hgs
parents:
diff changeset
   966
    
hgs
parents:
diff changeset
   967
    return found;
hgs
parents:
diff changeset
   968
    }
hgs
parents:
diff changeset
   969
    
hgs
parents:
diff changeset
   970
    
hgs
parents:
diff changeset
   971
// ---------------------------------------------------------
hgs
parents:
diff changeset
   972
// CReaderXML::DetectTailAP
hgs
parents:
diff changeset
   973
// ---------------------------------------------------------
hgs
parents:
diff changeset
   974
//     
hgs
parents:
diff changeset
   975
TBool CReaderXML::DetectTailAP()
hgs
parents:
diff changeset
   976
    {
hgs
parents:
diff changeset
   977
    TBool found( EFalse );
hgs
parents:
diff changeset
   978
        
hgs
parents:
diff changeset
   979
    switch ( CurrentFeature() )        
hgs
parents:
diff changeset
   980
        {
hgs
parents:
diff changeset
   981
        case EFeaturePacketData:
hgs
parents:
diff changeset
   982
            found = ( iLine->FindF( KDataTailPacketData ) != KErrNotFound ); 
hgs
parents:
diff changeset
   983
            break;
hgs
parents:
diff changeset
   984
        case EFeatureWLAN:
hgs
parents:
diff changeset
   985
            found = ( iLine->FindF( KDataTailWLAN ) != KErrNotFound );
hgs
parents:
diff changeset
   986
            break;
hgs
parents:
diff changeset
   987
        case EFeatureLAN:
hgs
parents:
diff changeset
   988
            found = ( iLine->FindF( KDataTailLAN ) != KErrNotFound );
hgs
parents:
diff changeset
   989
            break;
hgs
parents:
diff changeset
   990
        case EFeatureVPN:
hgs
parents:
diff changeset
   991
            found = ( iLine->FindF( KDataTailVPN ) != KErrNotFound );
hgs
parents:
diff changeset
   992
            break;
hgs
parents:
diff changeset
   993
        case EFeatureDN:
hgs
parents:
diff changeset
   994
            found = ( iLine->FindF( KDataTailDN ) != KErrNotFound );
hgs
parents:
diff changeset
   995
            break;
hgs
parents:
diff changeset
   996
        case EFeatureGlobal:
hgs
parents:
diff changeset
   997
            //there is no data tail for Global settings -- looks for feature tail
hgs
parents:
diff changeset
   998
            found = ( iLine->FindF( KFeatureTailGlobal ) != KErrNotFound );
hgs
parents:
diff changeset
   999
            break;
hgs
parents:
diff changeset
  1000
        }
hgs
parents:
diff changeset
  1001
    
hgs
parents:
diff changeset
  1002
    return found;
hgs
parents:
diff changeset
  1003
    }
hgs
parents:
diff changeset
  1004
    
hgs
parents:
diff changeset
  1005
    
hgs
parents:
diff changeset
  1006
// ---------------------------------------------------------
hgs
parents:
diff changeset
  1007
// CReaderXML::DetectParamL
hgs
parents:
diff changeset
  1008
// ---------------------------------------------------------
hgs
parents:
diff changeset
  1009
//
hgs
parents:
diff changeset
  1010
TInt CReaderXML::DetectParam()
hgs
parents:
diff changeset
  1011
    {
hgs
parents:
diff changeset
  1012
    TInt fieldId( KErrNotFound ); //field id of detected parameter 
hgs
parents:
diff changeset
  1013
    RArray<EInputParams> *params( NULL ); //pointer to the table used 
hgs
parents:
diff changeset
  1014
                                        //for or detection    
hgs
parents:
diff changeset
  1015
hgs
parents:
diff changeset
  1016
    switch ( CurrentFeature() )        
hgs
parents:
diff changeset
  1017
        {
hgs
parents:
diff changeset
  1018
        case EFeaturePacketData:
hgs
parents:
diff changeset
  1019
            params   = &iPDParams;
hgs
parents:
diff changeset
  1020
            break;
hgs
parents:
diff changeset
  1021
        case EFeatureWLAN:
hgs
parents:
diff changeset
  1022
            params   = &iWLanParams;
hgs
parents:
diff changeset
  1023
            break;
hgs
parents:
diff changeset
  1024
        case EFeatureLAN:
hgs
parents:
diff changeset
  1025
            params   = &iLanParams;
hgs
parents:
diff changeset
  1026
            break;
hgs
parents:
diff changeset
  1027
        case EFeatureVPN:
hgs
parents:
diff changeset
  1028
            params   = &iVpnParams;
hgs
parents:
diff changeset
  1029
            break;
hgs
parents:
diff changeset
  1030
        case EFeatureDN:
hgs
parents:
diff changeset
  1031
            params =   &iDNParams;
hgs
parents:
diff changeset
  1032
            break;
hgs
parents:
diff changeset
  1033
        case EFeatureGlobal:
hgs
parents:
diff changeset
  1034
            params   = &iGlobalParams;
hgs
parents:
diff changeset
  1035
            break;
hgs
parents:
diff changeset
  1036
        default:
hgs
parents:
diff changeset
  1037
            User::Panic( KPanicInvalidCase, KErrInvalidCase );
hgs
parents:
diff changeset
  1038
        }
hgs
parents:
diff changeset
  1039
       
hgs
parents:
diff changeset
  1040
    //looks for parameter match
hgs
parents:
diff changeset
  1041
    HBufC16* paramName = ReadParam( EParamName );
hgs
parents:
diff changeset
  1042
    if ( paramName == NULL )
hgs
parents:
diff changeset
  1043
            {
hgs
parents:
diff changeset
  1044
            return fieldId;
hgs
parents:
diff changeset
  1045
            }
hgs
parents:
diff changeset
  1046
hgs
parents:
diff changeset
  1047
    TBool found ( EFalse );
hgs
parents:
diff changeset
  1048
    for ( TInt idx = 0; idx < params->Count() && !found; idx++ )
hgs
parents:
diff changeset
  1049
        {        
hgs
parents:
diff changeset
  1050
        if ( paramName->CompareF( (*params)[idx].iParam ) == 0 )
hgs
parents:
diff changeset
  1051
            {
hgs
parents:
diff changeset
  1052
            fieldId = (*params)[idx].iId;
hgs
parents:
diff changeset
  1053
            found = ETrue;            
hgs
parents:
diff changeset
  1054
            }
hgs
parents:
diff changeset
  1055
        }
hgs
parents:
diff changeset
  1056
       
hgs
parents:
diff changeset
  1057
    delete paramName;   
hgs
parents:
diff changeset
  1058
    return fieldId;
hgs
parents:
diff changeset
  1059
    }
hgs
parents:
diff changeset
  1060
  
hgs
parents:
diff changeset
  1061
    
hgs
parents:
diff changeset
  1062
// ---------------------------------------------------------
hgs
parents:
diff changeset
  1063
// CReaderXML::ReadParam
hgs
parents:
diff changeset
  1064
// ---------------------------------------------------------
hgs
parents:
diff changeset
  1065
//     
hgs
parents:
diff changeset
  1066
HBufC16* CReaderXML::ReadParam( TParamSegment aSegment )
hgs
parents:
diff changeset
  1067
    {
hgs
parents:
diff changeset
  1068
    TBuf<KMaxItemLength> tag; //local buffer
hgs
parents:
diff changeset
  1069
    TInt posh( 0 ); //header position
hgs
parents:
diff changeset
  1070
    TInt post( 0 ); //tail position
hgs
parents:
diff changeset
  1071
    HBufC16* ret = NULL; // returned pointer
hgs
parents:
diff changeset
  1072
    
hgs
parents:
diff changeset
  1073
    //  calculation of the position 
hgs
parents:
diff changeset
  1074
    //
hgs
parents:
diff changeset
  1075
    //  EParamValue:           posh|     post|
hgs
parents:
diff changeset
  1076
    //                             |         |
hgs
parents:
diff changeset
  1077
    //  EParamName:  posh|    post||         |
hgs
parents:
diff changeset
  1078
    //                   ¡        ¡¡         ¡ 
hgs
parents:
diff changeset
  1079
    //                  <ParamName>ParamValue</ParamName>
hgs
parents:
diff changeset
  1080
    
hgs
parents:
diff changeset
  1081
    switch ( aSegment )
hgs
parents:
diff changeset
  1082
        {
hgs
parents:
diff changeset
  1083
        case EParamValue:
hgs
parents:
diff changeset
  1084
            posh = iLine->Find( KParamValueHead ) + 1;
hgs
parents:
diff changeset
  1085
            post = iLine->Find( KParamValueTail );
hgs
parents:
diff changeset
  1086
            break;
hgs
parents:
diff changeset
  1087
        case EParamName:
hgs
parents:
diff changeset
  1088
            posh = iLine->Find( KParamNameHead ) + 1;
hgs
parents:
diff changeset
  1089
            post = iLine->Find( KParamNameTail );
hgs
parents:
diff changeset
  1090
            break;
hgs
parents:
diff changeset
  1091
        default:
hgs
parents:
diff changeset
  1092
            break;
hgs
parents:
diff changeset
  1093
        }
hgs
parents:
diff changeset
  1094
    
hgs
parents:
diff changeset
  1095
    if ( posh == KErrNotFound || post == KErrNotFound || post == 0 )
hgs
parents:
diff changeset
  1096
        {
hgs
parents:
diff changeset
  1097
        //line must contain header and tail and longer than 0
hgs
parents:
diff changeset
  1098
        ret = NULL;
hgs
parents:
diff changeset
  1099
        }
hgs
parents:
diff changeset
  1100
    else
hgs
parents:
diff changeset
  1101
        {
hgs
parents:
diff changeset
  1102
        // Copis the value to the local buffer and allocates buffer
hgs
parents:
diff changeset
  1103
        tag.Copy( iLine->Mid( posh, post - posh ) );
hgs
parents:
diff changeset
  1104
        ret = tag.Alloc();
hgs
parents:
diff changeset
  1105
        // Checks the result.
hgs
parents:
diff changeset
  1106
        if( ret == NULL )
hgs
parents:
diff changeset
  1107
            {
hgs
parents:
diff changeset
  1108
            CLOG_WRITE_FORMAT( "! Warning: tag could not be allocated %S:",
hgs
parents:
diff changeset
  1109
                                     &tag );
hgs
parents:
diff changeset
  1110
            }
hgs
parents:
diff changeset
  1111
// Debugging help; commented out for clearer log.
hgs
parents:
diff changeset
  1112
//        else 
hgs
parents:
diff changeset
  1113
//            {
hgs
parents:
diff changeset
  1114
//            if (aSegment == EParamValue)
hgs
parents:
diff changeset
  1115
//                {
hgs
parents:
diff changeset
  1116
//                CLOG_WRITE_FORMAT( "CReaderXML::ReadParam: value %S", &tag );
hgs
parents:
diff changeset
  1117
//                }
hgs
parents:
diff changeset
  1118
//            else if (aSegment == EParamName)
hgs
parents:
diff changeset
  1119
//                {
hgs
parents:
diff changeset
  1120
//                CLOG_WRITE_FORMAT( "CReaderXML::ReadParam: name %S", &tag );
hgs
parents:
diff changeset
  1121
//                }
hgs
parents:
diff changeset
  1122
//            }
hgs
parents:
diff changeset
  1123
        }
hgs
parents:
diff changeset
  1124
    return ret;
hgs
parents:
diff changeset
  1125
    }
hgs
parents:
diff changeset
  1126
hgs
parents:
diff changeset
  1127
hgs
parents:
diff changeset
  1128
// ---------------------------------------------------------
hgs
parents:
diff changeset
  1129
// CReaderXML::DetectEncoding
hgs
parents:
diff changeset
  1130
// ---------------------------------------------------------
hgs
parents:
diff changeset
  1131
//     
hgs
parents:
diff changeset
  1132
void CReaderXML::DetectEncodingL()
hgs
parents:
diff changeset
  1133
    {
hgs
parents:
diff changeset
  1134
    TInt originalPos( iFilePos );  //stores original file position
hgs
parents:
diff changeset
  1135
    TBool found( EFalse );
hgs
parents:
diff changeset
  1136
    
hgs
parents:
diff changeset
  1137
    for ( TInt i = ECharSetUnicode; i >= ECharSetAscii && !found; i--)
hgs
parents:
diff changeset
  1138
        {
hgs
parents:
diff changeset
  1139
        //assumes that the first line contains version and encoding info
hgs
parents:
diff changeset
  1140
        iFilePos = 0;
hgs
parents:
diff changeset
  1141
        iCharSet = static_cast<TDbCreatorInputCharSet>( i );
hgs
parents:
diff changeset
  1142
        
hgs
parents:
diff changeset
  1143
        if ( ReadLineL() == KErrNone )
hgs
parents:
diff changeset
  1144
            {
hgs
parents:
diff changeset
  1145
            if( iCharSet == ECharSetAscii )
hgs
parents:
diff changeset
  1146
                {
hgs
parents:
diff changeset
  1147
                if ( ( iLine->FindF( KXmlVersion ) != KErrNotFound ) ||
hgs
parents:
diff changeset
  1148
                     ( iLine->FindF( KEncoding ) != KErrNotFound ) )
hgs
parents:
diff changeset
  1149
                    {
hgs
parents:
diff changeset
  1150
                    if( iLine->FindF( KEncodingUtf8 ) != KErrNotFound )
hgs
parents:
diff changeset
  1151
                        {
hgs
parents:
diff changeset
  1152
                        iCharSet = ECharSetUtf8;
hgs
parents:
diff changeset
  1153
                        }
hgs
parents:
diff changeset
  1154
                    found = ETrue;
hgs
parents:
diff changeset
  1155
                    }
hgs
parents:
diff changeset
  1156
                }
hgs
parents:
diff changeset
  1157
            else if( iCharSet == ECharSetUnicode )
hgs
parents:
diff changeset
  1158
                {
hgs
parents:
diff changeset
  1159
                if ( ( iLine->FindF( KXmlVersion ) != KErrNotFound ) ||
hgs
parents:
diff changeset
  1160
                     ( iLine->FindF( KEncoding ) != KErrNotFound ) )
hgs
parents:
diff changeset
  1161
                    {
hgs
parents:
diff changeset
  1162
                    found = ETrue;
hgs
parents:
diff changeset
  1163
                    }
hgs
parents:
diff changeset
  1164
                }
hgs
parents:
diff changeset
  1165
            }
hgs
parents:
diff changeset
  1166
        }
hgs
parents:
diff changeset
  1167
    iFilePos = originalPos;
hgs
parents:
diff changeset
  1168
    }
hgs
parents:
diff changeset
  1169
    
hgs
parents:
diff changeset
  1170
// ---------------------------------------------------------
hgs
parents:
diff changeset
  1171
// CReaderXML::ConvertSpecialXMLChars
hgs
parents:
diff changeset
  1172
// ---------------------------------------------------------
hgs
parents:
diff changeset
  1173
//
hgs
parents:
diff changeset
  1174
void CReaderXML::ConvertSpecialXMLChars( HBufC* aPtrTag )
hgs
parents:
diff changeset
  1175
    {
hgs
parents:
diff changeset
  1176
    if ( aPtrTag == NULL )
hgs
parents:
diff changeset
  1177
            {
hgs
parents:
diff changeset
  1178
                return;
hgs
parents:
diff changeset
  1179
            }   
hgs
parents:
diff changeset
  1180
    _LIT16( escapeStart, "&" );
hgs
parents:
diff changeset
  1181
    
hgs
parents:
diff changeset
  1182
    //check if there are parameters to be replaced, if not: return
hgs
parents:
diff changeset
  1183
    if ( aPtrTag->Des().Find( escapeStart ) == KErrNotFound )
hgs
parents:
diff changeset
  1184
            {
hgs
parents:
diff changeset
  1185
                return;
hgs
parents:
diff changeset
  1186
            }
hgs
parents:
diff changeset
  1187
                
hgs
parents:
diff changeset
  1188
    _LIT16( spXML1, "&lt;" );
hgs
parents:
diff changeset
  1189
    _LIT16( sp1, "<" );
hgs
parents:
diff changeset
  1190
    ReplaceInString( aPtrTag, spXML1, sp1 );
hgs
parents:
diff changeset
  1191
    _LIT16( spXML2, "&amp;" );
hgs
parents:
diff changeset
  1192
    _LIT16( sp2, "&" );
hgs
parents:
diff changeset
  1193
    ReplaceInString( aPtrTag, spXML2, sp2 );
hgs
parents:
diff changeset
  1194
    _LIT16( spXML3, "&gt;" );
hgs
parents:
diff changeset
  1195
    _LIT16( sp3, ">" );
hgs
parents:
diff changeset
  1196
    ReplaceInString( aPtrTag, spXML3, sp3 );
hgs
parents:
diff changeset
  1197
    _LIT16( spXML4, "&quot;" );
hgs
parents:
diff changeset
  1198
    _LIT16( sp4, "\"" );
hgs
parents:
diff changeset
  1199
    ReplaceInString( aPtrTag, spXML4, sp4 );
hgs
parents:
diff changeset
  1200
    _LIT16( spXML5, "&apos;" );
hgs
parents:
diff changeset
  1201
    _LIT16( sp5, "\'" );
hgs
parents:
diff changeset
  1202
    ReplaceInString( aPtrTag, spXML5, sp5 );
hgs
parents:
diff changeset
  1203
    _LIT16( spXML6, "&iexcl;" );
hgs
parents:
diff changeset
  1204
    _LIT16( sp6, "\u00a1" );
hgs
parents:
diff changeset
  1205
    ReplaceInString( aPtrTag, spXML6, sp6 );
hgs
parents:
diff changeset
  1206
    _LIT16( spXML7, "&cent;" );
hgs
parents:
diff changeset
  1207
    _LIT16( sp7, "\u00a2" );
hgs
parents:
diff changeset
  1208
    ReplaceInString( aPtrTag, spXML7, sp7 );
hgs
parents:
diff changeset
  1209
    _LIT16( spXML8, "&pound;" );
hgs
parents:
diff changeset
  1210
    _LIT16( sp8, "\u00a3" );
hgs
parents:
diff changeset
  1211
    ReplaceInString( aPtrTag, spXML8, sp8 );
hgs
parents:
diff changeset
  1212
    _LIT16( spXML9, "&curren;" );
hgs
parents:
diff changeset
  1213
    _LIT16( sp9, "\u00a4" );
hgs
parents:
diff changeset
  1214
    ReplaceInString( aPtrTag, spXML9, sp9 );
hgs
parents:
diff changeset
  1215
    _LIT16( spXML10, "&yen;" );
hgs
parents:
diff changeset
  1216
    _LIT16( sp10, "\u00a5" );
hgs
parents:
diff changeset
  1217
    ReplaceInString( aPtrTag, spXML10, sp10 );
hgs
parents:
diff changeset
  1218
    _LIT16( spXML11, "&brvbar;" );
hgs
parents:
diff changeset
  1219
    _LIT16( sp11, "\u00a6" );
hgs
parents:
diff changeset
  1220
    ReplaceInString( aPtrTag, spXML11, sp11 );
hgs
parents:
diff changeset
  1221
    _LIT16( spXML12, "&sect;" );
hgs
parents:
diff changeset
  1222
    _LIT16( sp12, "\u00a7" );
hgs
parents:
diff changeset
  1223
    ReplaceInString( aPtrTag, spXML12, sp12 );
hgs
parents:
diff changeset
  1224
    _LIT16( spXML13, "&uml;" );
hgs
parents:
diff changeset
  1225
    _LIT16( sp13, "\u00a8" );
hgs
parents:
diff changeset
  1226
    ReplaceInString( aPtrTag, spXML13, sp13 );
hgs
parents:
diff changeset
  1227
    _LIT16( spXML14, "&copy;" );
hgs
parents:
diff changeset
  1228
    _LIT16( sp14, "\u00a9" );
hgs
parents:
diff changeset
  1229
    ReplaceInString( aPtrTag, spXML14, sp14 );
hgs
parents:
diff changeset
  1230
    _LIT16( spXML15, "&ordf;" );
hgs
parents:
diff changeset
  1231
    _LIT16( sp15, "\u00aa" );
hgs
parents:
diff changeset
  1232
    ReplaceInString( aPtrTag, spXML15, sp15 );
hgs
parents:
diff changeset
  1233
    _LIT16( spXML16, "&laquo;" );
hgs
parents:
diff changeset
  1234
    _LIT16( sp16, "\u00ab" );
hgs
parents:
diff changeset
  1235
    ReplaceInString( aPtrTag, spXML16, sp16 );
hgs
parents:
diff changeset
  1236
    _LIT16( spXML17, "&not;" );
hgs
parents:
diff changeset
  1237
    _LIT16( sp17, "\u00ac" );
hgs
parents:
diff changeset
  1238
    ReplaceInString( aPtrTag, spXML17, sp17 );
hgs
parents:
diff changeset
  1239
    _LIT16( spXML18, "&reg;" );
hgs
parents:
diff changeset
  1240
    _LIT16( sp18, "\u00ae" );
hgs
parents:
diff changeset
  1241
    ReplaceInString( aPtrTag, spXML18, sp18 );
hgs
parents:
diff changeset
  1242
    _LIT16( spXML19, "&macr;" );
hgs
parents:
diff changeset
  1243
    _LIT16( sp19, "\u00af" );
hgs
parents:
diff changeset
  1244
    ReplaceInString( aPtrTag, spXML19, sp19 );
hgs
parents:
diff changeset
  1245
    _LIT16( spXML20, "&deg;" );
hgs
parents:
diff changeset
  1246
    _LIT16( sp20, "\u00b0" );
hgs
parents:
diff changeset
  1247
    ReplaceInString( aPtrTag, spXML20, sp20 );
hgs
parents:
diff changeset
  1248
    _LIT16( spXML21, "&plusmn;" );
hgs
parents:
diff changeset
  1249
    _LIT16( sp21, "\u00b1" );
hgs
parents:
diff changeset
  1250
    ReplaceInString( aPtrTag, spXML21, sp21 );
hgs
parents:
diff changeset
  1251
    _LIT16( spXML22, "&sup2;" );
hgs
parents:
diff changeset
  1252
    _LIT16( sp22, "\u00b2" );
hgs
parents:
diff changeset
  1253
    ReplaceInString( aPtrTag, spXML22, sp22 );
hgs
parents:
diff changeset
  1254
    _LIT16( spXML23, "&sup3;" );
hgs
parents:
diff changeset
  1255
    _LIT16( sp23, "\u00b3" );
hgs
parents:
diff changeset
  1256
    ReplaceInString( aPtrTag, spXML23, sp23 );
hgs
parents:
diff changeset
  1257
    _LIT16( spXML24, "&acute;" );
hgs
parents:
diff changeset
  1258
    _LIT16( sp24, "\u00b4" );
hgs
parents:
diff changeset
  1259
    ReplaceInString( aPtrTag, spXML24, sp24 );
hgs
parents:
diff changeset
  1260
    _LIT16( spXML25, "&micro;" );
hgs
parents:
diff changeset
  1261
    _LIT16( sp25, "\u00b5" );
hgs
parents:
diff changeset
  1262
    ReplaceInString( aPtrTag, spXML25, sp25 );
hgs
parents:
diff changeset
  1263
    _LIT16( spXML26, "&para;" );
hgs
parents:
diff changeset
  1264
    _LIT16( sp26, "\u00b6" );
hgs
parents:
diff changeset
  1265
    ReplaceInString( aPtrTag, spXML26, sp26 );  
hgs
parents:
diff changeset
  1266
    _LIT16( spXML27, "&middot;" );
hgs
parents:
diff changeset
  1267
    _LIT16( sp27, "\u00b7" );
hgs
parents:
diff changeset
  1268
    ReplaceInString( aPtrTag, spXML27, sp27 );
hgs
parents:
diff changeset
  1269
    _LIT16( spXML28, "&cedil;" );
hgs
parents:
diff changeset
  1270
    _LIT16( sp28, "\u00b8" );
hgs
parents:
diff changeset
  1271
    ReplaceInString( aPtrTag, spXML28, sp28 );
hgs
parents:
diff changeset
  1272
    _LIT16( spXML29, "&sup1;" );
hgs
parents:
diff changeset
  1273
    _LIT16( sp29, "\u00b9" );
hgs
parents:
diff changeset
  1274
    ReplaceInString( aPtrTag, spXML29, sp29 );
hgs
parents:
diff changeset
  1275
    _LIT16( spXML30, "&ordm;" );
hgs
parents:
diff changeset
  1276
    _LIT16( sp30, "\u00ba" );
hgs
parents:
diff changeset
  1277
    ReplaceInString( aPtrTag, spXML30, sp30 );
hgs
parents:
diff changeset
  1278
    _LIT16( spXML31, "&raquo;" );
hgs
parents:
diff changeset
  1279
    _LIT16( sp31, "\u00bb" );
hgs
parents:
diff changeset
  1280
    ReplaceInString( aPtrTag, spXML31, sp31 );
hgs
parents:
diff changeset
  1281
    _LIT16( spXML32, "&frac14;" );
hgs
parents:
diff changeset
  1282
    _LIT16( sp32, "\u00bc" );
hgs
parents:
diff changeset
  1283
    ReplaceInString( aPtrTag, spXML32, sp32 );
hgs
parents:
diff changeset
  1284
    _LIT16( spXML33, "&frac12;" );
hgs
parents:
diff changeset
  1285
    _LIT16( sp33, "\u00bd" );
hgs
parents:
diff changeset
  1286
    ReplaceInString( aPtrTag, spXML33, sp33 );
hgs
parents:
diff changeset
  1287
    _LIT16( spXML34, "&frac34;" );
hgs
parents:
diff changeset
  1288
    _LIT16( sp34, "\u00be" );
hgs
parents:
diff changeset
  1289
    ReplaceInString( aPtrTag, spXML34, sp34 );
hgs
parents:
diff changeset
  1290
    _LIT16( spXML35, "&iquest;" );
hgs
parents:
diff changeset
  1291
    _LIT16( sp35, "\u00bf" );
hgs
parents:
diff changeset
  1292
    ReplaceInString( aPtrTag, spXML35, sp35 );
hgs
parents:
diff changeset
  1293
    _LIT16( spXML36, "&Agrave;" );
hgs
parents:
diff changeset
  1294
    _LIT16( sp36, "\u00c0" );
hgs
parents:
diff changeset
  1295
    ReplaceInString( aPtrTag, spXML36, sp36 );
hgs
parents:
diff changeset
  1296
    _LIT16( spXML37, "&Aacute;" );
hgs
parents:
diff changeset
  1297
    _LIT16( sp37, "\u00c1" );
hgs
parents:
diff changeset
  1298
    ReplaceInString( aPtrTag, spXML37, sp37 );
hgs
parents:
diff changeset
  1299
    _LIT16( spXML38, "&Acirc;" );
hgs
parents:
diff changeset
  1300
    _LIT16( sp38, "\u00c2" );
hgs
parents:
diff changeset
  1301
    ReplaceInString( aPtrTag, spXML38, sp38 );
hgs
parents:
diff changeset
  1302
    _LIT16( spXML39, "&Atilde;" );
hgs
parents:
diff changeset
  1303
    _LIT16( sp39, "\u00c3" );
hgs
parents:
diff changeset
  1304
    ReplaceInString( aPtrTag, spXML39, sp39 );
hgs
parents:
diff changeset
  1305
    _LIT16( spXML40, "&Auml;" );
hgs
parents:
diff changeset
  1306
    _LIT16( sp40, "\u00c4" );
hgs
parents:
diff changeset
  1307
    ReplaceInString( aPtrTag, spXML40, sp40 );
hgs
parents:
diff changeset
  1308
    _LIT16( spXML41, "&Aring;" );
hgs
parents:
diff changeset
  1309
    _LIT16( sp41, "\u00c5" );
hgs
parents:
diff changeset
  1310
    ReplaceInString( aPtrTag, spXML41, sp41 );
hgs
parents:
diff changeset
  1311
    _LIT16( spXML42, "&AElig;" );
hgs
parents:
diff changeset
  1312
    _LIT16( sp42, "\u00c6" );
hgs
parents:
diff changeset
  1313
    ReplaceInString( aPtrTag, spXML42, sp42 ); 
hgs
parents:
diff changeset
  1314
    _LIT16( spXML43, "&Ccedil;" );
hgs
parents:
diff changeset
  1315
    _LIT16( sp43, "\u00c7" );
hgs
parents:
diff changeset
  1316
    ReplaceInString( aPtrTag, spXML43, sp43 );
hgs
parents:
diff changeset
  1317
    _LIT16( spXML44, "&Egrave;" );
hgs
parents:
diff changeset
  1318
    _LIT16( sp44, "\u00c8" );
hgs
parents:
diff changeset
  1319
    ReplaceInString( aPtrTag, spXML44, sp44 );
hgs
parents:
diff changeset
  1320
    _LIT16( spXML45, "&Eacute;" );
hgs
parents:
diff changeset
  1321
    _LIT16( sp45, "\u00c9" );
hgs
parents:
diff changeset
  1322
    ReplaceInString( aPtrTag, spXML45, sp45 );
hgs
parents:
diff changeset
  1323
    _LIT16( spXML46, "&Ecirc;" );
hgs
parents:
diff changeset
  1324
    _LIT16( sp46, "\u00ca" );
hgs
parents:
diff changeset
  1325
    ReplaceInString( aPtrTag, spXML46, sp46 );
hgs
parents:
diff changeset
  1326
    _LIT16( spXML47, "&Euml;" );
hgs
parents:
diff changeset
  1327
    _LIT16( sp47, "\u00cb" );
hgs
parents:
diff changeset
  1328
    ReplaceInString( aPtrTag, spXML47, sp47 );
hgs
parents:
diff changeset
  1329
    _LIT16( spXML48, "&Igrave;" );
hgs
parents:
diff changeset
  1330
    _LIT16( sp48, "\u00cc" );
hgs
parents:
diff changeset
  1331
    ReplaceInString( aPtrTag, spXML48, sp48 );
hgs
parents:
diff changeset
  1332
    _LIT16( spXML49, "&Iacute;" );
hgs
parents:
diff changeset
  1333
    _LIT16( sp49, "\u00cd" );
hgs
parents:
diff changeset
  1334
    ReplaceInString( aPtrTag, spXML49, sp49 );
hgs
parents:
diff changeset
  1335
    _LIT16( spXML50, "&Icirc;" );
hgs
parents:
diff changeset
  1336
    _LIT16( sp50, "\u00ce" );
hgs
parents:
diff changeset
  1337
    ReplaceInString( aPtrTag, spXML50, sp50 );
hgs
parents:
diff changeset
  1338
    _LIT16( spXML51, "&Iuml;" );
hgs
parents:
diff changeset
  1339
    _LIT16( sp51, "\u00cf" );
hgs
parents:
diff changeset
  1340
    ReplaceInString( aPtrTag, spXML51, sp51 );
hgs
parents:
diff changeset
  1341
    _LIT16( spXML52, "&ETH;" );
hgs
parents:
diff changeset
  1342
    _LIT16( sp52, "\u00d0" );
hgs
parents:
diff changeset
  1343
    ReplaceInString( aPtrTag, spXML52, sp52 );
hgs
parents:
diff changeset
  1344
    _LIT16( spXML53, "&Ntilde;" );
hgs
parents:
diff changeset
  1345
    _LIT16( sp53, "\u00d1" );
hgs
parents:
diff changeset
  1346
    ReplaceInString( aPtrTag, spXML53, sp53 );
hgs
parents:
diff changeset
  1347
    _LIT16( spXML54, "&Ograve;" );
hgs
parents:
diff changeset
  1348
    _LIT16( sp54, "\u00d2" );
hgs
parents:
diff changeset
  1349
    ReplaceInString( aPtrTag, spXML54, sp54 );
hgs
parents:
diff changeset
  1350
    _LIT16( spXML55, "&Oacute;" );
hgs
parents:
diff changeset
  1351
    _LIT16( sp55, "\u00d3" );
hgs
parents:
diff changeset
  1352
    ReplaceInString( aPtrTag, spXML55, sp55 );
hgs
parents:
diff changeset
  1353
    _LIT16( spXML56, "&Ocirc;" );
hgs
parents:
diff changeset
  1354
    _LIT16( sp56, "\u00d4" );
hgs
parents:
diff changeset
  1355
    ReplaceInString( aPtrTag, spXML56, sp56 );
hgs
parents:
diff changeset
  1356
    _LIT16( spXML57, "&Otilde;" );
hgs
parents:
diff changeset
  1357
    _LIT16( sp57, "\u00d5" );
hgs
parents:
diff changeset
  1358
    ReplaceInString( aPtrTag, spXML57, sp57 );
hgs
parents:
diff changeset
  1359
    _LIT16( spXML58, "&Ouml;" );
hgs
parents:
diff changeset
  1360
    _LIT16( sp58, "\u00d6" );
hgs
parents:
diff changeset
  1361
    ReplaceInString( aPtrTag, spXML58, sp58 );
hgs
parents:
diff changeset
  1362
    _LIT16( spXML59, "&times;" );
hgs
parents:
diff changeset
  1363
    _LIT16( sp59, "\u00d7" );
hgs
parents:
diff changeset
  1364
    ReplaceInString( aPtrTag, spXML59, sp59 );
hgs
parents:
diff changeset
  1365
    _LIT16( spXML60, "&Oslash;" );
hgs
parents:
diff changeset
  1366
    _LIT16( sp60, "\u00d8" );
hgs
parents:
diff changeset
  1367
    ReplaceInString( aPtrTag, spXML60, sp60 );
hgs
parents:
diff changeset
  1368
    _LIT16( spXML61, "&Ugrave;" );
hgs
parents:
diff changeset
  1369
    _LIT16( sp61, "\u00d9" );
hgs
parents:
diff changeset
  1370
    ReplaceInString( aPtrTag, spXML61, sp61 );
hgs
parents:
diff changeset
  1371
    _LIT16( spXML62, "&Uacute;" );
hgs
parents:
diff changeset
  1372
    _LIT16( sp62, "\u00da" );
hgs
parents:
diff changeset
  1373
    ReplaceInString( aPtrTag, spXML62, sp62 );
hgs
parents:
diff changeset
  1374
    _LIT16( spXML63, "&Ucirc;" );
hgs
parents:
diff changeset
  1375
    _LIT16( sp63, "\u00db" );
hgs
parents:
diff changeset
  1376
    ReplaceInString( aPtrTag, spXML63, sp63 );
hgs
parents:
diff changeset
  1377
    _LIT16( spXML64, "&Uuml;" );
hgs
parents:
diff changeset
  1378
    _LIT16( sp64, "\u00dc" );
hgs
parents:
diff changeset
  1379
    ReplaceInString( aPtrTag, spXML64, sp64 );
hgs
parents:
diff changeset
  1380
    _LIT16( spXML65, "&Yacute;" );
hgs
parents:
diff changeset
  1381
    _LIT16( sp65, "\u00dd" );
hgs
parents:
diff changeset
  1382
    ReplaceInString( aPtrTag, spXML65, sp65 );
hgs
parents:
diff changeset
  1383
    _LIT16( spXML66, "&THORN;" );
hgs
parents:
diff changeset
  1384
    _LIT16( sp66, "\u00de" );
hgs
parents:
diff changeset
  1385
    ReplaceInString( aPtrTag, spXML66, sp66 );
hgs
parents:
diff changeset
  1386
    _LIT16( spXML67, "&szlig;" );
hgs
parents:
diff changeset
  1387
    _LIT16( sp67, "\u00df" );
hgs
parents:
diff changeset
  1388
    ReplaceInString( aPtrTag, spXML67, sp67 );
hgs
parents:
diff changeset
  1389
    _LIT16( spXML68, "&agrave;" );
hgs
parents:
diff changeset
  1390
    _LIT16( sp68, "\u00e0" );
hgs
parents:
diff changeset
  1391
    ReplaceInString( aPtrTag, spXML68, sp68 );
hgs
parents:
diff changeset
  1392
    _LIT16( spXML69, "&aacute;" );
hgs
parents:
diff changeset
  1393
    _LIT16( sp69, "\u00e1" );
hgs
parents:
diff changeset
  1394
    ReplaceInString( aPtrTag, spXML69, sp69 );
hgs
parents:
diff changeset
  1395
    _LIT16( spXML70, "&acirc;" );
hgs
parents:
diff changeset
  1396
    _LIT16( sp70, "\u00e2" );
hgs
parents:
diff changeset
  1397
    ReplaceInString( aPtrTag, spXML70, sp70 );
hgs
parents:
diff changeset
  1398
    _LIT16( spXML71, "&atilde;" );
hgs
parents:
diff changeset
  1399
    _LIT16( sp71, "\u00e3" );
hgs
parents:
diff changeset
  1400
    ReplaceInString( aPtrTag, spXML71, sp71 );
hgs
parents:
diff changeset
  1401
    _LIT16( spXML72, "&auml;");
hgs
parents:
diff changeset
  1402
    _LIT16( sp72, "\u00e4" );
hgs
parents:
diff changeset
  1403
    ReplaceInString( aPtrTag, spXML72, sp72 );
hgs
parents:
diff changeset
  1404
    _LIT16( spXML73, "&aring;" );
hgs
parents:
diff changeset
  1405
    _LIT16( sp73, "\u00e5" );
hgs
parents:
diff changeset
  1406
    ReplaceInString( aPtrTag, spXML73, sp73 );
hgs
parents:
diff changeset
  1407
    _LIT16( spXML74, "&aelig;" );
hgs
parents:
diff changeset
  1408
    _LIT16( sp74, "\u00e6" );
hgs
parents:
diff changeset
  1409
    ReplaceInString( aPtrTag, spXML74, sp74 );
hgs
parents:
diff changeset
  1410
    _LIT16( spXML75, "&acedil;" );
hgs
parents:
diff changeset
  1411
    _LIT16( sp75, "\u00e7" );
hgs
parents:
diff changeset
  1412
    ReplaceInString( aPtrTag, spXML75, sp75 );
hgs
parents:
diff changeset
  1413
    _LIT16( spXML76, "&egrave;" );
hgs
parents:
diff changeset
  1414
    _LIT16( sp76, "\u00e8" );
hgs
parents:
diff changeset
  1415
    ReplaceInString( aPtrTag, spXML76, sp76 );
hgs
parents:
diff changeset
  1416
    _LIT16( spXML77, "&eacute;" );
hgs
parents:
diff changeset
  1417
    _LIT16( sp77, "\u00e9" );
hgs
parents:
diff changeset
  1418
    ReplaceInString( aPtrTag, spXML77, sp77 );
hgs
parents:
diff changeset
  1419
    _LIT16( spXML78, "&ecirc;" );
hgs
parents:
diff changeset
  1420
    _LIT16( sp78, "\u00ea" );
hgs
parents:
diff changeset
  1421
    ReplaceInString( aPtrTag, spXML78, sp78 );
hgs
parents:
diff changeset
  1422
    _LIT16( spXML79, "&euml;" );
hgs
parents:
diff changeset
  1423
    _LIT16( sp79, "\u00eb" );
hgs
parents:
diff changeset
  1424
    ReplaceInString( aPtrTag, spXML79, sp79 );
hgs
parents:
diff changeset
  1425
    _LIT16( spXML80, "&igrave;" );
hgs
parents:
diff changeset
  1426
    _LIT16( sp80, "\u00ec" );
hgs
parents:
diff changeset
  1427
    ReplaceInString( aPtrTag, spXML80, sp80 );
hgs
parents:
diff changeset
  1428
    _LIT16( spXML81, "&iacute;" );
hgs
parents:
diff changeset
  1429
    _LIT16( sp81, "\u00ed" );
hgs
parents:
diff changeset
  1430
    ReplaceInString( aPtrTag, spXML81, sp81 );
hgs
parents:
diff changeset
  1431
    _LIT16( spXML82, "&icirc;" );
hgs
parents:
diff changeset
  1432
    _LIT16( sp82, "\u00ee" );
hgs
parents:
diff changeset
  1433
    ReplaceInString( aPtrTag, spXML82, sp82 );
hgs
parents:
diff changeset
  1434
    _LIT16( spXML83, "&iuml;" );
hgs
parents:
diff changeset
  1435
    _LIT16( sp83, "\u00ef" );
hgs
parents:
diff changeset
  1436
    ReplaceInString( aPtrTag, spXML83, sp83 );
hgs
parents:
diff changeset
  1437
    _LIT16( spXML84, "&eth;" );
hgs
parents:
diff changeset
  1438
    _LIT16( sp84, "\u00f0" );
hgs
parents:
diff changeset
  1439
    ReplaceInString( aPtrTag, spXML84, sp84 );
hgs
parents:
diff changeset
  1440
    _LIT16( spXML85, "&ntilde;" );
hgs
parents:
diff changeset
  1441
    _LIT16( sp85, "\u00f1" );
hgs
parents:
diff changeset
  1442
    ReplaceInString( aPtrTag, spXML85, sp85 );
hgs
parents:
diff changeset
  1443
    _LIT16( spXML86, "&ograve;" );
hgs
parents:
diff changeset
  1444
    _LIT16( sp86, "\u00f2" );
hgs
parents:
diff changeset
  1445
    ReplaceInString( aPtrTag, spXML86, sp86 );
hgs
parents:
diff changeset
  1446
    _LIT16( spXML87, "&oacute;" );
hgs
parents:
diff changeset
  1447
    _LIT16( sp87, "\u00f3" );
hgs
parents:
diff changeset
  1448
    ReplaceInString( aPtrTag, spXML87, sp87 );
hgs
parents:
diff changeset
  1449
    _LIT16( spXML88, "&ocirc;" );
hgs
parents:
diff changeset
  1450
    _LIT16( sp88, "\u00f4" );
hgs
parents:
diff changeset
  1451
    ReplaceInString( aPtrTag, spXML88, sp88 );
hgs
parents:
diff changeset
  1452
    _LIT16( spXML89, "&otilde;" );
hgs
parents:
diff changeset
  1453
    _LIT16( sp89, "\u00f5" );
hgs
parents:
diff changeset
  1454
    ReplaceInString( aPtrTag, spXML89, sp89 );
hgs
parents:
diff changeset
  1455
    _LIT16( spXML90, "&ouml;" );
hgs
parents:
diff changeset
  1456
    _LIT16( sp90, "\u00f6" );
hgs
parents:
diff changeset
  1457
    ReplaceInString( aPtrTag, spXML90, sp90 );
hgs
parents:
diff changeset
  1458
    _LIT16( spXML91, "&divide;" );
hgs
parents:
diff changeset
  1459
    _LIT16( sp91, "\u00f7" );
hgs
parents:
diff changeset
  1460
    ReplaceInString( aPtrTag, spXML91, sp91 );
hgs
parents:
diff changeset
  1461
    _LIT16( spXML92, "&oslash;" );
hgs
parents:
diff changeset
  1462
    _LIT16( sp92, "\u00f8" );
hgs
parents:
diff changeset
  1463
    ReplaceInString( aPtrTag, spXML92, sp92 );
hgs
parents:
diff changeset
  1464
    _LIT16( spXML93, "&ugrave;" );
hgs
parents:
diff changeset
  1465
    _LIT16( sp93, "\u00f9" );
hgs
parents:
diff changeset
  1466
    ReplaceInString( aPtrTag, spXML93, sp93 );
hgs
parents:
diff changeset
  1467
    _LIT16( spXML94, "&uacute;" );
hgs
parents:
diff changeset
  1468
    _LIT16( sp94, "\u00fa" );
hgs
parents:
diff changeset
  1469
    ReplaceInString( aPtrTag, spXML94, sp94 );
hgs
parents:
diff changeset
  1470
    _LIT16( spXML95, "&ucirc;" );
hgs
parents:
diff changeset
  1471
    _LIT16( sp95, "\u00fb" );
hgs
parents:
diff changeset
  1472
    ReplaceInString( aPtrTag, spXML95, sp95 );
hgs
parents:
diff changeset
  1473
    _LIT16( spXML96, "&uuml;" );
hgs
parents:
diff changeset
  1474
    _LIT16( sp96, "\u00fc" );
hgs
parents:
diff changeset
  1475
    ReplaceInString( aPtrTag, spXML96, sp96 );
hgs
parents:
diff changeset
  1476
    _LIT16( spXML97, "&yacute;" );
hgs
parents:
diff changeset
  1477
    _LIT16( sp97, "\u00fd" );
hgs
parents:
diff changeset
  1478
    ReplaceInString( aPtrTag, spXML97, sp97 );
hgs
parents:
diff changeset
  1479
    _LIT16( spXML98, "&thorn;" );
hgs
parents:
diff changeset
  1480
    _LIT16( sp98, "\u00de" );
hgs
parents:
diff changeset
  1481
    ReplaceInString( aPtrTag, spXML98, sp98 );
hgs
parents:
diff changeset
  1482
    _LIT16( spXML99, "&yuml;" );
hgs
parents:
diff changeset
  1483
    _LIT16( sp99, "\u00ff" );
hgs
parents:
diff changeset
  1484
    ReplaceInString( aPtrTag, spXML99, sp99 );
hgs
parents:
diff changeset
  1485
    _LIT16( spXML100, "&OElig;" );
hgs
parents:
diff changeset
  1486
    _LIT16( sp100, "\u0152" );
hgs
parents:
diff changeset
  1487
    ReplaceInString( aPtrTag, spXML100, sp100 );
hgs
parents:
diff changeset
  1488
    _LIT16( spXML101, "&oelig;" );
hgs
parents:
diff changeset
  1489
    _LIT16( sp101, "\u0153" );
hgs
parents:
diff changeset
  1490
    ReplaceInString( aPtrTag, spXML101, sp101 );
hgs
parents:
diff changeset
  1491
    _LIT16( spXML102, "&Scaron;" );
hgs
parents:
diff changeset
  1492
    _LIT16( sp102, "\u0160" );
hgs
parents:
diff changeset
  1493
    ReplaceInString( aPtrTag, spXML102, sp102 );
hgs
parents:
diff changeset
  1494
    _LIT16( spXML103, "&scaron;" );
hgs
parents:
diff changeset
  1495
    _LIT16( sp103, "\u0161" );
hgs
parents:
diff changeset
  1496
    ReplaceInString( aPtrTag, spXML103, sp103 );
hgs
parents:
diff changeset
  1497
    _LIT16( spXML104, "&Yuml;" );
hgs
parents:
diff changeset
  1498
    _LIT16( sp104, "\u0178" );
hgs
parents:
diff changeset
  1499
    ReplaceInString( aPtrTag, spXML104, sp104 );
hgs
parents:
diff changeset
  1500
    _LIT16( spXML105, "&fnof;" );
hgs
parents:
diff changeset
  1501
    _LIT16( sp105, "\u0192" );
hgs
parents:
diff changeset
  1502
    ReplaceInString( aPtrTag, spXML105, sp105 );
hgs
parents:
diff changeset
  1503
    _LIT16( spXML106, "&circ;" );
hgs
parents:
diff changeset
  1504
    _LIT16( sp106, "\u02c6" );
hgs
parents:
diff changeset
  1505
    ReplaceInString( aPtrTag, spXML106, sp106 );
hgs
parents:
diff changeset
  1506
    _LIT16( spXML107, "&tilde;" );
hgs
parents:
diff changeset
  1507
    _LIT16( sp107, "\u02dc" );
hgs
parents:
diff changeset
  1508
    ReplaceInString( aPtrTag, spXML107, sp107 );
hgs
parents:
diff changeset
  1509
    }
hgs
parents:
diff changeset
  1510
hgs
parents:
diff changeset
  1511
// ---------------------------------------------------------
hgs
parents:
diff changeset
  1512
// CReaderXML::Replace
hgs
parents:
diff changeset
  1513
// ---------------------------------------------------------
hgs
parents:
diff changeset
  1514
//
hgs
parents:
diff changeset
  1515
void CReaderXML::ReplaceInString(   HBufC* aPtrTag, 
hgs
parents:
diff changeset
  1516
                                const TDesC& aSpXML, 
hgs
parents:
diff changeset
  1517
                                const TDesC& aSp )
hgs
parents:
diff changeset
  1518
    {
hgs
parents:
diff changeset
  1519
        if( aPtrTag == NULL )
hgs
parents:
diff changeset
  1520
        {
hgs
parents:
diff changeset
  1521
            return;
hgs
parents:
diff changeset
  1522
        }
hgs
parents:
diff changeset
  1523
    TInt strPos = aPtrTag->Des().Find(aSpXML);
hgs
parents:
diff changeset
  1524
    while ( strPos != KErrNotFound )
hgs
parents:
diff changeset
  1525
        {
hgs
parents:
diff changeset
  1526
        aPtrTag->Des().Replace(strPos, aSpXML.Length() , aSp);
hgs
parents:
diff changeset
  1527
        strPos = aPtrTag->Des().Find(aSpXML);     
hgs
parents:
diff changeset
  1528
        }
hgs
parents:
diff changeset
  1529
    }   
hgs
parents:
diff changeset
  1530
hgs
parents:
diff changeset
  1531
//maximum number of VPN AP parameters
hgs
parents:
diff changeset
  1532
hgs
parents:
diff changeset
  1533
hgs
parents:
diff changeset
  1534
void CReaderXML::FillPacketDataParams()    
hgs
parents:
diff changeset
  1535
    {
hgs
parents:
diff changeset
  1536
    iPDParams.Append( EInputParams( ECmName,                          KConnectionName ) );
hgs
parents:
diff changeset
  1537
    iPDParams.Append( EInputParams( ECmId,                            KConnectionId ) );
hgs
parents:
diff changeset
  1538
    iPDParams.Append( EInputParams( ECmProtected,                     KProtected ) );
hgs
parents:
diff changeset
  1539
    iPDParams.Append( EInputParams( ECmHidden,                        KHidden ) );
hgs
parents:
diff changeset
  1540
    iPDParams.Append( EInputParams( ECmMetaHiddenAgent,               KHiddenAgent ) );
hgs
parents:
diff changeset
  1541
    iPDParams.Append( EInputParams( ECmMetaHighlight,                 KHighlighted ) );
hgs
parents:
diff changeset
  1542
    iPDParams.Append( EInputParams( ECmSeamlessnessLevel,             KSeamlessness ) );
hgs
parents:
diff changeset
  1543
    iPDParams.Append( EInputParams( EPacketDataAPName,                KGprs_AP_Name ) );
hgs
parents:
diff changeset
  1544
    iPDParams.Append( EInputParams( EPacketDataIFAuthName,            KUserName ) );
hgs
parents:
diff changeset
  1545
    iPDParams.Append( EInputParams( EPacketDataIFPromptForAuth,       KPromptPassword ) );
hgs
parents:
diff changeset
  1546
    iPDParams.Append( EInputParams( EPacketDataIFAuthPass,            KPassword ) );
hgs
parents:
diff changeset
  1547
    iPDParams.Append( EInputParams( EPacketDataDisablePlainTextAuth,  KPasswordAuthType ) );
hgs
parents:
diff changeset
  1548
    iPDParams.Append( EInputParams( ECmWapIPGatewayAddress,           KWAPGatewayIP ) );
hgs
parents:
diff changeset
  1549
    iPDParams.Append( EInputParams( ECmStartPage,                     KStartingPage ) );
hgs
parents:
diff changeset
  1550
    iPDParams.Append( EInputParams( ECmWapIPSecurity,                 KWTLS_Security ) );
hgs
parents:
diff changeset
  1551
    iPDParams.Append( EInputParams( ECmWapIPWSPOption,                KWAP_ConnectionType ) );
hgs
parents:
diff changeset
  1552
    iPDParams.Append( EInputParams( EPacketDataIPAddr,                KPhoneIP ) );
hgs
parents:
diff changeset
  1553
    iPDParams.Append( EInputParams( EPacketDataIPNameServer1,         KPrimaryNameServer ) );
hgs
parents:
diff changeset
  1554
    iPDParams.Append( EInputParams( EPacketDataIPNameServer2,         KSecondaryNameServer ) );
hgs
parents:
diff changeset
  1555
    iPDParams.Append( EInputParams( ECmProxyServerName,               KProxyServerAddress ) );
hgs
parents:
diff changeset
  1556
    iPDParams.Append( EInputParams( ECmProxyPortNumber,               KProxyPortNumber ) );
hgs
parents:
diff changeset
  1557
    iPDParams.Append( EInputParams( ECmProxyProtocolName,             KProxyProtocolName ) );
hgs
parents:
diff changeset
  1558
    iPDParams.Append( EInputParams( EPacketDataIPIP6NameServer1,      KPrimaryIP6NameServer ) );
hgs
parents:
diff changeset
  1559
    iPDParams.Append( EInputParams( EPacketDataIPIP6NameServer2,      KSecondaryIP6NameServer ) );
hgs
parents:
diff changeset
  1560
    iPDParams.Append( EInputParams( EPacketDataApType,                KIspType ) );
hgs
parents:
diff changeset
  1561
    iPDParams.Append( EInputParams( EPacketDataPDPType,               KNetworkType ) );
hgs
parents:
diff changeset
  1562
    iPDParams.Append( EInputParams( EPacketDataUseEdge,               KGprsUseEdge ) );
hgs
parents:
diff changeset
  1563
    iPDParams.Append( EInputParams( EPacketDataLinger,                KLinger ) );
hgs
parents:
diff changeset
  1564
    };
hgs
parents:
diff changeset
  1565
hgs
parents:
diff changeset
  1566
void CReaderXML::FillLanParams()    
hgs
parents:
diff changeset
  1567
    {
hgs
parents:
diff changeset
  1568
    iLanParams.Append( EInputParams( ECmName,                           KConnectionName ) );
hgs
parents:
diff changeset
  1569
    iLanParams.Append( EInputParams( ECmId,                             KConnectionId ) );
hgs
parents:
diff changeset
  1570
    iLanParams.Append( EInputParams( ECmProtected,                      KProtected ) );
hgs
parents:
diff changeset
  1571
    iLanParams.Append( EInputParams( ECmHidden,                         KHidden ) );
hgs
parents:
diff changeset
  1572
    iLanParams.Append( EInputParams( ECmMetaHiddenAgent,                KHiddenAgent ) );
hgs
parents:
diff changeset
  1573
    iLanParams.Append( EInputParams( ECmMetaHighlight,                  KHighlighted ) );
hgs
parents:
diff changeset
  1574
    iLanParams.Append( EInputParams( ECmSeamlessnessLevel,              KSeamlessness ) );
hgs
parents:
diff changeset
  1575
    iLanParams.Append( EInputParams( ECmWapIPGatewayAddress,            KWAPGatewayIP ) );
hgs
parents:
diff changeset
  1576
    iLanParams.Append( EInputParams( ECmStartPage,                      KStartingPage ) );
hgs
parents:
diff changeset
  1577
    iLanParams.Append( EInputParams( ECmWapIPSecurity,                  KWTLS_Security ) );
hgs
parents:
diff changeset
  1578
    iLanParams.Append( EInputParams( ECmWapIPWSPOption,                 KWAP_ConnectionType ) );
hgs
parents:
diff changeset
  1579
    iLanParams.Append( EInputParams( ECmProxyServerName,                KProxyServerAddress ) );
hgs
parents:
diff changeset
  1580
    iLanParams.Append( EInputParams( ECmProxyPortNumber,                KProxyPortNumber ) );
hgs
parents:
diff changeset
  1581
    iLanParams.Append( EInputParams( ECmProxyProtocolName,              KProxyProtocolName ) );
hgs
parents:
diff changeset
  1582
    iLanParams.Append( EInputParams( ELanIfNetworks,                    KLanIfNetworks ) );
hgs
parents:
diff changeset
  1583
    iLanParams.Append( EInputParams( ELanIpNetMask,                     KLanIpNetMask ) );
hgs
parents:
diff changeset
  1584
    iLanParams.Append( EInputParams( ELanIpGateway,                     KLanIpGateway ) );
hgs
parents:
diff changeset
  1585
    iLanParams.Append( EInputParams( ELanIpAddr,                        KPhoneIP ) );
hgs
parents:
diff changeset
  1586
    iLanParams.Append( EInputParams( ELanIpNameServer1,                 KPrimaryNameServer ) );
hgs
parents:
diff changeset
  1587
    iLanParams.Append( EInputParams( ELanIpNameServer2,                 KSecondaryNameServer ) );
hgs
parents:
diff changeset
  1588
    iLanParams.Append( EInputParams( ELanIp6NameServer1,                KPrimaryIP6NameServer ) );
hgs
parents:
diff changeset
  1589
    iLanParams.Append( EInputParams( ELanIp6NameServer2,                KSecondaryIP6NameServer ) );
hgs
parents:
diff changeset
  1590
    iLanParams.Append( EInputParams( ELanIpAddrFromServer,              KLanIpAddrFromServer ) );
hgs
parents:
diff changeset
  1591
    iLanParams.Append( EInputParams( ELanIpDNSAddrFromServer,           KLanIpDNSAddrFromServer ) );
hgs
parents:
diff changeset
  1592
    iLanParams.Append( EInputParams( ELanConfigDaemonManagerName,       KLanConfigDaemonManagerName ) );
hgs
parents:
diff changeset
  1593
    iLanParams.Append( EInputParams( ELanConfigDaemonName,              KLanConfigDaemonName ) );
hgs
parents:
diff changeset
  1594
    };
hgs
parents:
diff changeset
  1595
    
hgs
parents:
diff changeset
  1596
//Binds WLAN access point parameters to field IDs
hgs
parents:
diff changeset
  1597
void CReaderXML::FillWLanParams()    
hgs
parents:
diff changeset
  1598
    {        
hgs
parents:
diff changeset
  1599
    iWLanParams.Append( EInputParams( ECmName,                      KConnectionName ) );
hgs
parents:
diff changeset
  1600
    iWLanParams.Append( EInputParams( ECmId,                        KConnectionId ) );
hgs
parents:
diff changeset
  1601
    iWLanParams.Append( EInputParams( ECmProtected,                 KProtected ) );
hgs
parents:
diff changeset
  1602
    iWLanParams.Append( EInputParams( ECmHidden,                    KHidden ) );
hgs
parents:
diff changeset
  1603
    iWLanParams.Append( EInputParams( ECmMetaHiddenAgent,           KHiddenAgent ) );
hgs
parents:
diff changeset
  1604
    iWLanParams.Append( EInputParams( ECmMetaHighlight,             KHighlighted ) );
hgs
parents:
diff changeset
  1605
    iWLanParams.Append( EInputParams( ECmSeamlessnessLevel,         KSeamlessness ) );
hgs
parents:
diff changeset
  1606
    iWLanParams.Append( EInputParams( ECmStartPage,                 KStartingPage ) );
hgs
parents:
diff changeset
  1607
    iWLanParams.Append( EInputParams( EWlanSSID,                    KNetworkName ) );
hgs
parents:
diff changeset
  1608
    iWLanParams.Append( EInputParams( EWlanConnectionMode,          KNetworkMode ) );
hgs
parents:
diff changeset
  1609
    iWLanParams.Append( EInputParams( EWlanSecurityMode,            KSecurityMode ) );
hgs
parents:
diff changeset
  1610
    iWLanParams.Append( EInputParams( EWlanIpNameServer1,           KPrimaryNameServer ) );
hgs
parents:
diff changeset
  1611
    iWLanParams.Append( EInputParams( EWlanIpNameServer2,           KSecondaryNameServer ) );
hgs
parents:
diff changeset
  1612
    iWLanParams.Append( EInputParams( EWlanIp6NameServer1,          KPrimaryIP6NameServer ) );
hgs
parents:
diff changeset
  1613
    iWLanParams.Append( EInputParams( EWlanIp6NameServer2,          KSecondaryIP6NameServer ) );
hgs
parents:
diff changeset
  1614
    iWLanParams.Append( EInputParams( EWlanIpGateway,               KWlanIpGatewayAddress ) );
hgs
parents:
diff changeset
  1615
    iWLanParams.Append( EInputParams( ECmProxyServerName,           KProxyServerAddress ) );
hgs
parents:
diff changeset
  1616
    iWLanParams.Append( EInputParams( ECmProxyProtocolName,         KProxyProtocolName ) );
hgs
parents:
diff changeset
  1617
    iWLanParams.Append( EInputParams( EWlanIpNetMask,               KWlanIpNetMask ) );
hgs
parents:
diff changeset
  1618
    iWLanParams.Append( EInputParams( ECmProxyPortNumber,           KProxyPortNumber ) );
hgs
parents:
diff changeset
  1619
    iWLanParams.Append( EInputParams( EWlanIpAddr,                  KPhoneIP ) ); 
hgs
parents:
diff changeset
  1620
    iWLanParams.Append( EInputParams( EWlanScanSSID,                KWlanScanSSId ) );
hgs
parents:
diff changeset
  1621
    iWLanParams.Append( EInputParams( EWlanChannelID,               KWlanChannelId ) );
hgs
parents:
diff changeset
  1622
    iWLanParams.Append( EInputParams( EWEPKeyInUse,                 KWEPKeyInUse ) );
hgs
parents:
diff changeset
  1623
    iWLanParams.Append( EInputParams( EWEPAuthType,                 KWEPAuthType ) );
hgs
parents:
diff changeset
  1624
    iWLanParams.Append( EInputParams( EWEPKey1Length,               KWEPKey1Length ) );
hgs
parents:
diff changeset
  1625
    iWLanParams.Append( EInputParams( EWEPKey1Format,               KWEPKey1Format ) );
hgs
parents:
diff changeset
  1626
    iWLanParams.Append( EInputParams( EWEPKey1Data,                 KWEPKey1Data ) );
hgs
parents:
diff changeset
  1627
    iWLanParams.Append( EInputParams( EWEPKey2Length,               KWEPKey2Length ) );
hgs
parents:
diff changeset
  1628
    iWLanParams.Append( EInputParams( EWEPKey2Format,               KWEPKey2Format ) );
hgs
parents:
diff changeset
  1629
    iWLanParams.Append( EInputParams( EWEPKey2Data,                 KWEPKey2Data ) );
hgs
parents:
diff changeset
  1630
    iWLanParams.Append( EInputParams( EWEPKey3Length,               KWEPKey3Length ) );
hgs
parents:
diff changeset
  1631
    iWLanParams.Append( EInputParams( EWEPKey3Format,               KWEPKey3Format ) );
hgs
parents:
diff changeset
  1632
    iWLanParams.Append( EInputParams( EWEPKey3Data,                 KWEPKey3Data ) );
hgs
parents:
diff changeset
  1633
    iWLanParams.Append( EInputParams( EWEPKey4Length,               KWEPKey4Length ) );
hgs
parents:
diff changeset
  1634
    iWLanParams.Append( EInputParams( EWEPKey4Format,               KWEPKey4Format ) );
hgs
parents:
diff changeset
  1635
    iWLanParams.Append( EInputParams( EWEPKey4Data,                 KWEPKey4Data ) );
hgs
parents:
diff changeset
  1636
    iWLanParams.Append( EInputParams( EWPAPresharedKey,             KWPAPresharedKey ) );
hgs
parents:
diff changeset
  1637
    iWLanParams.Append( EInputParams( EWPAKeyLength,                KWPAKeyLength ) );
hgs
parents:
diff changeset
  1638
    iWLanParams.Append( EInputParams( EWPAEapMethod,                KWPAEapMethod ) );
hgs
parents:
diff changeset
  1639
    iWLanParams.Append( EInputParams( EWPAUseOfPresharedKey,        KWPAUseOfPresharedKey ) );
hgs
parents:
diff changeset
  1640
    iWLanParams.Append( EInputParams( EEapGtcUsername,              KEapGtcUsername ) );
hgs
parents:
diff changeset
  1641
    iWLanParams.Append( EInputParams( EEapGtcSessionValidityTime,   KEapGtcSessionValidityTime ) );
hgs
parents:
diff changeset
  1642
    iWLanParams.Append( EInputParams( EEapGtcEncapsulation,         KEapGtcEncapsulation ) );
hgs
parents:
diff changeset
  1643
    iWLanParams.Append( EInputParams( EEapTlsUsername,              KEapTlsUsername ) );
hgs
parents:
diff changeset
  1644
    iWLanParams.Append( EInputParams( EEapTlsRealm,                 KEapTlsRealm ) );
hgs
parents:
diff changeset
  1645
    iWLanParams.Append( EInputParams( EEapTlsVerifyServerRealm,     KEapTlsVerifyServerRealm ) );
hgs
parents:
diff changeset
  1646
    iWLanParams.Append( EInputParams( EEapTlsRequireClientAuth,     KEapTlsRequireClientAuth ) );
hgs
parents:
diff changeset
  1647
    iWLanParams.Append( EInputParams( EEapTlsSessionValidityTime,   KEapTlsSessionValidityTime ) );
hgs
parents:
diff changeset
  1648
    iWLanParams.Append( EInputParams( EEapTlsCipherSuites,          KEapTlsCipherSuites ) );
hgs
parents:
diff changeset
  1649
    iWLanParams.Append( EInputParams( EEapTlsUserCertSubjectKeyId,  KEapTlsUserCertSubjectKeyId ) );
hgs
parents:
diff changeset
  1650
    iWLanParams.Append( EInputParams( EEapTlsUserCertIssuerName,    KEapTlsUserCertIssuerName ) );
hgs
parents:
diff changeset
  1651
    iWLanParams.Append( EInputParams( EEapTlsUserCertSerialNumber,  KEapTlsUserCertSerialNumber ) );
hgs
parents:
diff changeset
  1652
    iWLanParams.Append( EInputParams( EEapTlsCaCertSubjectKeyId,    KEapTlsCaCertSubjectKeyId ) );
hgs
parents:
diff changeset
  1653
    iWLanParams.Append( EInputParams( EEapTlsCaCertIssuerName,      KEapTlsCaCertIssuerName ) );
hgs
parents:
diff changeset
  1654
    iWLanParams.Append( EInputParams( EEapTlsCaCertSerialNumber,    KEapTlsCaCertSerialNumber ) );
hgs
parents:
diff changeset
  1655
    iWLanParams.Append( EInputParams( EEapTlsEncapsulation,         KEapTlsEncapsulation ) );
hgs
parents:
diff changeset
  1656
    iWLanParams.Append( EInputParams( EEapLeapUsername,             KEapLeapUsername ) );
hgs
parents:
diff changeset
  1657
    iWLanParams.Append( EInputParams( EEapLeapPassword,             KEapLeapPassword ) );
hgs
parents:
diff changeset
  1658
    iWLanParams.Append( EInputParams( EEapLeapSessionValidityTime,  KEapLeapSessionValidityTime ) );
hgs
parents:
diff changeset
  1659
    iWLanParams.Append( EInputParams( EEapSimUsername,              KEapSimUsername ) );
hgs
parents:
diff changeset
  1660
    iWLanParams.Append( EInputParams( EEapSimRealm,                 KEapSimRealm ) );
hgs
parents:
diff changeset
  1661
    iWLanParams.Append( EInputParams( EEapSimUsePseudonyms,         KEapSimUsePseudonyms ) );
hgs
parents:
diff changeset
  1662
    iWLanParams.Append( EInputParams( EEapSimSessionValidityTime,   KEapSimSessionValidityTime ) );
hgs
parents:
diff changeset
  1663
    iWLanParams.Append( EInputParams( EEapSimEncapsulation,         KEapSimEncapsulation ) );
hgs
parents:
diff changeset
  1664
    iWLanParams.Append( EInputParams( EEapTtlsUsername,             KEapTtlsUsername ) );
hgs
parents:
diff changeset
  1665
    iWLanParams.Append( EInputParams( EEapTtlsRealm,                KEapTtlsRealm ) );
hgs
parents:
diff changeset
  1666
    iWLanParams.Append( EInputParams( EEapTtlsVerifyServerRealm,    KEapTtlsVerifyServerRealm ) );
hgs
parents:
diff changeset
  1667
    iWLanParams.Append( EInputParams( EEapTtlsRequireClientAuth,    KEapTtlsRequireClientAuth ) );
hgs
parents:
diff changeset
  1668
    iWLanParams.Append( EInputParams( EEapTtlsSessionValidityTime,  KEapTtlsSessionValidityTime ) );
hgs
parents:
diff changeset
  1669
    iWLanParams.Append( EInputParams( EEapTtlsCipherSuites,         KEapTtlsCipherSuites ) );
hgs
parents:
diff changeset
  1670
    iWLanParams.Append( EInputParams( EEapTtlsEncapsulatedTypes,    KEapTtlsEncapsulatedTypes ) );
hgs
parents:
diff changeset
  1671
    iWLanParams.Append( EInputParams( EEapTtlsUserCertSubjectKeyId, KEapTtlsUserCertSubjectKeyId ) );
hgs
parents:
diff changeset
  1672
    iWLanParams.Append( EInputParams( EEapTtlsUserCertIssuerName,   KEapTtlsUserCertIssuerName ) );
hgs
parents:
diff changeset
  1673
    iWLanParams.Append( EInputParams( EEapTtlsUserCertSerialNumber, KEapTtlsUserCertSerialNumber ) );
hgs
parents:
diff changeset
  1674
    iWLanParams.Append( EInputParams( EEapTtlsCaCertSubjectKeyId,   KEapTtlsCaCertSubjectKeyId ) );
hgs
parents:
diff changeset
  1675
    iWLanParams.Append( EInputParams( EEapTtlsCaCertIssuerName,     KEapTtlsCaCertIssuerName ) );
hgs
parents:
diff changeset
  1676
    iWLanParams.Append( EInputParams( EEapTtlsCaCertSerialNumber,   KEapTtlsCaCertSerialNumber ) );
hgs
parents:
diff changeset
  1677
    iWLanParams.Append( EInputParams( EEapAkaUsername,              KEapAkaUsername ) );
hgs
parents:
diff changeset
  1678
    iWLanParams.Append( EInputParams( EEapAkaRealm,                 KEapAkaRealm ) );
hgs
parents:
diff changeset
  1679
    iWLanParams.Append( EInputParams( EEapAkaUsePseudonyms,         KEapAkaUsePseudonyms ) );
hgs
parents:
diff changeset
  1680
    iWLanParams.Append( EInputParams( EEapAkaSessionValidityTime,   KEapAkaSessionValidityTime ) );
hgs
parents:
diff changeset
  1681
    iWLanParams.Append( EInputParams( EEapAkaEncapsulation,         KEapAkaEncapsulation ) );
hgs
parents:
diff changeset
  1682
    iWLanParams.Append( EInputParams( EEapPeapUsername,             KEapPeapUsername ) );
hgs
parents:
diff changeset
  1683
    iWLanParams.Append( EInputParams( EEapPeapRealm,                KEapPeapRealm ) );
hgs
parents:
diff changeset
  1684
    iWLanParams.Append( EInputParams( EEapPeapVerifyServerRealm,    KEapPeapVerifyServerRealm ) );
hgs
parents:
diff changeset
  1685
    iWLanParams.Append( EInputParams( EEapPeapRequireClientAuth,    KEapPeapRequireClientAuth ) );
hgs
parents:
diff changeset
  1686
    iWLanParams.Append( EInputParams( EEapPeapSessionValidityTime,  KEapPeapSessionValidityTime ) );
hgs
parents:
diff changeset
  1687
    iWLanParams.Append( EInputParams( EEapPeapCipherSuites,         KEapPeapCipherSuites ) );
hgs
parents:
diff changeset
  1688
    iWLanParams.Append( EInputParams( EEapPeapV0Allowed,            KEapPeapV0Allowed ) );
hgs
parents:
diff changeset
  1689
    iWLanParams.Append( EInputParams( EEapPeapV1Allowed,            KEapPeapV1Allowed ) );
hgs
parents:
diff changeset
  1690
    iWLanParams.Append( EInputParams( EEapPeapV2Allowed,            KEapPeapV2Allowed ) );
hgs
parents:
diff changeset
  1691
    iWLanParams.Append( EInputParams( EEapPeapEncapsulatedTypes,    KEapPeapEncapsulatedTypes ) );
hgs
parents:
diff changeset
  1692
    iWLanParams.Append( EInputParams( EEapPeapUserCertSubjectKeyId, KEapPeapUserCertSubjectKeyId ) );
hgs
parents:
diff changeset
  1693
    iWLanParams.Append( EInputParams( EEapPeapUserCertIssuerName,   KEapPeapUserCertIssuerName ) );
hgs
parents:
diff changeset
  1694
    iWLanParams.Append( EInputParams( EEapPeapUserCertSerialNumber, KEapPeapUserCertSerialNumber ) );
hgs
parents:
diff changeset
  1695
    iWLanParams.Append( EInputParams( EEapPeapCaCertSubjectKeyId,   KEapPeapCaCertSubjectKeyId ) );
hgs
parents:
diff changeset
  1696
    iWLanParams.Append( EInputParams( EEapPeapCaCertIssuerName,     KEapPeapCaCertIssuerName ) );
hgs
parents:
diff changeset
  1697
    iWLanParams.Append( EInputParams( EEapPeapCaCertSerialNumber,   KEapPeapCaCertSerialNumber ) );
hgs
parents:
diff changeset
  1698
    iWLanParams.Append( EInputParams( EEapMschapv2Username,         KEapMschapv2Username ) );
hgs
parents:
diff changeset
  1699
    iWLanParams.Append( EInputParams( EEapMschapv2Password,         KEapMschapv2Password ) );
hgs
parents:
diff changeset
  1700
    iWLanParams.Append( EInputParams( EEapMschapv2SessionValidityTime, KEapMschapv2SessionValidityTime ) );
hgs
parents:
diff changeset
  1701
    iWLanParams.Append( EInputParams( EEapMschapv2Encapsulation,    KEapMschapv2Encapsulation ) );
hgs
parents:
diff changeset
  1702
    iWLanParams.Append( EInputParams( EEapFastUsername,             KEapFastUsername ) );
hgs
parents:
diff changeset
  1703
    iWLanParams.Append( EInputParams( EEapFastRealm,                KEapFastRealm ) );
hgs
parents:
diff changeset
  1704
    iWLanParams.Append( EInputParams( EEapFastVerifyServerRealm,    KEapFastVerifyServerRealm ) );
hgs
parents:
diff changeset
  1705
    iWLanParams.Append( EInputParams( EEapFastRequireClientAuth,    KEapFastRequireClientAuth ) );
hgs
parents:
diff changeset
  1706
    iWLanParams.Append( EInputParams( EEapFastSessionValidityTime,  KEapFastSessionValidityTime ) );
hgs
parents:
diff changeset
  1707
    iWLanParams.Append( EInputParams( EEapFastCipherSuites,         KEapFastCipherSuites ) );
hgs
parents:
diff changeset
  1708
    iWLanParams.Append( EInputParams( EEapFastEncapsulatedTypes,    KEapFastEncapsulatedTypes ) );
hgs
parents:
diff changeset
  1709
    iWLanParams.Append( EInputParams( EEapFastAuthProvModeAllowed,  KEapFastAuthProvModeAllowed ) );
hgs
parents:
diff changeset
  1710
    iWLanParams.Append( EInputParams( EEapFastUnauthProvModeAllowed, KEapFastUnauthProvModeAllowed ) );
hgs
parents:
diff changeset
  1711
    iWLanParams.Append( EInputParams( EEapFastWarnADHPNoPAC,        KEapFastWarnADHPNoPAC ) );
hgs
parents:
diff changeset
  1712
    iWLanParams.Append( EInputParams( EEapFastWarnADHPNoMatchingPAC, KEapFastWarnADHPNoMatchingPAC ) );
hgs
parents:
diff changeset
  1713
    iWLanParams.Append( EInputParams( EEapFastWarnNotDefaultServer, KEapFastWarnNotDefaultServer ) );
hgs
parents:
diff changeset
  1714
    iWLanParams.Append( EInputParams( EEapFastUserCertSubjectKeyId, KEapFastUserCertSubjectKeyId ) );
hgs
parents:
diff changeset
  1715
    iWLanParams.Append( EInputParams( EEapFastUserCertIssuerName,   KEapFastUserCertIssuerName ) );
hgs
parents:
diff changeset
  1716
    iWLanParams.Append( EInputParams( EEapFastUserCertSerialNumber, KEapFastUserCertSerialNumber ) );
hgs
parents:
diff changeset
  1717
    iWLanParams.Append( EInputParams( EEapFastCaCertSubjectKeyId,   KEapFastCaCertSubjectKeyId ) );
hgs
parents:
diff changeset
  1718
    iWLanParams.Append( EInputParams( EEapFastCaCertIssuerName,     KEapFastCaCertIssuerName ) );
hgs
parents:
diff changeset
  1719
    iWLanParams.Append( EInputParams( EEapFastCaCertSerialNumber,   KEapFastCaCertSerialNumber ) );
hgs
parents:
diff changeset
  1720
    iWLanParams.Append( EInputParams( EMschapv2Username,            KMschapv2Username ) );
hgs
parents:
diff changeset
  1721
    iWLanParams.Append( EInputParams( EMschapv2Password,            KMschapv2Password ) );
hgs
parents:
diff changeset
  1722
    iWLanParams.Append( EInputParams( EMschapv2SessionValidityTime, KMschapv2SessionValidityTime ) );
hgs
parents:
diff changeset
  1723
    iWLanParams.Append( EInputParams( EMschapv2Encapsulation, 		KMschapv2Encapsulation ) );        
hgs
parents:
diff changeset
  1724
    };
hgs
parents:
diff changeset
  1725
    
hgs
parents:
diff changeset
  1726
    
hgs
parents:
diff changeset
  1727
hgs
parents:
diff changeset
  1728
void CReaderXML::FillVpnParams()    
hgs
parents:
diff changeset
  1729
    {
hgs
parents:
diff changeset
  1730
    iVpnParams.Reset();
hgs
parents:
diff changeset
  1731
        
hgs
parents:
diff changeset
  1732
    iVpnParams.Append( EInputParams( ECmName,              KConnectionName ) );
hgs
parents:
diff changeset
  1733
    iVpnParams.Append( EInputParams( ECmId,                KConnectionId ) );
hgs
parents:
diff changeset
  1734
    iVpnParams.Append( EInputParams( ECmProtected,         KProtected ) );
hgs
parents:
diff changeset
  1735
    iVpnParams.Append( EInputParams( ECmHidden,            KHidden ) );
hgs
parents:
diff changeset
  1736
    iVpnParams.Append( EInputParams( ECmMetaHiddenAgent,   KHiddenAgent ) );
hgs
parents:
diff changeset
  1737
    iVpnParams.Append( EInputParams( ECmMetaHighlight,     KHighlighted ) );
hgs
parents:
diff changeset
  1738
    iVpnParams.Append( EInputParams( ECmSeamlessnessLevel, KSeamlessness ) );
hgs
parents:
diff changeset
  1739
    iVpnParams.Append( EInputParams( ECmProxyServerName,   KProxyServerAddress ) );
hgs
parents:
diff changeset
  1740
    iVpnParams.Append( EInputParams( ECmProxyPortNumber,   KProxyPortNumber ) );
hgs
parents:
diff changeset
  1741
    iVpnParams.Append( EInputParams( ECmProxyProtocolName, KProxyProtocolName ) );
hgs
parents:
diff changeset
  1742
    iVpnParams.Append( EInputParams( EVPN_IapName,         KVpnIapName ) );
hgs
parents:
diff changeset
  1743
    iVpnParams.Append( EInputParams( EVpnServicePolicy,    KVpnServicePolicy ) );
hgs
parents:
diff changeset
  1744
hgs
parents:
diff changeset
  1745
    };    
hgs
parents:
diff changeset
  1746
hgs
parents:
diff changeset
  1747
//Binds Gobal settings parameters to field IDs
hgs
parents:
diff changeset
  1748
void CReaderXML::FillGlobalParams()    
hgs
parents:
diff changeset
  1749
    {         
hgs
parents:
diff changeset
  1750
    iGlobalParams.Append( EInputParams( EGPRSAttachMode,        KAttachMode ) );
hgs
parents:
diff changeset
  1751
    iGlobalParams.Append( EInputParams( EDefaultAP,             KDefaultAP) );
hgs
parents:
diff changeset
  1752
    iGlobalParams.Append( EInputParams( EDefaultDnIcon,         KDefaultDnIcon ) );
hgs
parents:
diff changeset
  1753
    iGlobalParams.Append( EInputParams( EPriorityLan,           KPriorityLan ) );
hgs
parents:
diff changeset
  1754
    iGlobalParams.Append( EInputParams( EPriorityWlan,          KPriorityWlan ) );
hgs
parents:
diff changeset
  1755
    iGlobalParams.Append( EInputParams( EPriorityPan,           KPriorityPan ) );
hgs
parents:
diff changeset
  1756
    iGlobalParams.Append( EInputParams( EPriorityGprsOut,       KPriorityGprsOut ) );
hgs
parents:
diff changeset
  1757
    iGlobalParams.Append( EInputParams( EPriorityGprsIn,        KPriorityGprsIn ) );
hgs
parents:
diff changeset
  1758
    iGlobalParams.Append( EInputParams( EPriorityCdma2k,        KPriorityCdma2k ) );
hgs
parents:
diff changeset
  1759
    iGlobalParams.Append( EInputParams( EPriorityDialOut,       KPriorityDialOut ) );
hgs
parents:
diff changeset
  1760
    iGlobalParams.Append( EInputParams( EPriorityDialIn,        KPriorityDialIn ) );
hgs
parents:
diff changeset
  1761
    iGlobalParams.Append( EInputParams( EPriorityVpn,           KPriorityVpn ) );
hgs
parents:
diff changeset
  1762
    iGlobalParams.Append( EInputParams( EPriorityMip,           KPriorityMip ) );
hgs
parents:
diff changeset
  1763
    iGlobalParams.Append( EInputParams( EUIPriorityLan,         KUIPriorityLan ) );
hgs
parents:
diff changeset
  1764
    iGlobalParams.Append( EInputParams( EUIPriorityWlan,        KUIPriorityWlan ) );
hgs
parents:
diff changeset
  1765
    iGlobalParams.Append( EInputParams( EUIPriorityPan,         KUIPriorityPan ) );
hgs
parents:
diff changeset
  1766
    iGlobalParams.Append( EInputParams( EUIPriorityGprsOut,     KUIPriorityGprsOut ) );
hgs
parents:
diff changeset
  1767
    iGlobalParams.Append( EInputParams( EUIPriorityGprsIn,      KUIPriorityGprsIn ) );
hgs
parents:
diff changeset
  1768
    iGlobalParams.Append( EInputParams( EUIPriorityCdma2k,      KUIPriorityCdma2k ) );
hgs
parents:
diff changeset
  1769
    iGlobalParams.Append( EInputParams( EUIPriorityDialOut,     KUIPriorityDialOut ) );
hgs
parents:
diff changeset
  1770
    iGlobalParams.Append( EInputParams( EUIPriorityDialIn,      KUIPriorityDialIn ) );
hgs
parents:
diff changeset
  1771
    iGlobalParams.Append( EInputParams( EUIPriorityVpn,         KUIPriorityVpn ) );
hgs
parents:
diff changeset
  1772
    iGlobalParams.Append( EInputParams( EUIPriorityMip,         KUIPriorityMip ) );
hgs
parents:
diff changeset
  1773
    iGlobalParams.Append( EInputParams( EUsageOfWlan,           KUsageOfWlan ) );
hgs
parents:
diff changeset
  1774
    iGlobalParams.Append( EInputParams( ECellularDataUsageHome,         KCellularDataUsageHome ) );
hgs
parents:
diff changeset
  1775
    iGlobalParams.Append( EInputParams( ECellularDataUsageVisitor,      KCellularDataUsageVisitor ) );
hgs
parents:
diff changeset
  1776
    iGlobalParams.Append( EInputParams( EGprsLastSocketActivityTimeout, KGprsLastSocketActivityTimeout ) );
hgs
parents:
diff changeset
  1777
    iGlobalParams.Append( EInputParams( EGprsLastSessionClosedTimeout,  KGprsLastSessionClosedTimeout ) );
hgs
parents:
diff changeset
  1778
    iGlobalParams.Append( EInputParams( EGprsLastSocketClosedTimeout,   KGprsLastSocketClosedTimeout ) );
hgs
parents:
diff changeset
  1779
    iGlobalParams.Append( EInputParams( EWlanLastSocketActivityTimeout, KWlanLastSocketActivityTimeout ) );
hgs
parents:
diff changeset
  1780
    iGlobalParams.Append( EInputParams( EWlanLastSessionClosedTimeout,  KWlanLastSessionClosedTimeout ) );
hgs
parents:
diff changeset
  1781
    iGlobalParams.Append( EInputParams( EWlanLastSocketClosedTimeout,   KWlanLastSocketClosedTimeout ) );
hgs
parents:
diff changeset
  1782
    iGlobalParams.Append( EInputParams( EWlanBGScanInterval,    KWlanBGScanInterval ) );
hgs
parents:
diff changeset
  1783
    iGlobalParams.Append( EInputParams( EWlanUseDefSettings,    KWlanUseDefSettings ) );
hgs
parents:
diff changeset
  1784
    iGlobalParams.Append( EInputParams( EWlanLongRetry,         KWlanLongRetry ) );
hgs
parents:
diff changeset
  1785
    iGlobalParams.Append( EInputParams( EWlanShortRetry,        KWlanShortRetry ) );
hgs
parents:
diff changeset
  1786
    iGlobalParams.Append( EInputParams( EWlanRTS,               KWlanRTS ) );
hgs
parents:
diff changeset
  1787
    iGlobalParams.Append( EInputParams( EWlanTxPowerLevel,      KWlanTxPowerLevel ) );
hgs
parents:
diff changeset
  1788
    iGlobalParams.Append( EInputParams( EWlanRadioMeasurements, KWlanRadioMeasurements ) );
hgs
parents:
diff changeset
  1789
    iGlobalParams.Append( EInputParams( EWlanPowerMode,         KWlanPowerMode ) );
hgs
parents:
diff changeset
  1790
    
hgs
parents:
diff changeset
  1791
    };
hgs
parents:
diff changeset
  1792
hgs
parents:
diff changeset
  1793
//Describes a Destination Network
hgs
parents:
diff changeset
  1794
void CReaderXML::FillDNParams()    
hgs
parents:
diff changeset
  1795
    {        
hgs
parents:
diff changeset
  1796
    iDNParams.Append( EInputParams( EDN_Name,           KDN_Name ) );
hgs
parents:
diff changeset
  1797
    iDNParams.Append( EInputParams( EDN_Id,             KDN_Id ) );
hgs
parents:
diff changeset
  1798
    iDNParams.Append( EInputParams( EDN_Icon,           KDN_Icon ) );
hgs
parents:
diff changeset
  1799
    iDNParams.Append( EInputParams( EDN_Metadata,       KDN_Metadata ) );
hgs
parents:
diff changeset
  1800
    iDNParams.Append( EInputParams( EDN_Protection,     KDN_Protection ) );
hgs
parents:
diff changeset
  1801
    iDNParams.Append( EInputParams( EDN_Hidden,         KHidden ) );
hgs
parents:
diff changeset
  1802
    iDNParams.Append( EInputParams( EDN_HiddenAgent,    KHiddenAgent ) );
hgs
parents:
diff changeset
  1803
    iDNParams.Append( EInputParams( EDN_Highlighted,    KHighlighted ) );
hgs
parents:
diff changeset
  1804
    iDNParams.Append( EInputParams( EDN_EmbeddedDNName, KDN_EmbeddedDNName ) );
hgs
parents:
diff changeset
  1805
    iDNParams.Append( EInputParams( EDN_IAPName,        KDN_IAPName ) );
hgs
parents:
diff changeset
  1806
    // Needed because of Customization Tool limitations
hgs
parents:
diff changeset
  1807
    iDNParams.Append( EInputParams( EDN_IAPName,        KDN_IAPName2 ) );
hgs
parents:
diff changeset
  1808
    iDNParams.Append( EInputParams( EDN_IAPName,        KDN_IAPName3 ) );
hgs
parents:
diff changeset
  1809
    iDNParams.Append( EInputParams( EDN_IAPName,        KDN_IAPName4 ) );
hgs
parents:
diff changeset
  1810
    iDNParams.Append( EInputParams( EDN_IAPName,        KDN_IAPName5 ) );
hgs
parents:
diff changeset
  1811
    iDNParams.Append( EInputParams( EDN_IAPName,        KDN_IAPName6 ) );
hgs
parents:
diff changeset
  1812
    iDNParams.Append( EInputParams( EDN_IAPName,        KDN_IAPName7 ) );
hgs
parents:
diff changeset
  1813
    iDNParams.Append( EInputParams( EDN_IAPName,        KDN_IAPName8 ) );
hgs
parents:
diff changeset
  1814
    iDNParams.Append( EInputParams( EDN_IAPName,        KDN_IAPName9 ) );
hgs
parents:
diff changeset
  1815
    iDNParams.Append( EInputParams( EDN_IAPName,        KDN_IAPName10 ) );   
hgs
parents:
diff changeset
  1816
    };
hgs
parents:
diff changeset
  1817
        
hgs
parents:
diff changeset
  1818
// End of File.