53 // CVpnApEngine::NewLC |
53 // CVpnApEngine::NewLC |
54 // --------------------------------------------------------- |
54 // --------------------------------------------------------- |
55 // |
55 // |
56 EXPORT_C CVpnApEngine* CVpnApEngine::NewLC( CCommsDatabase* aDb ) |
56 EXPORT_C CVpnApEngine* CVpnApEngine::NewLC( CCommsDatabase* aDb ) |
57 { |
57 { |
58 CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::NewL" ) ) ); |
58 return NULL; |
59 |
|
60 CVpnApEngine* self = new ( ELeave ) CVpnApEngine; |
|
61 CleanupStack::PushL( self ); |
|
62 self->ConstructL( aDb ); |
|
63 |
|
64 CLOG( ( EApItem, 1, _L( "<- CVpnApEngine::NewL" ) ) ); |
|
65 |
|
66 return self; |
|
67 } |
59 } |
68 |
60 |
69 |
61 |
70 // --------------------------------------------------------- |
62 // --------------------------------------------------------- |
71 // CVpnApEngine::~CVpnApEngine |
63 // CVpnApEngine::~CVpnApEngine |
72 // --------------------------------------------------------- |
64 // --------------------------------------------------------- |
73 // |
65 // |
74 EXPORT_C CVpnApEngine::~CVpnApEngine() |
66 EXPORT_C CVpnApEngine::~CVpnApEngine() |
75 { |
67 { |
76 if ( iOwnDb ) |
|
77 { |
|
78 delete iDb; |
|
79 } |
|
80 |
|
81 CLOG( ( EApItem, 0, _L( "<-> CVpnApEngine::~CVpnApEngine" ) ) ); |
|
82 } |
68 } |
83 |
69 |
84 |
70 |
85 // --------------------------------------------------------- |
71 // --------------------------------------------------------- |
86 // CVpnApEngine::ConstructL |
72 // CVpnApEngine::ConstructL |
87 // --------------------------------------------------------- |
73 // --------------------------------------------------------- |
88 // |
74 // |
89 EXPORT_C void CVpnApEngine::ConstructL( CCommsDatabase* aDb ) |
75 EXPORT_C void CVpnApEngine::ConstructL( CCommsDatabase* aDb ) |
90 { |
76 { |
91 CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::ConstructL" ) ) ); |
|
92 |
|
93 if ( aDb ) |
|
94 { |
|
95 iDb = aDb; |
|
96 iOwnDb = EFalse; |
|
97 } |
|
98 else |
|
99 { |
|
100 iDb = CCommsDatabase::NewL(); |
|
101 iOwnDb = ETrue; |
|
102 } |
|
103 |
|
104 CLOG( ( EApItem, 0, _L( "<- CVpnApEngine::ConstructL" ) ) ); |
|
105 } |
77 } |
106 |
78 |
107 |
79 |
108 // --------------------------------------------------------- |
80 // --------------------------------------------------------- |
109 // CVpnApEngine::CVpnApEngine |
81 // CVpnApEngine::CVpnApEngine |
110 // --------------------------------------------------------- |
82 // --------------------------------------------------------- |
111 // |
83 // |
112 EXPORT_C CVpnApEngine::CVpnApEngine() |
84 EXPORT_C CVpnApEngine::CVpnApEngine() |
113 :iOwnDb( EFalse ) |
85 :iOwnDb( EFalse ) |
114 { |
86 { |
115 CLOG( ( EApItem, 0, _L( "<-> CVpnApEngine::CVpnApEngine" ) ) ); |
|
116 |
|
117 } |
87 } |
118 |
88 |
119 |
89 |
120 |
90 |
121 // --------------------------------------------------------- |
91 // --------------------------------------------------------- |
122 // CVpnApEngine::CreateVpnApL |
92 // CVpnApEngine::CreateVpnApL |
123 // --------------------------------------------------------- |
93 // --------------------------------------------------------- |
124 // |
94 // |
125 EXPORT_C TUint32 CVpnApEngine::CreateVpnApL( CVpnApItem& aVpnApItem ) |
95 EXPORT_C TUint32 CVpnApEngine::CreateVpnApL( CVpnApItem& aVpnApItem ) |
126 { |
96 { |
127 CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::CreateVpnApL" ) ) ); |
97 return 0; |
128 |
|
129 TUint32 retval( 0 ); |
|
130 |
|
131 // Start a transaction |
|
132 TBool ownTransaction = ApCommons::StartPushedTransactionLC( *iDb ); |
|
133 |
|
134 retval = DoCreateVpnApL( ETrue, aVpnApItem ); |
|
135 |
|
136 if ( ownTransaction ) |
|
137 { |
|
138 ApCommons::CommitTransaction( *iDb ); |
|
139 CleanupStack::Pop(); // RollbackTransactionOnLeave |
|
140 } |
|
141 |
|
142 |
|
143 |
|
144 CLOG( ( EApItem, 1, _L( "<- CVpnApEngine::CreateVpnApL" ) ) ); |
|
145 |
|
146 return retval; |
|
147 } |
98 } |
148 |
99 |
149 |
100 |
150 |
101 |
151 |
102 |
158 TUint32 aIapId, |
109 TUint32 aIapId, |
159 TDesC& aPolicy, |
110 TDesC& aPolicy, |
160 TDesC* aProxyServerAddress, |
111 TDesC* aProxyServerAddress, |
161 TUint32 aProxyPort ) |
112 TUint32 aProxyPort ) |
162 { |
113 { |
163 CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::CreateVpnApL..." ) ) ); |
114 return 0; |
164 TUint32 retval( 0 ); |
|
165 |
|
166 CVpnApItem* item = CVpnApItem::NewLC(); |
|
167 |
|
168 item->WriteTextL( EApVpnWapAccessPointName, aName ); |
|
169 item->WriteUint( EApVpnRealIapID, aIapId ); |
|
170 item->WriteTextL( EApVpnPolicyId, aPolicy ); |
|
171 item->WriteLongTextL( EApVpnProxyServerAddress, *aProxyServerAddress ); |
|
172 item->WriteUint( EApVpnProxyPortNumber, aProxyPort ); |
|
173 |
|
174 |
|
175 RVpnServ ps; |
|
176 User::LeaveIfError( ps.Connect() ); |
|
177 CleanupClosePushL<RVpnServ>( ps ); |
|
178 |
|
179 TVpnPolicyDetails det; |
|
180 |
|
181 TVpnPolicyName pName( aPolicy ); |
|
182 |
|
183 TInt err = ps.GetPolicyDetails( pName, det ); |
|
184 |
|
185 // When the policy is deleted (err!=0): |
|
186 // have this leave, in UI display a note about needing to be reconfigured |
|
187 // & set it & policyID to none to look like there is NO policy |
|
188 // which will force the reconfiguration if in the UI |
|
189 User::LeaveIfError( err ); |
|
190 |
|
191 item->WriteTextL( EApVpnPolicy, det.iName ); |
|
192 |
|
193 CreateVpnApL( *item ); |
|
194 |
|
195 CleanupStack::PopAndDestroy(); // ps |
|
196 |
|
197 CleanupStack::PopAndDestroy( item ); |
|
198 |
|
199 CLOG( ( EApItem, 1, _L( "<- CVpnApEngine::CreateVpnApL..." ) ) ); |
|
200 |
|
201 return retval; |
|
202 } |
115 } |
203 |
116 |
204 |
117 |
205 |
118 |
206 |
119 |
280 // CVpnApEngine::IsVpnApL() |
157 // CVpnApEngine::IsVpnApL() |
281 // --------------------------------------------------------- |
158 // --------------------------------------------------------- |
282 // |
159 // |
283 EXPORT_C TBool CVpnApEngine::IsVpnApL( const TUint32 aUid ) |
160 EXPORT_C TBool CVpnApEngine::IsVpnApL( const TUint32 aUid ) |
284 { |
161 { |
285 CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::IsVpnApL" ) ) ); |
162 return EFalse; |
286 |
|
287 TBool retval( EFalse ); |
|
288 // Start a transaction |
|
289 TBool ownTransaction = ApCommons::StartPushedTransactionLC( *iDb ); |
|
290 |
|
291 CCommsDbTableView* wapt; |
|
292 wapt = iDb->OpenViewMatchingUintLC( TPtrC(WAP_IP_BEARER), |
|
293 TPtrC(WAP_ACCESS_POINT_ID), aUid ); |
|
294 User::LeaveIfError( wapt->GotoFirstRecord() ); |
|
295 |
|
296 TUint32 iapid( 0 ); |
|
297 ApCommons::ReadUintL( wapt, TPtrC(WAP_IAP), iapid ); |
|
298 |
|
299 |
|
300 |
|
301 CCommsDbTableView* iapt; |
|
302 iapt = iDb->OpenViewMatchingUintLC( TPtrC(IAP), |
|
303 TPtrC(COMMDB_ID), iapid ); |
|
304 User::LeaveIfError( iapt->GotoFirstRecord() ); |
|
305 |
|
306 HBufC* iapServiceType = ApCommons::ReadText16ValueLC |
|
307 ( |
|
308 iapt, |
|
309 TPtrC(IAP_SERVICE_TYPE) |
|
310 ); |
|
311 |
|
312 retval = ( iapServiceType->Compare( TPtrC(VPN_SERVICE) ) == 0 ); |
|
313 |
|
314 CleanupStack::PopAndDestroy( iapServiceType ); // iapServiceType |
|
315 |
|
316 CleanupStack::PopAndDestroy( iapt ); // iapt |
|
317 |
|
318 CleanupStack::PopAndDestroy( wapt ); // wapt |
|
319 |
|
320 if ( ownTransaction ) |
|
321 { |
|
322 ApCommons::CommitTransaction( *iDb ); |
|
323 CleanupStack::Pop(); // RollbackTransactionOnLeave |
|
324 } |
|
325 |
|
326 CLOG( ( EApItem, 1, _L( "<- CVpnApEngine::IsVpnApL" ) ) ); |
|
327 |
|
328 return retval; |
|
329 } |
163 } |
330 |
164 |
331 |
165 |
332 |
166 |
333 // --------------------------------------------------------- |
167 // --------------------------------------------------------- |
346 // CVpnApEngine::DoCreateVpnApL |
180 // CVpnApEngine::DoCreateVpnApL |
347 // --------------------------------------------------------- |
181 // --------------------------------------------------------- |
348 // |
182 // |
349 TUint32 CVpnApEngine::DoCreateVpnApL( TBool aIsNew, CVpnApItem& aVpnApItem ) |
183 TUint32 CVpnApEngine::DoCreateVpnApL( TBool aIsNew, CVpnApItem& aVpnApItem ) |
350 { |
184 { |
351 CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::DoCreateVpnApL" ) ) ); |
185 return 0; |
352 |
|
353 // internal function, caller MUST initiate a transaction, WE WILL NOT. |
|
354 // create 1 single virtual bearer if not already present |
|
355 // Create a new VPN access point (WAP, etc. with VPN IAP |
|
356 // Create a new VPN record in VPN table |
|
357 |
|
358 CApUtils* util = CApUtils::NewLC( *iDb ); |
|
359 TBool valid = |
|
360 util->IsValidNameL( *aVpnApItem.iName, aVpnApItem.iVpnWapId ); |
|
361 CleanupStack::PopAndDestroy( util ); |
|
362 |
|
363 if ( !valid ) |
|
364 { |
|
365 User::Leave( KErrAlreadyExists ); |
|
366 } |
|
367 |
|
368 WriteVpnDataL( aIsNew, aVpnApItem ); |
|
369 TUint32 virtbearerid = CreateVirtBearerIfNeededL(); |
|
370 aVpnApItem.iVirtualBearerID = virtbearerid; |
|
371 WriteNetworkDataL( aIsNew, aVpnApItem ); |
|
372 WriteVpnIapRecordL( aIsNew, aVpnApItem ); |
|
373 |
|
374 WriteVpnWapApDataL( aIsNew, aVpnApItem ); |
|
375 WriteVpnWapBearerDataL( aIsNew, aVpnApItem ); |
|
376 if ( aVpnApItem.HasProxy() ) |
|
377 { |
|
378 WriteProxyDataL( aIsNew, aVpnApItem ); |
|
379 } |
|
380 else |
|
381 { |
|
382 if ( !aIsNew ) |
|
383 { |
|
384 CCommsDbTableView* iapt; |
|
385 iapt = iDb->OpenViewMatchingUintLC( TPtrC(IAP), TPtrC(COMMDB_ID), |
|
386 aVpnApItem.iVpnIapId ); |
|
387 |
|
388 User::LeaveIfError( iapt->GotoFirstRecord() ); |
|
389 HBufC* servicetype = HBufC::NewLC( KCommsDbSvrMaxFieldLength ); |
|
390 TPtr servptr( servicetype->Des() ); |
|
391 iapt->ReadTextL( TPtrC(IAP_SERVICE_TYPE), servptr ); |
|
392 |
|
393 TRAP_IGNORE( RemoveVpnProxyDataL( aVpnApItem.iVpnTableId ) ); |
|
394 |
|
395 CleanupStack::PopAndDestroy( servicetype ); |
|
396 CleanupStack::PopAndDestroy( iapt ); |
|
397 } |
|
398 } |
|
399 |
|
400 CLOG( ( EApItem, 0, _L( "<- CVpnApEngine::DoCreateVpnApL" ) ) ); |
|
401 |
|
402 return aVpnApItem.iVpnWapId; |
|
403 } |
186 } |
404 |
187 |
405 |
188 |
406 // --------------------------------------------------------- |
189 // --------------------------------------------------------- |
407 // CVpnApEngine::WriteVpnDataL |
190 // CVpnApEngine::WriteVpnDataL |
408 // --------------------------------------------------------- |
191 // --------------------------------------------------------- |
409 // |
192 // |
410 void CVpnApEngine::WriteVpnDataL( TBool aIsNew, CVpnApItem& aVpnApItem ) |
193 void CVpnApEngine::WriteVpnDataL( TBool aIsNew, CVpnApItem& aVpnApItem ) |
411 { |
194 { |
412 CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::WriteVpnDataL" ) ) ); |
|
413 |
|
414 // internal function, caller MUST initiate a transaction, WE WILL NOT. |
|
415 CCommsDbTableView* t; |
|
416 |
|
417 if ( aIsNew ) |
|
418 { |
|
419 t = iDb->OpenTableLC( TPtrC(VPN_SERVICE) ); |
|
420 TInt err = t->InsertRecord( aVpnApItem.iVpnTableId ); |
|
421 if ( err ) |
|
422 { |
|
423 User::LeaveIfError( err ); |
|
424 } |
|
425 } |
|
426 else |
|
427 { |
|
428 t = iDb->OpenViewMatchingUintLC( TPtrC(VPN_SERVICE), |
|
429 TPtrC(COMMDB_ID), |
|
430 aVpnApItem.iVpnTableId ); |
|
431 User::LeaveIfError( t->GotoFirstRecord() ); |
|
432 User::LeaveIfError( t->UpdateRecord() ); |
|
433 } |
|
434 |
|
435 t->WriteTextL( TPtrC(COMMDB_NAME), *aVpnApItem.iName ); |
|
436 |
|
437 t->WriteTextL( TPtrC(VPN_SERVICE_POLICY), *aVpnApItem.iPolicyId ); |
|
438 |
|
439 t->WriteUintL( TPtrC(VPN_SERVICE_IAP), aVpnApItem.iRealIapId ); |
|
440 |
|
441 t->WriteUintL( TPtrC(VPN_SERVICE_NETWORKID), aVpnApItem.iHomeNetwork ); |
|
442 |
|
443 User::LeaveIfError( t->PutRecordChanges( EFalse, EFalse ) ); |
|
444 |
|
445 CleanupStack::PopAndDestroy( t ); // t |
|
446 |
|
447 CLOG( ( EApItem, 0, _L( "<- CVpnApEngine::WriteVpnDataL" ) ) ); |
|
448 |
|
449 } |
195 } |
450 |
196 |
451 |
197 |
452 |
198 |
453 |
199 |
455 // CVpnApEngine::CreateVirtBearerIfNeededL |
201 // CVpnApEngine::CreateVirtBearerIfNeededL |
456 // --------------------------------------------------------- |
202 // --------------------------------------------------------- |
457 // |
203 // |
458 TUint32 CVpnApEngine::CreateVirtBearerIfNeededL() |
204 TUint32 CVpnApEngine::CreateVirtBearerIfNeededL() |
459 { |
205 { |
460 CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::CreateVirtBearerIfNeededL" ) ) ); |
206 return 0; |
461 |
|
462 TUint32 retval( 0 ); |
|
463 |
|
464 CCommsDbTableView* t = NULL; |
|
465 |
|
466 t = iDb->OpenViewMatchingTextLC( TPtrC(VIRTUAL_BEARER), |
|
467 TPtrC(VIRTUAL_BEARER_AGENT), |
|
468 KVpnVirtualBearerAgent ); |
|
469 if ( t->GotoFirstRecord() == KErrNotFound ) |
|
470 { // no such yet, create one |
|
471 TInt err = t->InsertRecord( retval ); |
|
472 if ( err ) |
|
473 { |
|
474 User::LeaveIfError( err ); |
|
475 } |
|
476 t->WriteTextL( TPtrC(COMMDB_NAME), KVpnVirtualBearerName ); |
|
477 t->WriteTextL( TPtrC(VIRTUAL_BEARER_AGENT), KVpnVirtualBearerAgent ); |
|
478 t->WriteTextL( TPtrC(VIRTUAL_BEARER_NIF), KVpnVirtualBearerNif ); |
|
479 |
|
480 t->WriteUintL( TPtrC(LAST_SOCKET_ACTIVITY_TIMEOUT), |
|
481 (TUint32)KNoTimeout ); |
|
482 t->WriteUintL( TPtrC(LAST_SESSION_CLOSED_TIMEOUT), |
|
483 KLastSessionTimeout ); |
|
484 t->WriteUintL( TPtrC(LAST_SOCKET_CLOSED_TIMEOUT), |
|
485 (TUint32)KNoTimeout ); |
|
486 |
|
487 User::LeaveIfError( t->PutRecordChanges( EFalse, EFalse ) ); |
|
488 |
|
489 } |
|
490 else |
|
491 { // there is one, use it |
|
492 t->ReadUintL( TPtrC(COMMDB_ID), retval ); |
|
493 } |
|
494 |
|
495 CleanupStack::PopAndDestroy( t ); // t |
|
496 |
|
497 CLOG( ( EApItem, 0, _L( "<- CVpnApEngine::CreateVirtBearerIfNeededL" ) ) ); |
|
498 |
|
499 return retval; |
|
500 } |
207 } |
501 |
208 |
502 |
209 |
503 |
210 |
504 // --------------------------------------------------------- |
211 // --------------------------------------------------------- |
506 // --------------------------------------------------------- |
213 // --------------------------------------------------------- |
507 // |
214 // |
508 TUint32 CVpnApEngine::WriteVpnIapRecordL( TBool aIsNew, |
215 TUint32 CVpnApEngine::WriteVpnIapRecordL( TBool aIsNew, |
509 CVpnApItem& aVpnApItem ) |
216 CVpnApItem& aVpnApItem ) |
510 { |
217 { |
511 CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::WriteVpnIapRecordL" ) ) ); |
218 return 0; |
512 |
|
513 // internal function, caller MUST initiate a transaction, WE WILL NOT. |
|
514 CCommsDbTableView* t; |
|
515 |
|
516 if ( aIsNew ) |
|
517 { |
|
518 t = iDb->OpenTableLC( TPtrC(IAP) ); |
|
519 TInt err = t->InsertRecord( aVpnApItem.iVpnIapId ); |
|
520 if ( err ) |
|
521 { |
|
522 User::LeaveIfError( err ); |
|
523 } |
|
524 } |
|
525 else |
|
526 { |
|
527 t = iDb->OpenViewMatchingUintLC( TPtrC(IAP), |
|
528 TPtrC(COMMDB_ID), |
|
529 aVpnApItem.iVpnIapId ); |
|
530 User::LeaveIfError( t->GotoFirstRecord() ); |
|
531 User::LeaveIfError( t->UpdateRecord() ); |
|
532 } |
|
533 |
|
534 t->WriteTextL( TPtrC(COMMDB_NAME), *aVpnApItem.iName ); |
|
535 |
|
536 t->WriteUintL( TPtrC(IAP_SERVICE), aVpnApItem.iVpnTableId ); |
|
537 t->WriteTextL( TPtrC(IAP_SERVICE_TYPE), TPtrC(VPN_SERVICE) ); |
|
538 |
|
539 // hardcoded... |
|
540 t->WriteTextL( TPtrC(IAP_BEARER_TYPE), TPtrC(VIRTUAL_BEARER) ); |
|
541 t->WriteUintL( TPtrC(IAP_BEARER), aVpnApItem.iVirtualBearerID ); |
|
542 |
|
543 t->WriteUintL( TPtrC(IAP_NETWORK), aVpnApItem.iVpnIapNetwork ); |
|
544 |
|
545 // Network weighting hardcoded to 0! |
|
546 t->WriteUintL( TPtrC(IAP_NETWORK_WEIGHTING), 0 ); |
|
547 |
|
548 TUint32 loc = GetLocationIdL(); |
|
549 t->WriteUintL( TPtrC(IAP_LOCATION), loc ); |
|
550 |
|
551 User::LeaveIfError( t->PutRecordChanges( EFalse, EFalse ) ); |
|
552 |
|
553 CleanupStack::PopAndDestroy( t ); // t |
|
554 |
|
555 |
|
556 CLOG( ( EApItem, 0, _L( "<- CVpnApEngine::WriteVpnIapRecordL" ) ) ); |
|
557 |
|
558 return aVpnApItem.iVpnIapId; |
|
559 } |
219 } |
560 |
220 |
561 |
221 |
562 |
222 |
563 |
223 |
565 // CVpnApEngine::GetLocationIdL |
225 // CVpnApEngine::GetLocationIdL |
566 // --------------------------------------------------------- |
226 // --------------------------------------------------------- |
567 // |
227 // |
568 TUint32 CVpnApEngine::GetLocationIdL() |
228 TUint32 CVpnApEngine::GetLocationIdL() |
569 { |
229 { |
570 // agreed that the location record having the name 'Mobile' is used |
230 return 0; |
571 CLOG( ( EHandler, 0, _L( "-> CVpnApEngine::GetLocationIdL" ) ) ); |
|
572 |
|
573 CCommsDbTableView* loc; |
|
574 loc = iDb->OpenViewMatchingTextLC( TPtrC(LOCATION), |
|
575 TPtrC(COMMDB_NAME), |
|
576 KLocation ); |
|
577 TInt err = loc->GotoFirstRecord(); |
|
578 |
|
579 User::LeaveIfError( err ); |
|
580 TUint32 id( 0 ); |
|
581 loc->ReadUintL( TPtrC(COMMDB_ID), id ); |
|
582 |
|
583 CleanupStack::PopAndDestroy( loc ); // loc |
|
584 |
|
585 CLOG( ( EHandler, 1, _L( "<- CVpnApEngine::GetLocationIdL" ) ) ); |
|
586 return id; |
|
587 } |
231 } |
588 |
232 |
589 |
233 |
590 |
234 |
591 // --------------------------------------------------------- |
235 // --------------------------------------------------------- |
592 // CVpnApEngine::WriteVpnWapApDataL |
236 // CVpnApEngine::WriteVpnWapApDataL |
593 // --------------------------------------------------------- |
237 // --------------------------------------------------------- |
594 // |
238 // |
595 void CVpnApEngine::WriteVpnWapApDataL( TBool aIsNew, CVpnApItem& aVpnApItem ) |
239 void CVpnApEngine::WriteVpnWapApDataL( TBool aIsNew, CVpnApItem& aVpnApItem ) |
596 { |
240 { |
597 CLOG( ( EHandler, 0, _L( "-> CVpnApEngine::WriteVpnWapApDataL" ) ) ); |
|
598 |
|
599 // internal function, caller MUST initiate a transaction, WE WILL NOT. |
|
600 CCommsDbTableView* wapt; |
|
601 |
|
602 if ( aIsNew ) |
|
603 { |
|
604 wapt = iDb->OpenTableLC( TPtrC(WAP_ACCESS_POINT) ); |
|
605 TInt err = wapt->InsertRecord( aVpnApItem.iVpnWapId ); |
|
606 if ( err ) |
|
607 { |
|
608 User::LeaveIfError( err ); |
|
609 } |
|
610 // CommDB's back-link makes returned UID value unusable, |
|
611 // variable needed just to be able to make the call... |
|
612 } |
|
613 else |
|
614 { |
|
615 wapt = iDb->OpenViewMatchingUintLC( TPtrC(WAP_ACCESS_POINT), |
|
616 TPtrC(COMMDB_ID), |
|
617 aVpnApItem.iVpnWapId ); |
|
618 User::LeaveIfError( wapt->GotoFirstRecord() ); |
|
619 User::LeaveIfError( wapt->UpdateRecord() ); |
|
620 } |
|
621 |
|
622 // it is IP_BEARER |
|
623 wapt->WriteTextL( TPtrC(WAP_CURRENT_BEARER), TPtrC(WAP_IP_BEARER) ); |
|
624 wapt->WriteTextL( TPtrC(COMMDB_NAME), *aVpnApItem.iName ); |
|
625 |
|
626 wapt->WriteLongTextL( TPtrC(WAP_START_PAGE), KEmpty ); |
|
627 |
|
628 User::LeaveIfError( wapt->PutRecordChanges( EFalse, EFalse ) ); |
|
629 |
|
630 CleanupStack::PopAndDestroy( wapt ); // wapt |
|
631 |
|
632 CLOG( ( EHandler, 1, _L( "<- CVpnApEngine::WriteVpnWapApDataL" ) ) ); |
|
633 } |
241 } |
634 |
242 |
635 |
243 |
636 |
244 |
637 // --------------------------------------------------------- |
245 // --------------------------------------------------------- |
639 // --------------------------------------------------------- |
247 // --------------------------------------------------------- |
640 // |
248 // |
641 void CVpnApEngine::WriteVpnWapBearerDataL( TBool aIsNew, |
249 void CVpnApEngine::WriteVpnWapBearerDataL( TBool aIsNew, |
642 CVpnApItem& aVpnApItem ) |
250 CVpnApItem& aVpnApItem ) |
643 { |
251 { |
644 CLOG( ( EHandler, 0, _L( "-> CVpnApEngine::WriteWapBearerDataL" ) ) ); |
|
645 |
|
646 // internal function, caller MUST initiate a transaction, WE WILL NOT. |
|
647 CCommsDbTableView* bearert; |
|
648 if ( aIsNew ) |
|
649 { |
|
650 bearert = iDb->OpenTableLC( TPtrC(WAP_IP_BEARER) ); |
|
651 // CommDB's back-link makes returned UID value unusable, |
|
652 // variable needed just to be able to make the call... |
|
653 TUint32 alma; |
|
654 User::LeaveIfError( bearert->InsertRecord( alma ) ); |
|
655 } |
|
656 else |
|
657 { |
|
658 bearert = iDb->OpenViewMatchingUintLC( TPtrC(WAP_IP_BEARER), |
|
659 TPtrC(WAP_ACCESS_POINT_ID), |
|
660 aVpnApItem.iVpnWapId ); |
|
661 User::LeaveIfError( bearert->GotoFirstRecord() ); |
|
662 User::LeaveIfError( bearert->UpdateRecord() ); |
|
663 } |
|
664 bearert->WriteTextL( TPtrC(WAP_GATEWAY_ADDRESS), KDefWapGatewayIpAddress ); |
|
665 |
|
666 /* |
|
667 bearert->WriteUintL( TPtrC(WAP_WSP_OPTION), |
|
668 aApItem.iIsConnectionTypeContinuous ); |
|
669 bearert->WriteBoolL( TPtrC(WAP_SECURITY), aApItem.iIsWTLSSecurityOn ); |
|
670 */ |
|
671 bearert->WriteUintL( TPtrC(WAP_ACCESS_POINT_ID), aVpnApItem.iVpnWapId ); |
|
672 |
|
673 bearert->WriteUintL( TPtrC(WAP_IAP), aVpnApItem.iVpnIapId ); |
|
674 |
|
675 // Hardcoded to 0 |
|
676 bearert->WriteUintL( TPtrC(WAP_PROXY_PORT), 0 ); |
|
677 |
|
678 User::LeaveIfError( bearert->PutRecordChanges( EFalse, EFalse ) ); |
|
679 |
|
680 CleanupStack::PopAndDestroy( bearert ); // bearert |
|
681 |
|
682 CLOG( ( EHandler, 1, _L( "<- CVpnApEngine::WriteWapBearerDataL" ) ) ); |
|
683 } |
252 } |
684 |
253 |
685 |
254 |
686 |
255 |
687 |
256 |
690 // --------------------------------------------------------- |
259 // --------------------------------------------------------- |
691 // |
260 // |
692 void CVpnApEngine::ReadVpnWapBearerDataL( TUint32 aUid, |
261 void CVpnApEngine::ReadVpnWapBearerDataL( TUint32 aUid, |
693 CVpnApItem& aVpnApItem ) |
262 CVpnApItem& aVpnApItem ) |
694 { |
263 { |
695 CLOG( ( EHandler, 0, _L( "-> CVpnApEngine::ReadVpnWapBearerDataL" ) ) ); |
|
696 |
|
697 // internal function, caller MUST initiate a transaction, WE WILL NOT. |
|
698 CCommsDbTableView* bearert; |
|
699 bearert = iDb->OpenViewMatchingUintLC( TPtrC(WAP_IP_BEARER), |
|
700 TPtrC(WAP_ACCESS_POINT_ID), |
|
701 aUid ); |
|
702 User::LeaveIfError( bearert->GotoFirstRecord() ); |
|
703 aVpnApItem.iVpnWapId = aUid; |
|
704 |
|
705 // for vpn, it is not used.... |
|
706 // bearert->WriteTextL( TPtrC(WAP_GATEWAY_ADDRESS), KEmpty ); |
|
707 |
|
708 /* |
|
709 bearert->WriteUintL( TPtrC(WAP_WSP_OPTION), |
|
710 aApItem.iIsConnectionTypeContinuous ); |
|
711 bearert->WriteBoolL( TPtrC(WAP_SECURITY), aApItem.iIsWTLSSecurityOn ); |
|
712 */ |
|
713 |
|
714 // not neccessary, as we already queried for it and set it... |
|
715 // bearert->ReadUintL( TPtrC(WAP_ACCESS_POINT_ID), aVpnApItem.iVpnWapId ); |
|
716 |
|
717 bearert->ReadUintL( TPtrC(WAP_IAP), aVpnApItem.iVpnIapId ); |
|
718 |
|
719 // Hardcoded to 0, not used, skip it |
|
720 // bearert->WriteUintL( TPtrC(WAP_PROXY_PORT), 0 ); |
|
721 |
|
722 CleanupStack::PopAndDestroy( bearert ); // bearert |
|
723 |
|
724 CLOG( ( EHandler, 1, _L( "<- CVpnApEngine::ReadVpnWapBearerDataL" ) ) ); |
|
725 } |
264 } |
726 |
265 |
727 |
266 |
728 |
267 |
729 |
268 |
731 // CVpnApEngine::ReadVpnWapApDataL |
270 // CVpnApEngine::ReadVpnWapApDataL |
732 // --------------------------------------------------------- |
271 // --------------------------------------------------------- |
733 // |
272 // |
734 void CVpnApEngine::ReadVpnWapApDataL( CVpnApItem& aVpnApItem ) |
273 void CVpnApEngine::ReadVpnWapApDataL( CVpnApItem& aVpnApItem ) |
735 { |
274 { |
736 CLOG( ( EHandler, 0, _L( "-> CVpnApEngine::ReadVpnWapApDataL" ) ) ); |
|
737 |
|
738 // internal function, caller MUST initiate a transaction, WE WILL NOT. |
|
739 CCommsDbTableView* wapt; |
|
740 |
|
741 wapt = iDb->OpenViewMatchingUintLC( TPtrC(WAP_ACCESS_POINT), |
|
742 TPtrC(COMMDB_ID), |
|
743 aVpnApItem.iVpnWapId ); |
|
744 User::LeaveIfError( wapt->GotoFirstRecord() ); |
|
745 |
|
746 // it is IP_BEARER, but as hardcoded, skip it... |
|
747 // wapt->ReadTextL( TPtrC(WAP_CURRENT_BEARER), TPtrC(WAP_IP_BEARER) ); |
|
748 |
|
749 HBufC* buf = NULL; |
|
750 buf = ApCommons::ReadText16ValueLC( wapt, TPtrC(COMMDB_NAME) ); |
|
751 aVpnApItem.WriteTextL( EApVpnWapAccessPointName, *buf ); |
|
752 CleanupStack::PopAndDestroy( buf ); // buf |
|
753 |
|
754 // HARDCODED, skip it |
|
755 //wapt->WriteLongTextL( TPtrC(WAP_START_PAGE), KEmpty ); |
|
756 |
|
757 CleanupStack::PopAndDestroy( wapt ); // wapt |
|
758 |
|
759 CLOG( ( EHandler, 1, _L( "<- CVpnApEngine::ReadVpnWapApDataL" ) ) ); |
|
760 } |
275 } |
761 |
276 |
762 |
277 |
763 |
278 |
764 // --------------------------------------------------------- |
279 // --------------------------------------------------------- |
765 // CVpnApEngine::ReadVpnIapRecordL |
280 // CVpnApEngine::ReadVpnIapRecordL |
766 // --------------------------------------------------------- |
281 // --------------------------------------------------------- |
767 // |
282 // |
768 void CVpnApEngine::ReadVpnIapRecordL( CVpnApItem& aVpnApItem ) |
283 void CVpnApEngine::ReadVpnIapRecordL( CVpnApItem& aVpnApItem ) |
769 { |
284 { |
770 CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::ReadVpnIapRecordL" ) ) ); |
|
771 |
|
772 // internal function, caller MUST initiate a transaction, WE WILL NOT. |
|
773 CCommsDbTableView* t; |
|
774 |
|
775 t = iDb->OpenViewMatchingUintLC( TPtrC(IAP), |
|
776 TPtrC(COMMDB_ID), |
|
777 aVpnApItem.iVpnIapId ); |
|
778 User::LeaveIfError( t->GotoFirstRecord() ); |
|
779 |
|
780 // Name is already set from WAP, skip it |
|
781 // t->WriteTextL( TPtrC(COMMDB_NAME), *aVpnApItem.iName ); |
|
782 |
|
783 t->ReadUintL( TPtrC(IAP_SERVICE), aVpnApItem.iVpnTableId ); |
|
784 |
|
785 // Hardcoded table name, not used, skip it |
|
786 // t->WriteTextL( TPtrC(IAP_SERVICE_TYPE), TPtrC(VPN_SERVICE) ); |
|
787 |
|
788 // hardcoded..., not used, skip it |
|
789 //t->WriteTextL( TPtrC(IAP_BEARER_TYPE), TPtrC(VIRTUAL_BEARER) ); |
|
790 |
|
791 t->ReadUintL( TPtrC(IAP_BEARER), aVpnApItem.iVirtualBearerID ); |
|
792 |
|
793 t->ReadUintL( TPtrC(IAP_NETWORK), aVpnApItem.iHomeNetwork ); |
|
794 |
|
795 // Network weighting hardcoded to 0!, not used, skip it |
|
796 //t->WriteUintL( TPtrC(IAP_NETWORK_WEIGHTING), 0 ); |
|
797 |
|
798 // as location is only written, skip it |
|
799 /* |
|
800 TUint32 loc = GetLocationIdL(); |
|
801 t->WriteUintL( TPtrC(IAP_LOCATION), loc ); |
|
802 */ |
|
803 |
|
804 CleanupStack::PopAndDestroy( t ); // t |
|
805 |
|
806 CLOG( ( EApItem, 0, _L( "<- CVpnApEngine::ReadVpnIapRecordL" ) ) ); |
|
807 } |
285 } |
808 |
286 |
809 |
287 |
810 |
288 |
811 // --------------------------------------------------------- |
289 // --------------------------------------------------------- |
812 // CVpnApEngine::ReadVpnDataL |
290 // CVpnApEngine::ReadVpnDataL |
813 // --------------------------------------------------------- |
291 // --------------------------------------------------------- |
814 // |
292 // |
815 void CVpnApEngine::ReadVpnDataL( CVpnApItem& aVpnApItem ) |
293 void CVpnApEngine::ReadVpnDataL( CVpnApItem& aVpnApItem ) |
816 { |
294 { |
817 CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::ReadVpnDataL" ) ) ); |
|
818 |
|
819 // internal function, caller MUST initiate a transaction, WE WILL NOT. |
|
820 CCommsDbTableView* t; |
|
821 |
|
822 t = iDb->OpenViewMatchingUintLC( TPtrC(VPN_SERVICE), |
|
823 TPtrC(COMMDB_ID), |
|
824 aVpnApItem.iVpnTableId ); |
|
825 User::LeaveIfError( t->GotoFirstRecord() ); |
|
826 |
|
827 // already got from WAP table, skip it here |
|
828 //t->WriteTextL( TPtrC(COMMDB_NAME), *aVpnApItem.iName ); |
|
829 |
|
830 HBufC* buf = NULL; |
|
831 buf = ApCommons::ReadText16ValueLC( t, TPtrC(VPN_SERVICE_POLICY) ); |
|
832 aVpnApItem.WriteTextL( EApVpnPolicyId, *buf ); |
|
833 |
|
834 RVpnServ ps; |
|
835 User::LeaveIfError( ps.Connect() ); |
|
836 CleanupClosePushL<RVpnServ>( ps ); |
|
837 |
|
838 TVpnPolicyName pName( *buf ); |
|
839 |
|
840 TInt policyCount(0); |
|
841 TInt err = ps.EnumeratePolicies(policyCount); |
|
842 if ( !err && policyCount) |
|
843 { |
|
844 CArrayFixFlat<TVpnPolicyInfo>* policyList; |
|
845 policyList = new (ELeave) CArrayFixFlat<TVpnPolicyInfo>(policyCount); |
|
846 CleanupStack::PushL(policyList); |
|
847 |
|
848 err = ps.GetPolicyInfoList(policyList); |
|
849 if ( err ) |
|
850 { |
|
851 aVpnApItem.WriteTextL( EApVpnPolicy, KEmpty ); |
|
852 } |
|
853 else |
|
854 { |
|
855 TBool found(EFalse); |
|
856 for (TInt i(0); i<policyList->Count(); ++i) |
|
857 { |
|
858 if (pName.Compare((*policyList)[i].iId) == 0 ) |
|
859 { |
|
860 aVpnApItem.WriteTextL( EApVpnPolicy, |
|
861 (*policyList)[i].iName ); |
|
862 found = ETrue; |
|
863 break; |
|
864 } |
|
865 } |
|
866 if (!found) |
|
867 { |
|
868 // When the policy is deleted (err!=0): |
|
869 // have this leave, in UI display a note about needing to be reconfigured & |
|
870 // set it & policyID to none to look like there is NO policy |
|
871 // which will force the reconfiguration if in the UI |
|
872 // User::LeaveIfError( err ); |
|
873 aVpnApItem.WriteTextL( EApVpnPolicy, KEmpty ); |
|
874 } |
|
875 } |
|
876 CleanupStack::PopAndDestroy(policyList); |
|
877 } |
|
878 |
|
879 CleanupStack::PopAndDestroy(); // ps |
|
880 |
|
881 CleanupStack::PopAndDestroy( buf ); // buf |
|
882 |
|
883 // These fields might be missing from CommsDat. |
|
884 // ApEngine does not support SNAPs, use CmManager API to get full support. |
|
885 TRAP_IGNORE( t->ReadUintL( TPtrC(VPN_SERVICE_IAP), aVpnApItem.iRealIapId ) ) |
|
886 TRAP_IGNORE( t->ReadUintL( TPtrC(VPN_SERVICE_NETWORKID), aVpnApItem.iHomeNetwork ) ) |
|
887 |
|
888 CleanupStack::PopAndDestroy( t ); // t |
|
889 |
|
890 // Get real IAP name !!!!! |
|
891 CCommsDbTableView* iapt; |
|
892 |
|
893 iapt = iDb->OpenViewMatchingUintLC( TPtrC(IAP), |
|
894 TPtrC(COMMDB_ID), |
|
895 aVpnApItem.iRealIapId ); |
|
896 |
|
897 err = iapt->GotoFirstRecord(); |
|
898 if ( err == KErrNotFound ) |
|
899 { |
|
900 aVpnApItem.WriteTextL( EApVpnRealIapName, KEmpty ); |
|
901 aVpnApItem.iVpnRealWapId = 0; |
|
902 } |
|
903 else |
|
904 { |
|
905 User::LeaveIfError( err ); |
|
906 buf = ApCommons::ReadText16ValueLC( iapt, TPtrC(COMMDB_NAME) ); |
|
907 aVpnApItem.WriteTextL( EApVpnRealIapName, *buf ); |
|
908 CleanupStack::PopAndDestroy( buf ); // buf |
|
909 |
|
910 CApUtils* util = CApUtils::NewLC( *iDb ); |
|
911 |
|
912 TUint32 realwapid = util->WapIdFromIapIdL( aVpnApItem.iRealIapId ); |
|
913 aVpnApItem.iVpnRealWapId = realwapid; |
|
914 |
|
915 CleanupStack::PopAndDestroy( util ); |
|
916 |
|
917 } |
|
918 |
|
919 CleanupStack::PopAndDestroy( iapt ); // t |
|
920 |
|
921 CLOG( ( EApItem, 0, _L( "<- CVpnApEngine::ReadVpnDataL" ) ) ); |
|
922 } |
295 } |
923 |
296 |
924 |
297 |
925 |
298 |
926 |
299 |
936 // --------------------------------------------------------- |
309 // --------------------------------------------------------- |
937 // |
310 // |
938 void CVpnApEngine::WriteProxyDataL( TBool aIsNew, |
311 void CVpnApEngine::WriteProxyDataL( TBool aIsNew, |
939 const CVpnApItem& aVpnApItem ) |
312 const CVpnApItem& aVpnApItem ) |
940 { |
313 { |
941 CLOG( ( EHandler, 0, _L( "-> CVpnApEngine::WriteProxyDataL" ) ) ); |
|
942 |
|
943 CCommsDbTableView* proxies; |
|
944 if ( aIsNew ) |
|
945 { |
|
946 proxies = iDb->OpenTableLC( TPtrC(PROXIES) ); |
|
947 // variable needed just to be able to make the call... |
|
948 TUint32 dummy; |
|
949 User::LeaveIfError( proxies->InsertRecord( dummy ) ); |
|
950 } |
|
951 else |
|
952 { |
|
953 proxies = iDb->OpenViewMatchingTextLC( TPtrC(PROXIES), |
|
954 TPtrC(PROXY_SERVICE_TYPE), |
|
955 TPtrC(VPN_SERVICE) ); |
|
956 TInt err = proxies->GotoFirstRecord(); |
|
957 if ( err == KErrNotFound ) |
|
958 { // originally there were NO proxy, but now it is added |
|
959 // variable needed just to be able to make the call... |
|
960 TUint32 dummy; |
|
961 User::LeaveIfError( proxies->InsertRecord( dummy ) ); |
|
962 } |
|
963 else |
|
964 { |
|
965 // check if it is our proxy... |
|
966 // Add test cases covering this route |
|
967 TUint32 uval; |
|
968 TBool found( EFalse ); |
|
969 do |
|
970 { |
|
971 // Add test cases covering this route |
|
972 proxies->ReadUintL( TPtrC(PROXY_ISP), uval ); |
|
973 if ( uval == aVpnApItem.iVpnTableId ) |
|
974 { |
|
975 found = ETrue; |
|
976 } |
|
977 else |
|
978 { |
|
979 err = proxies->GotoNextRecord(); |
|
980 } |
|
981 } while ( (!err) && (!found) ); |
|
982 if ( !found ) |
|
983 { // no proxy record, add it now |
|
984 // variable needed just to be able to make the call... |
|
985 TUint32 alma; |
|
986 User::LeaveIfError( proxies->InsertRecord( alma ) ); |
|
987 } |
|
988 else |
|
989 { // we found our proxy, use it... |
|
990 User::LeaveIfError( proxies->UpdateRecord() ); |
|
991 } |
|
992 } |
|
993 } |
|
994 proxies->WriteTextL( TPtrC(PROXY_SERVICE_TYPE), |
|
995 TPtrC(VPN_SERVICE) ); |
|
996 |
|
997 proxies->WriteUintL( TPtrC(PROXY_ISP), aVpnApItem.iVpnTableId ); |
|
998 |
|
999 |
|
1000 proxies->WriteLongTextL( TPtrC(PROXY_SERVER_NAME), |
|
1001 *aVpnApItem.iProxyServerAddress ); |
|
1002 |
|
1003 proxies->WriteTextL( TPtrC(PROXY_PROTOCOL_NAME), |
|
1004 KDefProxyProtocolName ); |
|
1005 |
|
1006 proxies->WriteUintL( TPtrC(PROXY_PORT_NUMBER), |
|
1007 aVpnApItem.iProxyPort ); |
|
1008 |
|
1009 TBool useproxy( EFalse ); |
|
1010 if ( ( aVpnApItem.iProxyPort ) |
|
1011 || ( aVpnApItem.iProxyServerAddress->Compare( KEmpty ) != 0 ) ) |
|
1012 { |
|
1013 useproxy = ETrue; |
|
1014 } |
|
1015 |
|
1016 proxies->WriteBoolL( TPtrC(PROXY_USE_PROXY_SERVER), |
|
1017 useproxy ); |
|
1018 |
|
1019 /* |
|
1020 not used, skipped |
|
1021 proxies->WriteLongTextL( TPtrC(PROXY_EXCEPTIONS), |
|
1022 *aApItem.iApProxyExceptions ); |
|
1023 */ |
|
1024 proxies->WriteLongTextL( TPtrC(PROXY_EXCEPTIONS), |
|
1025 KEmpty ); |
|
1026 |
|
1027 User::LeaveIfError( proxies->PutRecordChanges( EFalse, EFalse ) ); |
|
1028 |
|
1029 CleanupStack::PopAndDestroy( proxies ); // proxies |
|
1030 |
|
1031 CLOG( ( EHandler, 1, _L( "<- CVpnApEngine::WriteProxyDataL" ) ) ); |
|
1032 } |
314 } |
1033 |
315 |
1034 |
316 |
1035 |
317 |
1036 // --------------------------------------------------------- |
318 // --------------------------------------------------------- |
1037 // CVpnApEngine::ReadProxyDataL |
319 // CVpnApEngine::ReadProxyDataL |
1038 // --------------------------------------------------------- |
320 // --------------------------------------------------------- |
1039 // |
321 // |
1040 void CVpnApEngine::ReadProxyDataL( CVpnApItem& aVpnApItem ) |
322 void CVpnApEngine::ReadProxyDataL( CVpnApItem& aVpnApItem ) |
1041 { |
323 { |
1042 // internal function, caller MUST initiate a transaction, WE WILL NOT. |
|
1043 CLOG( ( EHandler, 0, _L( "-> CVpnApEngine::ReadProxyDataL" ) ) ); |
|
1044 |
|
1045 CCommsDbTableView* proxies; |
|
1046 proxies = iDb->OpenViewMatchingTextLC( TPtrC(PROXIES), |
|
1047 TPtrC(PROXY_SERVICE_TYPE), |
|
1048 TPtrC(VPN_SERVICE) ); |
|
1049 TInt err = proxies->GotoFirstRecord(); |
|
1050 if ( err != KErrNotFound ) |
|
1051 { |
|
1052 User::LeaveIfError( err ); |
|
1053 } |
|
1054 if ( err != KErrNotFound ) |
|
1055 { |
|
1056 // check if it is our proxy... |
|
1057 // Add test cases covering this route |
|
1058 TUint32 uval; |
|
1059 TBool found( EFalse ); |
|
1060 do |
|
1061 { |
|
1062 // Add test cases covering this route |
|
1063 proxies->ReadUintL( TPtrC(PROXY_ISP), uval ); |
|
1064 if ( uval == aVpnApItem.iVpnTableId ) |
|
1065 { |
|
1066 found = ETrue; |
|
1067 } |
|
1068 else |
|
1069 { |
|
1070 err = proxies->GotoNextRecord(); |
|
1071 } |
|
1072 } while ( (!err) && (!found) ); |
|
1073 if ( found ) |
|
1074 { // it is our proxy record, use it |
|
1075 HBufC* buf = ApCommons::ReadLongTextLC( proxies, |
|
1076 TPtrC(PROXY_SERVER_NAME), |
|
1077 err ); |
|
1078 if ( err != KErrUnknown ) |
|
1079 { |
|
1080 aVpnApItem.WriteLongTextL( EApVpnProxyServerAddress, *buf ); |
|
1081 } |
|
1082 |
|
1083 CleanupStack::PopAndDestroy( buf ); // buf |
|
1084 |
|
1085 TUint32 tempint; |
|
1086 |
|
1087 ApCommons::ReadUintL( proxies, TPtrC(PROXY_PORT_NUMBER), tempint ); |
|
1088 aVpnApItem.WriteUint( EApVpnProxyPortNumber, tempint ); |
|
1089 |
|
1090 /* |
|
1091 buf = ApCommons::ReadLongTextLC( proxies, |
|
1092 TPtrC(PROXY_EXCEPTIONS), |
|
1093 err ); |
|
1094 aVpnApItem.WriteLongTextL( EApProxyExceptions, *buf ); |
|
1095 CleanupStack::PopAndDestroy( buf ); // buf |
|
1096 */ |
|
1097 } |
|
1098 } |
|
1099 CleanupStack::PopAndDestroy( proxies ); // proxies |
|
1100 |
|
1101 CLOG( ( EHandler, 1, _L( "<- CVpnApEngine::ReadProxyDataL" ) ) ); |
|
1102 } |
324 } |
1103 |
325 |
1104 |
326 |
1105 |
327 |
1106 |
328 |
1108 // CVpnApEngine::RemoveVpnProxyDataL |
330 // CVpnApEngine::RemoveVpnProxyDataL |
1109 // --------------------------------------------------------- |
331 // --------------------------------------------------------- |
1110 // |
332 // |
1111 void CVpnApEngine::RemoveVpnProxyDataL( TUint32 aIspId ) |
333 void CVpnApEngine::RemoveVpnProxyDataL( TUint32 aIspId ) |
1112 { |
334 { |
1113 // internal function, caller MUST initiate a transaction, WE WILL NOT. |
|
1114 CLOG( ( EHandler, 0, _L( "-> CVpnApEngine::RemoveProxyDataL" ) ) ); |
|
1115 |
|
1116 // Add test cases covering all this functions routes |
|
1117 |
|
1118 CCommsDbTableView* proxies; |
|
1119 proxies = iDb->OpenViewMatchingTextLC( TPtrC(PROXIES), |
|
1120 TPtrC(PROXY_SERVICE_TYPE), |
|
1121 TPtrC(VPN_SERVICE) ); |
|
1122 TInt err = proxies->GotoFirstRecord(); |
|
1123 if ( err == KErrNone ) |
|
1124 { // now get OUR proxy record |
|
1125 TUint32 uval; |
|
1126 TBool found( EFalse ); |
|
1127 do |
|
1128 { |
|
1129 // Add test cases covering this route |
|
1130 proxies->ReadUintL( TPtrC(PROXY_ISP), uval ); |
|
1131 if ( uval == aIspId ) |
|
1132 { |
|
1133 found = ETrue; |
|
1134 } |
|
1135 else |
|
1136 { |
|
1137 err = proxies->GotoNextRecord(); |
|
1138 } |
|
1139 } while ( (!err) && (!found) ); |
|
1140 if ( found ) |
|
1141 { |
|
1142 User::LeaveIfError( proxies->DeleteRecord() ); |
|
1143 } |
|
1144 else |
|
1145 { |
|
1146 // silently ignore KErrNotFound. It is caused by incorrect DB, |
|
1147 // we are 'repairing it' this way. |
|
1148 if ( err != KErrNotFound ) |
|
1149 { |
|
1150 User::LeaveIfError( err ); |
|
1151 } |
|
1152 } |
|
1153 } |
|
1154 else |
|
1155 { |
|
1156 // silently ignore KErrNotFound. It is caused by incorrect DB, |
|
1157 // we are 'repairing it' this way. |
|
1158 if ( err != KErrNotFound ) |
|
1159 { |
|
1160 User::LeaveIfError( err ); |
|
1161 } |
|
1162 } |
|
1163 CleanupStack::PopAndDestroy( proxies ); // proxies |
|
1164 |
|
1165 CLOG( ( EHandler, 1, _L( "<- CVpnApEngine::RemoveProxyDataL" ) ) ); |
|
1166 } |
335 } |
1167 |
336 |
1168 |
337 |
1169 |
338 |
1170 // --------------------------------------------------------- |
339 // --------------------------------------------------------- |
1171 // CVpnApEngine::DoDeleteVpnL |
340 // CVpnApEngine::DoDeleteVpnL |
1172 // --------------------------------------------------------- |
341 // --------------------------------------------------------- |
1173 // |
342 // |
1174 void CVpnApEngine::DoDeleteVpnL( TUint32 aUid ) |
343 void CVpnApEngine::DoDeleteVpnL( TUint32 aUid ) |
1175 { |
344 { |
1176 CLOG( ( EHandler, 0, _L( "-> CVpnApEngine::DoDeleteVpnL" ) ) ); |
|
1177 |
|
1178 // when deleting, need to delete: |
|
1179 // homenetwork |
|
1180 // VPN_TABLE record |
|
1181 // IAP's VPN record |
|
1182 // WAP's VPN record |
|
1183 // IP_BEARER's record |
|
1184 // proxy record |
|
1185 |
|
1186 // first make sure that the given AP is not in use |
|
1187 CApUtils* utils = CApUtils::NewLC( *iDb ); |
|
1188 if ( utils->IsAPInUseL( aUid ) ) |
|
1189 { |
|
1190 User::Leave( KErrInUse ); |
|
1191 } |
|
1192 CleanupStack::PopAndDestroy( utils ); // utils |
|
1193 |
|
1194 CCommsDbTableView* wapt; |
|
1195 wapt = iDb->OpenViewMatchingUintLC( TPtrC(WAP_ACCESS_POINT), |
|
1196 TPtrC(COMMDB_ID), aUid ); |
|
1197 User::LeaveIfError( wapt->GotoFirstRecord() ); |
|
1198 HBufC* buf = HBufC::NewLC( KCommsDbSvrMaxFieldLength ); |
|
1199 TPtr ptr( buf->Des() ); |
|
1200 wapt->ReadTextL( TPtrC(WAP_CURRENT_BEARER), |
|
1201 ptr ); // see declaration for comments! |
|
1202 |
|
1203 if ( *buf == TPtrC(WAP_IP_BEARER) ) |
|
1204 { |
|
1205 // get serviceType |
|
1206 CCommsDbTableView* bearert; |
|
1207 bearert = iDb->OpenViewMatchingUintLC( TPtrC(WAP_IP_BEARER), |
|
1208 TPtrC(WAP_ACCESS_POINT_ID), |
|
1209 aUid ); |
|
1210 |
|
1211 User::LeaveIfError( bearert->GotoFirstRecord() ); |
|
1212 |
|
1213 TUint32 ipbearerid; |
|
1214 ApCommons::ReadUintL( bearert, TPtrC(COMMDB_ID), ipbearerid ); |
|
1215 |
|
1216 TUint32 iapid; |
|
1217 ApCommons::ReadUintL( bearert, TPtrC(WAP_IAP), iapid ); |
|
1218 |
|
1219 CCommsDbTableView* iapt; |
|
1220 iapt = iDb->OpenViewMatchingUintLC( TPtrC(IAP), TPtrC(COMMDB_ID), |
|
1221 iapid ); |
|
1222 |
|
1223 User::LeaveIfError( iapt->GotoFirstRecord() ); |
|
1224 HBufC* servicetype = HBufC::NewLC( KCommsDbSvrMaxFieldLength ); |
|
1225 TPtr servptr( servicetype->Des() ); |
|
1226 iapt->ReadTextL( TPtrC(IAP_SERVICE_TYPE), servptr ); |
|
1227 TUint32 ispid; |
|
1228 iapt->ReadUintL( TPtrC(IAP_SERVICE), ispid ); |
|
1229 TUint32 networkid; |
|
1230 iapt->ReadUintL( TPtrC(IAP_NETWORK), networkid ); |
|
1231 |
|
1232 RemoveNetworkDataL( networkid ); |
|
1233 |
|
1234 if ( *servicetype == TPtrC(VPN_SERVICE) ) |
|
1235 { |
|
1236 RemoveRecordL( TPtrC(VPN_SERVICE), ispid ); |
|
1237 RemoveRecordL( TPtrC(IAP), iapid ); |
|
1238 } |
|
1239 else |
|
1240 { // what to do if none of them??? |
|
1241 User::Leave( KErrInvalidBearer ); |
|
1242 } |
|
1243 RemoveVpnProxyDataL( ispid ); |
|
1244 RemoveRecordL( TPtrC(WAP_IP_BEARER), ipbearerid ); |
|
1245 // servicetype, iapt, bearert |
|
1246 CleanupStack::PopAndDestroy( 3, bearert ); |
|
1247 } |
|
1248 else |
|
1249 { // sms, |
|
1250 User::Leave( KErrInvalidBearerType ); |
|
1251 } |
|
1252 |
|
1253 RemoveRecordL( TPtrC(WAP_ACCESS_POINT), aUid ); |
|
1254 |
|
1255 CleanupStack::PopAndDestroy( 2, wapt ); // buf, wapt |
|
1256 |
|
1257 CLOG( ( EHandler, 1, _L( "<- CVpnApEngine::DoDeleteVpnL" ) ) ); |
|
1258 } |
345 } |
1259 |
346 |
1260 |
347 |
1261 |
348 |
1262 // --------------------------------------------------------- |
349 // --------------------------------------------------------- |
1263 // CVpnApEngine::RemoveRecordL |
350 // CVpnApEngine::RemoveRecordL |
1264 // --------------------------------------------------------- |
351 // --------------------------------------------------------- |
1265 // |
352 // |
1266 void CVpnApEngine::RemoveRecordL( const TDesC& aTable, TUint32 aUid ) |
353 void CVpnApEngine::RemoveRecordL( const TDesC& aTable, TUint32 aUid ) |
1267 { |
354 { |
1268 CLOG( ( EHandler, 0, _L( "-> CVpnApEngine::RemoveRecordL" ) ) ); |
|
1269 |
|
1270 CCommsDbTableView* t = iDb->OpenViewMatchingUintLC( |
|
1271 aTable, |
|
1272 TPtrC(COMMDB_ID), |
|
1273 aUid ); |
|
1274 TInt res = t->GotoFirstRecord(); // OK. |
|
1275 if ( res == KErrNone ) |
|
1276 { // exists, delete it |
|
1277 User::LeaveIfError( t->DeleteRecord() ); |
|
1278 } |
|
1279 else |
|
1280 { |
|
1281 // silently ignore KErrNotFound. It is caused by incorrect DB, |
|
1282 // we are 'repairing it' this way. |
|
1283 if ( res != KErrNotFound ) |
|
1284 { |
|
1285 User::Leave( res ); |
|
1286 } |
|
1287 } |
|
1288 CleanupStack::PopAndDestroy( t ); // t |
|
1289 |
|
1290 CLOG( ( EHandler, 1, _L( "<- CVpnApEngine::RemoveRecordL" ) ) ); |
|
1291 } |
355 } |
1292 |
356 |
1293 |
357 |
1294 |
358 |
1295 |
359 |
1299 // --------------------------------------------------------- |
363 // --------------------------------------------------------- |
1300 // |
364 // |
1301 void CVpnApEngine::WriteNetworkDataL( TBool aIsNew, |
365 void CVpnApEngine::WriteNetworkDataL( TBool aIsNew, |
1302 CVpnApItem& aVpnApItem ) |
366 CVpnApItem& aVpnApItem ) |
1303 { |
367 { |
1304 CLOG( ( EHandler, 0, _L( "-> CVpnApEngine::WriteNetworkDataL" ) ) ); |
|
1305 |
|
1306 if ( aVpnApItem.iVpnIapNetwork == 0 ) |
|
1307 { |
|
1308 CCommsDbTableView* networks; |
|
1309 HBufC* buf = HBufC::NewLC( KApEngineMaxSql ); |
|
1310 if ( aIsNew ) |
|
1311 { |
|
1312 networks = iDb->OpenTableLC( TPtrC(NETWORK) ); |
|
1313 TUint32 netId; |
|
1314 User::LeaveIfError( networks->InsertRecord( netId ) ); |
|
1315 aVpnApItem.iVpnIapNetwork = netId; |
|
1316 } |
|
1317 else |
|
1318 { |
|
1319 networks = iDb->OpenViewMatchingUintLC( |
|
1320 TPtrC(NETWORK), TPtrC(COMMDB_ID), |
|
1321 aVpnApItem.iVpnIapNetwork ); |
|
1322 |
|
1323 TInt err = networks->GotoFirstRecord(); |
|
1324 if ( err == KErrNotFound ) |
|
1325 { // originally there were NO network, but now it is added |
|
1326 TUint32 netId; |
|
1327 User::LeaveIfError( networks->InsertRecord( netId ) ); |
|
1328 aVpnApItem.iVpnIapNetwork = netId; |
|
1329 } |
|
1330 else |
|
1331 { |
|
1332 User::LeaveIfError( networks->UpdateRecord() ); |
|
1333 } |
|
1334 } |
|
1335 networks->WriteTextL( TPtrC(COMMDB_NAME), *aVpnApItem.iName ); |
|
1336 |
|
1337 User::LeaveIfError( networks->PutRecordChanges( EFalse, EFalse ) ); |
|
1338 |
|
1339 CleanupStack::PopAndDestroy( networks ); // networks |
|
1340 CleanupStack::PopAndDestroy( buf ); // buf |
|
1341 } |
|
1342 |
|
1343 CLOG( ( EHandler, 1, _L( "<- CVpnApEngine::WriteNetworkDataL" ) ) ); |
|
1344 } |
368 } |
1345 |
369 |
1346 |
370 |
1347 // --------------------------------------------------------- |
371 // --------------------------------------------------------- |
1348 // CVpnApEngine::ReadNetworkDataL |
372 // CVpnApEngine::ReadNetworkDataL |
1349 // --------------------------------------------------------- |
373 // --------------------------------------------------------- |
1350 // |
374 // |
1351 void CVpnApEngine::ReadNetworkDataL( CVpnApItem& aVpnApItem ) |
375 void CVpnApEngine::ReadNetworkDataL( CVpnApItem& aVpnApItem ) |
1352 { |
376 { |
1353 // internal function, caller MUST initiate a transaction, WE WILL NOT. |
|
1354 CLOG( ( EHandler, 0, _L( "-> CVpnApEngine::ReadNetworkDataL" ) ) ); |
|
1355 |
|
1356 CCommsDbTableView* networks; |
|
1357 networks = iDb->OpenViewMatchingUintLC( TPtrC(NETWORK), |
|
1358 TPtrC(COMMDB_ID), |
|
1359 aVpnApItem.iVpnIapNetwork ); |
|
1360 |
|
1361 TInt err = networks->GotoFirstRecord(); |
|
1362 |
|
1363 if ( err != KErrNotFound ) |
|
1364 { |
|
1365 User::LeaveIfError( err ); |
|
1366 } |
|
1367 if ( err != KErrNotFound ) |
|
1368 { |
|
1369 HBufC* buf = ApCommons::ReadText16ValueLC( networks, |
|
1370 TPtrC(COMMDB_NAME) ); |
|
1371 if ( err != KErrUnknown ) |
|
1372 { |
|
1373 aVpnApItem.WriteTextL( EApVpnIapNetworkName, *buf ); |
|
1374 } |
|
1375 |
|
1376 CleanupStack::PopAndDestroy( buf ); // buf |
|
1377 } |
|
1378 else |
|
1379 { // not found, set to NONE |
|
1380 aVpnApItem.WriteTextL( EApVpnIapNetworkName, KEmpty ); |
|
1381 } |
|
1382 CleanupStack::PopAndDestroy( networks ); // networks |
|
1383 |
|
1384 CLOG( ( EHandler, 1, _L( "<- CVpnApEngine::ReadNetworkDataL" ) ) ); |
|
1385 } |
377 } |
1386 |
378 |
1387 |
379 |
1388 |
380 |
1389 // --------------------------------------------------------- |
381 // --------------------------------------------------------- |
1390 // CVpnApEngine::RemoveNetworkDataL |
382 // CVpnApEngine::RemoveNetworkDataL |
1391 // --------------------------------------------------------- |
383 // --------------------------------------------------------- |
1392 // |
384 // |
1393 void CVpnApEngine::RemoveNetworkDataL( TUint32 aIspId ) |
385 void CVpnApEngine::RemoveNetworkDataL( TUint32 aIspId ) |
1394 { |
386 { |
1395 // internal function, caller MUST initiate a transaction, WE WILL NOT. |
|
1396 CLOG( ( EHandler, 0, _L( "-> CVpnApEngine::RemoveNetworkDataL" ) ) ); |
|
1397 |
|
1398 RemoveRecordL( TPtrC(NETWORK), aIspId ); |
|
1399 |
|
1400 CLOG( ( EHandler, 1, _L( "<- CVpnApEngine::RemoveNetworkDataL" ) ) ); |
|
1401 } |
387 } |
1402 |
388 |
1403 // End of File |
389 // End of File |
1404 |
390 |