1 /* |
|
2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: TUN Driver plug-in IF implementation class. |
|
15 * |
|
16 */ |
|
17 |
|
18 #include <AknsUtils.h> |
|
19 #include <cmpluginvpn.mbg> |
|
20 #include <data_caging_path_literals.hrh> |
|
21 |
|
22 #include "cmlogger.h" |
|
23 #include "cmdestinationimpl.h" |
|
24 #include "cmplugintundriver.h" |
|
25 |
|
26 using namespace CMManager; |
|
27 using namespace CommsDat; |
|
28 |
|
29 const TUint32 KDefaultPriorityTUNDriver = 0; |
|
30 _LIT( KPluginTUNDriverFileIcons, "z:cmplugintundriver.mbm" ); |
|
31 _LIT(KTUNDriverBearerName,"TUNDriverBearer"); |
|
32 #define KCDAgentNameTUNDriver _S("tundriveragt.agt") |
|
33 _LIT(KTUNDriverTunnelAgent,"tundriveragt.agt"); |
|
34 #define KCDInterfaceNameTUNDriver _S("tundriver") |
|
35 _LIT(KTUNDriverInterfaceName,"tundriver"); |
|
36 |
|
37 const TInt KLanLastSocketActivityTimeout = -1; |
|
38 const TInt KLanLastSocketClosedTimeout = -1; |
|
39 |
|
40 const TBool KDefIpAddrFromServer = EFalse; |
|
41 const TBool KDefIpDnsAddrFromServer = EFalse; |
|
42 const TBool KDefIp6DnsAddrFromServer = EFalse; |
|
43 _LIT( KEmpty, ""); |
|
44 |
|
45 static const TCmAttribConvTable STUNDriverConvTbl[] = |
|
46 { |
|
47 { ETUNDriverIfNetworks, ETUNDriverRangeMax, NULL }, |
|
48 { ETUNDriverIfNetworks, KCDTIdLANIfNetworks, NULL }, |
|
49 { ETUNDriverIpNetMask, KCDTIdLANIpNetMask, &CheckIPv4ValidityL }, |
|
50 { ETUNDriverIpGateway, KCDTIdLANIpGateway, &CheckIPv4ValidityL }, |
|
51 { ETUNDriverIpAddrFromServer, KCDTIdLANIpAddrFromServer, NULL }, |
|
52 { ETUNDriverIpAddr, KCDTIdLANIpAddr, &CheckIPv4ValidityL }, |
|
53 { ETUNDriverIpDNSAddrFromServer, KCDTIdLANIpDNSAddrFromServer, NULL }, |
|
54 { ETUNDriverIpNameServer1, KCDTIdLANIpNameServer1, &CheckIPv4ValidityL }, |
|
55 { ETUNDriverIpNameServer2, KCDTIdLANIpNameServer2, &CheckIPv4ValidityL }, |
|
56 { ETUNDriverIp6DNSAddrFromServer, KCDTIdLANIp6DNSAddrFromServer, NULL }, |
|
57 { ETUNDriverIp6NameServer1, KCDTIdLANIp6NameServer1, &CheckIPv4ValidityL }, |
|
58 { ETUNDriverIp6NameServer2, KCDTIdLANIp6NameServer2, &CheckIPv4ValidityL }, |
|
59 { ETUNDriverIpAddrLeaseValidFrom, KCDTIdLANIpAddrLeaseValidFrom, NULL }, |
|
60 { ETUNDriverIpAddrLeaseValidTo, KCDTIdLANIpAddrLeaseValidTo, NULL }, |
|
61 { ETUNDriverConfigDaemonManagerName, KCDTIdLANConfigDaemonManagerName, NULL }, |
|
62 { ETUNDriverConfigDaemonName, KCDTIdLANConfigDaemonName, NULL }, |
|
63 { ETUNDriverServiceExtensionTableName, KCDTIdLANServiceExtensionTableName, NULL }, |
|
64 { ETUNDriverServiceExtensionTableRecordId, KCDTIdLANServiceExtensionTableRecordId, NULL }, |
|
65 { 0, 0, NULL } |
|
66 }; |
|
67 |
|
68 static const TCmCommonAttrConvArrayItem STUNDriverCommonConvTbl[] = |
|
69 { |
|
70 { ETUNDriverIfNetworks, ECmIFNetworks }, |
|
71 { ETUNDriverIpNetMask, ECmIPNetmask }, |
|
72 { ETUNDriverIpGateway, ECmIPGateway }, |
|
73 { ETUNDriverIpAddrFromServer, ECmIPAddFromServer }, |
|
74 { ETUNDriverIpAddr, ECmIPAddress }, |
|
75 { ETUNDriverIpDNSAddrFromServer, ECmIPDNSAddrFromServer }, |
|
76 { ETUNDriverIpNameServer1, ECmIPNameServer1 }, |
|
77 { ETUNDriverIpNameServer2, ECmIPNameServer2 }, |
|
78 { ETUNDriverIp6DNSAddrFromServer, ECmIP6DNSAddrFromServer }, |
|
79 { ETUNDriverIp6NameServer1, ECmIP6NameServer1 }, |
|
80 { ETUNDriverIp6NameServer2, ECmIP6NameServer2 }, |
|
81 { ETUNDriverIpAddrLeaseValidFrom, ECmIPAddrLeaseValidFrom }, |
|
82 { ETUNDriverIpAddrLeaseValidTo, ECmIPAddrLeaseValidTo }, |
|
83 { ETUNDriverConfigDaemonManagerName, ECmConfigDaemonManagerName }, |
|
84 { ETUNDriverConfigDaemonName, ECmConfigDaemonName }, |
|
85 { 0, 0 } |
|
86 }; |
|
87 |
|
88 // -------------------------------------------------------------------------- |
|
89 // CCmPluginTUNDriver::NewL() |
|
90 // -------------------------------------------------------------------------- |
|
91 // |
|
92 CCmPluginTUNDriver* CCmPluginTUNDriver::NewL( TCmPluginInitParam* aInitParam ) |
|
93 { |
|
94 CCmPluginTUNDriver* self = new( ELeave ) CCmPluginTUNDriver( aInitParam ); |
|
95 CleanupStack::PushL( self ); |
|
96 self->ConstructL(); |
|
97 CleanupStack::Pop( self ); |
|
98 return self; |
|
99 } |
|
100 |
|
101 // -------------------------------------------------------------------------- |
|
102 // CCmPluginTUNDriver::~CCmPluginTUNDriver() |
|
103 // -------------------------------------------------------------------------- |
|
104 // |
|
105 CCmPluginTUNDriver::~CCmPluginTUNDriver() |
|
106 { |
|
107 AdditionalReset(); |
|
108 } |
|
109 |
|
110 // -------------------------------------------------------------------------- |
|
111 // CCmPluginTUNDriver::CreateInstanceL |
|
112 // -------------------------------------------------------------------------- |
|
113 // |
|
114 CCmPluginBaseEng* CCmPluginTUNDriver::CreateInstanceL( TCmPluginInitParam& aInitParam ) const |
|
115 { |
|
116 CCmPluginTUNDriver* self = new( ELeave ) CCmPluginTUNDriver( &aInitParam ); |
|
117 CleanupStack::PushL( self ); |
|
118 self->ConstructL(); |
|
119 CleanupStack::Pop( self ); |
|
120 return self; |
|
121 } |
|
122 |
|
123 // -------------------------------------------------------------------------- |
|
124 // CCmPluginTUNDriver::CCmPluginTUNDriver() |
|
125 // -------------------------------------------------------------------------- |
|
126 // |
|
127 CCmPluginTUNDriver::CCmPluginTUNDriver( TCmPluginInitParam* aInitParam ) |
|
128 : CCmPluginLanBase( aInitParam ) |
|
129 { |
|
130 CLOG_CREATE; |
|
131 iBearerType = KPluginTUNDriverBearerTypeUid; |
|
132 } |
|
133 |
|
134 // -------------------------------------------------------------------------- |
|
135 // CCmPluginTUNDriver::ConstructL() |
|
136 // -------------------------------------------------------------------------- |
|
137 // |
|
138 void CCmPluginTUNDriver::ConstructL() |
|
139 { |
|
140 CCmPluginLanBase::ConstructL(); |
|
141 iBearerRecName = KCDTypeNameVirtualBearer; |
|
142 |
|
143 AddConverstionTableL( (CCDRecordBase**)&iServiceRecord, NULL, STUNDriverConvTbl ); |
|
144 AddCommonConversionTableL( STUNDriverCommonConvTbl ); |
|
145 } |
|
146 |
|
147 // -------------------------------------------------------------------------- |
|
148 // CCmPluginTUNDriver::GetIntAttributeL() |
|
149 // -------------------------------------------------------------------------- |
|
150 // |
|
151 TUint32 CCmPluginTUNDriver::GetIntAttributeL( const TUint32 aAttribute ) const |
|
152 { |
|
153 LOGGER_ENTERFN( "CCmPluginTUNDriver::GetIntAttributeL" ); |
|
154 |
|
155 TUint32 retVal( 0 ); |
|
156 |
|
157 switch( aAttribute ) |
|
158 { |
|
159 case ECmBearerIcon: |
|
160 { |
|
161 MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); |
|
162 TAknsItemID id; |
|
163 TParse mbmFile; |
|
164 User::LeaveIfError( mbmFile.Set( KPluginTUNDriverFileIcons, |
|
165 &KDC_BITMAP_DIR, NULL ) ); |
|
166 |
|
167 retVal = (TUint32)AknsUtils::CreateGulIconL( |
|
168 skinInstance, |
|
169 id, |
|
170 mbmFile.FullName(), |
|
171 EMbmCmpluginvpnQgn_prop_vpn_access_point, |
|
172 EMbmCmpluginvpnQgn_prop_vpn_access_point_mask ); |
|
173 } |
|
174 break; |
|
175 case ECmCommsDBBearerType: |
|
176 { |
|
177 retVal = KCommDbBearerLAN; |
|
178 } |
|
179 break; |
|
180 case ECmDefaultUiPriority: |
|
181 case ECmDefaultPriority: |
|
182 { |
|
183 retVal = aAttribute == ECmDefaultPriority ? |
|
184 GlobalBearerPriority( TPtrC(KCDTypeNameLANService) ) : |
|
185 GlobalUiBearerPriority( TPtrC(KCDTypeNameLANService) ); |
|
186 |
|
187 if ( retVal == KDataMobilitySelectionPolicyPriorityWildCard ) |
|
188 { |
|
189 retVal = KDefaultPriorityTUNDriver; |
|
190 } |
|
191 } |
|
192 break; |
|
193 default: |
|
194 { |
|
195 retVal = CCmPluginBaseEng::GetIntAttributeL( aAttribute ); |
|
196 } |
|
197 } |
|
198 |
|
199 return retVal; |
|
200 } |
|
201 |
|
202 // -------------------------------------------------------------------------- |
|
203 // CCmPluginTUNDriver::CanHandleIapIdL() |
|
204 // -------------------------------------------------------------------------- |
|
205 // |
|
206 TBool CCmPluginTUNDriver::CanHandleIapIdL( TUint32 aIapId ) const |
|
207 { |
|
208 LOGGER_ENTERFN( "CCmPluginTUNDriver::CanHandleIapIdL1" ); |
|
209 TBool retVal( EFalse ); |
|
210 |
|
211 CCDIAPRecord *iapRecord = static_cast<CCDIAPRecord *> |
|
212 (CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord)); |
|
213 |
|
214 CleanupStack::PushL( iapRecord ); |
|
215 iapRecord->SetRecordId( aIapId ); |
|
216 |
|
217 TRAPD( err, iapRecord->LoadL( Session() )); |
|
218 |
|
219 if( !err ) |
|
220 { |
|
221 CanHandleIapIdL( iapRecord ); |
|
222 } |
|
223 |
|
224 CleanupStack::PopAndDestroy( iapRecord ); |
|
225 return retVal; |
|
226 } |
|
227 |
|
228 // -------------------------------------------------------------------------- |
|
229 // CCmPluginTUNDriver::CanHandleIapIdL() |
|
230 // -------------------------------------------------------------------------- |
|
231 // |
|
232 TBool CCmPluginTUNDriver::CanHandleIapIdL( CCDIAPRecord *aIapRecord ) const |
|
233 { |
|
234 LOGGER_ENTERFN( "CCmPluginTUNDriver::CanHandleIapIdL" ); |
|
235 |
|
236 TBool retVal( EFalse ); |
|
237 |
|
238 if( TPtrC( aIapRecord->iServiceType ) == TPtrC(KCDTypeNameLANService) && |
|
239 TPtrC( aIapRecord->iBearerType ) == TPtrC(KCDTypeNameVirtualBearer) ) |
|
240 { |
|
241 CMDBRecordSet<CCDVirtualBearerRecord>* bearersRS = |
|
242 new ( ELeave ) CMDBRecordSet<CCDVirtualBearerRecord>(KCDTIdVirtualBearerRecord); |
|
243 CleanupStack::PushL( bearersRS ); |
|
244 CCDVirtualBearerRecord* bearerRecord = |
|
245 static_cast<CCDVirtualBearerRecord *>( CCDRecordBase::RecordFactoryL( KCDTIdVirtualBearerRecord ) ); |
|
246 CleanupStack::PushL( bearerRecord ); |
|
247 |
|
248 // Find entries used "tundriveragt.agt" as agent from Table VirtualBearer |
|
249 bearerRecord->iBearerAgent.SetL( KTUNDriverTunnelAgent ); |
|
250 bearerRecord->iVirtualBearerNifName.SetL( KTUNDriverInterfaceName ); |
|
251 bearersRS->iRecords.AppendL( bearerRecord ); |
|
252 |
|
253 CleanupStack::Pop( bearerRecord ); |
|
254 bearerRecord = NULL; |
|
255 if ( bearersRS->FindL( Session() ) ) |
|
256 { |
|
257 TUint32 recordId = (*bearersRS)[0]->RecordId(); |
|
258 TPtrC bearerName( (*bearersRS)[0]->iRecordName.GetL() ); |
|
259 TPtrC bearerAgent( (*bearersRS)[0]->iBearerAgent.GetL() ); |
|
260 TPtrC bearerInterface( (*bearersRS)[0]->iVirtualBearerNifName.GetL() ); |
|
261 |
|
262 // Further comparing record ID referred to by this VPN IAP with entry ID in table VirtualBearer |
|
263 // And also comparing bear name with our expected one "vpnbearer" |
|
264 if ( bearerAgent == TPtrC( KCDAgentNameTUNDriver ) && |
|
265 bearerInterface == TPtrC( KCDInterfaceNameTUNDriver ) ) |
|
266 { |
|
267 retVal = ETrue; |
|
268 } |
|
269 } |
|
270 |
|
271 CleanupStack::PopAndDestroy( bearersRS ); |
|
272 } |
|
273 return retVal; |
|
274 } |
|
275 |
|
276 // -------------------------------------------------------------------------- |
|
277 // CCmPluginTUNDriver::RunSettingsL() |
|
278 // -------------------------------------------------------------------------- |
|
279 // |
|
280 TInt CCmPluginTUNDriver::RunSettingsL() |
|
281 { |
|
282 LOGGER_ENTERFN( "CCmPluginTUNDriver::RunSettingsL" ); |
|
283 User::Leave( KErrNotSupported ); |
|
284 return KErrNotSupported; |
|
285 } |
|
286 |
|
287 // -------------------------------------------------------------------------- |
|
288 // CCmPluginTUNDriver::LoadServiceSettingL() |
|
289 // -------------------------------------------------------------------------- |
|
290 // |
|
291 void CCmPluginTUNDriver::LoadServiceSettingL() |
|
292 { |
|
293 LOGGER_ENTERFN( "CCmPluginTUNDriver::LoadServiceSettingL" ); |
|
294 |
|
295 if( TPtrC(KCDTypeNameLANService) == iIapRecord->iServiceType ) |
|
296 { |
|
297 iServiceRecord = static_cast<CCDLANServiceRecord *> |
|
298 ( CCDRecordBase::RecordFactoryL( KCDTIdLANServiceRecord ) ); |
|
299 } |
|
300 else |
|
301 { |
|
302 User::Leave( KErrNotSupported ); |
|
303 } |
|
304 |
|
305 CCmPluginBaseEng::LoadServiceSettingL(); |
|
306 } |
|
307 |
|
308 // -------------------------------------------------------------------------- |
|
309 // CCmPluginTUNDriver::InitializeWithUiL() |
|
310 // -------------------------------------------------------------------------- |
|
311 // |
|
312 TBool CCmPluginTUNDriver::InitializeWithUiL( TBool /*aManuallyConfigure*/ ) |
|
313 { |
|
314 User::Leave( KErrNotSupported ); |
|
315 return ETrue; |
|
316 } |
|
317 |
|
318 // -------------------------------------------------------------------------- |
|
319 // CCmPluginTUNDriver::ServiceRecord() |
|
320 // -------------------------------------------------------------------------- |
|
321 // |
|
322 CCDLANServiceRecord& CCmPluginTUNDriver::ServiceRecord() const |
|
323 { |
|
324 LOGGER_ENTERFN( "CCmPluginTUNDriver::ServiceRecord" ); |
|
325 return *static_cast<CCDLANServiceRecord*>( iServiceRecord ); |
|
326 } |
|
327 |
|
328 // -------------------------------------------------------------------------- |
|
329 // CCmPluginTUNDriver::CreateNewServiceRecordL() |
|
330 // -------------------------------------------------------------------------- |
|
331 // |
|
332 void CCmPluginTUNDriver::CreateNewServiceRecordL() |
|
333 { |
|
334 LOGGER_ENTERFN( "CCmPluginTUNDriver::CreateNewServiceRecordL" ); |
|
335 |
|
336 delete iServiceRecord; |
|
337 iServiceRecord = NULL; |
|
338 |
|
339 iServiceRecord = static_cast<CCDServiceRecordBase *> |
|
340 (CCDRecordBase::RecordFactoryL( KCDTIdLANServiceRecord )); |
|
341 |
|
342 // I do not think that we have to use the default record, |
|
343 // but for compatibility with ApEngine, we write all fields |
|
344 CCDLANServiceRecord* record = |
|
345 static_cast<CCDLANServiceRecord *>( iServiceRecord ); |
|
346 |
|
347 if ( FeatureSupported( KFeatureIdIPv6 ) ) |
|
348 { |
|
349 record->iIfNetworks.SetL( KDefIspIfNetworksIPv4IPv6LAN ); |
|
350 } |
|
351 else |
|
352 { |
|
353 record->iIfNetworks.SetL( KDefIspIfNetworksIPv4 ); |
|
354 } |
|
355 record->iIpGateway.SetL( KUnspecifiedIPv4 ); |
|
356 record->iIpAddrFromServer.SetL( KDefIpAddrFromServer ); |
|
357 |
|
358 record->iIpAddr.SetL( KUnspecifiedIPv4 ); |
|
359 |
|
360 record->iIpDnsAddrFromServer.SetL( KDefIpDnsAddrFromServer ); |
|
361 |
|
362 record->iIpNameServer1.SetL( KUnspecifiedIPv4 ); |
|
363 record->iIpNameServer2.SetL( KUnspecifiedIPv4 ); |
|
364 record->iIp6DnsAddrFromServer.SetL( KDefIp6DnsAddrFromServer ); |
|
365 record->iIp6NameServer1.SetL( KDynamicIpv6Address ); |
|
366 record->iIp6NameServer2.SetL( KDynamicIpv6Address ); |
|
367 |
|
368 if ( KDefIpAddrFromServer ) |
|
369 { |
|
370 record->iConfigDaemonManagerName.SetL( KDaemonManagerName ); |
|
371 record->iConfigDaemonName.SetL( KConfigDaemonName ); |
|
372 } |
|
373 else |
|
374 { |
|
375 record->iConfigDaemonManagerName.SetL( KEmpty ); |
|
376 record->iConfigDaemonName.SetL( KEmpty ); |
|
377 } |
|
378 } |
|
379 |
|
380 // --------------------------------------------------------------------------- |
|
381 // CCmPluginTUNDriver::ServiceRecordIdLC |
|
382 // --------------------------------------------------------------------------- |
|
383 // |
|
384 void CCmPluginTUNDriver::ServiceRecordIdLC( HBufC* &aName, TUint32& aRecordId ) |
|
385 { |
|
386 LOGGER_ENTERFN( "CCmPluginTUNDriver::ServiceRecordIdLC" ); |
|
387 |
|
388 aName = TPtrC( KCDTypeNameLANService ).AllocLC(); |
|
389 aRecordId = iServiceRecord->RecordId(); |
|
390 } |
|
391 |
|
392 // -------------------------------------------------------------------------- |
|
393 // CCmPluginTUNDriver::BearerRecordIdLC() |
|
394 // -------------------------------------------------------------------------- |
|
395 // |
|
396 void CCmPluginTUNDriver::BearerRecordIdLC( HBufC* &aBearerName, TUint32& aRecordId ) |
|
397 { |
|
398 LOGGER_ENTERFN( "CCmPluginTUNDriver::BearerRecordIdLC" ); |
|
399 |
|
400 CMDBRecordSet<CCDVirtualBearerRecord>* bearersRS = |
|
401 new(ELeave) CMDBRecordSet<CCDVirtualBearerRecord> |
|
402 (KCDTIdVirtualBearerRecord); |
|
403 CleanupStack::PushL( bearersRS ); |
|
404 |
|
405 CCDVirtualBearerRecord* tmprec = static_cast<CCDVirtualBearerRecord*> |
|
406 (CCDRecordBase::RecordFactoryL( KCDTIdVirtualBearerRecord )); |
|
407 CleanupStack::PushL( tmprec ); |
|
408 tmprec->iBearerAgent.SetL( KTUNDriverTunnelAgent ); |
|
409 bearersRS->iRecords.AppendL( tmprec ); |
|
410 |
|
411 CleanupStack::Pop( tmprec ); |
|
412 tmprec = NULL; |
|
413 |
|
414 if ( !bearersRS->FindL( Session() ) ) |
|
415 // No bearer record found -> create a default one. |
|
416 { |
|
417 tmprec = static_cast<CCDVirtualBearerRecord *> |
|
418 (CCDRecordBase::RecordFactoryL(KCDTIdVirtualBearerRecord)); |
|
419 CleanupStack::PushL(tmprec); |
|
420 |
|
421 tmprec->iRecordName.SetL( KTUNDriverBearerName ); |
|
422 tmprec->iBearerAgent.SetL( KTUNDriverTunnelAgent ); |
|
423 tmprec->iVirtualBearerNifName.SetL(KTUNDriverInterfaceName); |
|
424 tmprec->iLastSocketActivityTimeout = (TUint32)KLanLastSocketActivityTimeout; |
|
425 tmprec->iLastSessionClosedTimeout = (TUint32) KLanLastSocketClosedTimeout; |
|
426 tmprec->iLastSocketClosedTimeout = (TUint32)KLanLastSocketActivityTimeout; |
|
427 |
|
428 tmprec->SetRecordId( KCDNewRecordRequest ); |
|
429 tmprec->StoreL( Session() ); |
|
430 |
|
431 aRecordId = tmprec->RecordId(); |
|
432 |
|
433 CleanupStack::PopAndDestroy(tmprec); |
|
434 } |
|
435 else |
|
436 { |
|
437 aRecordId = (*bearersRS)[0]->RecordId(); |
|
438 } |
|
439 |
|
440 CleanupStack::PopAndDestroy( bearersRS ); |
|
441 |
|
442 aBearerName = TPtrC( KCDTypeNameVirtualBearer ).AllocLC(); |
|
443 } |
|
444 |
|
445 // -------------------------------------------------------------------------- |
|
446 // CCmPluginTUNDriver::PrepareToUpdateRecordsL() |
|
447 // -------------------------------------------------------------------------- |
|
448 // |
|
449 void CCmPluginTUNDriver::PrepareToUpdateRecordsL() |
|
450 { |
|
451 LOGGER_ENTERFN( "CCmPluginTUNDriver::PrepareToUpdateRecordsL" ); |
|
452 CheckDNSServerAddressL( ETrue, |
|
453 ServiceRecord().iIp6NameServer1, |
|
454 ServiceRecord().iIp6NameServer2, |
|
455 ServiceRecord().iIp6DnsAddrFromServer ); |
|
456 |
|
457 CheckDNSServerAddressL( EFalse, |
|
458 ServiceRecord().iIpNameServer1, |
|
459 ServiceRecord().iIpNameServer2, |
|
460 ServiceRecord().iIpDnsAddrFromServer ); |
|
461 } |
|
462 |
|
463 // -------------------------------------------------------------------------- |
|
464 // CCmPluginTUNDriver::AdditionalReset() |
|
465 // -------------------------------------------------------------------------- |
|
466 // |
|
467 void CCmPluginTUNDriver::AdditionalReset() |
|
468 { |
|
469 |
|
470 } |
|
471 |
|
472 // eof |
|