1 /* |
|
2 * Copyright (c) 2002 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: Declaration of the CVpnApItem class. |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 // INCLUDE FILES |
|
20 |
|
21 #include <f32file.h> |
|
22 #include <bautils.h> |
|
23 #include <barsc.h> |
|
24 #include <apengine.rsg> |
|
25 #include <txtetext.h> |
|
26 #include <data_caging_path_literals.hrh> |
|
27 |
|
28 #include "VpnApItem.h" |
|
29 #include "ApEngineLogger.h" |
|
30 #include "ApEngineConsts.h" |
|
31 #include "ApEngineCommons.h" |
|
32 |
|
33 |
|
34 |
|
35 // CONSTANTS |
|
36 const TInt KApItemInitialTxtBufSize = 0; |
|
37 const TInt KVpnDefProxyPortNumber = 80; |
|
38 |
|
39 // DUPLCIATE as I can not touch original, but do need the file here, too... |
|
40 /// ROM drive. |
|
41 _LIT( KApEngineResDriveZ, "z:" ); |
|
42 /// ApEngine resource file name. |
|
43 _LIT( KApEngineResFileName, "ApEngine.rsc" ); |
|
44 |
|
45 |
|
46 |
|
47 // ================= MEMBER FUNCTIONS ======================= |
|
48 // --------------------------------------------------------- |
|
49 // CVpnApItem::NewLC |
|
50 // --------------------------------------------------------- |
|
51 // |
|
52 EXPORT_C CVpnApItem* CVpnApItem::NewLC() |
|
53 { |
|
54 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::NewL" ) ) ); |
|
55 |
|
56 CVpnApItem* self = new ( ELeave ) CVpnApItem; |
|
57 CleanupStack::PushL( self ); |
|
58 self->ConstructL(); |
|
59 |
|
60 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::NewL" ) ) ); |
|
61 |
|
62 return self; |
|
63 } |
|
64 |
|
65 |
|
66 // --------------------------------------------------------- |
|
67 // CVpnApItem::~CVpnApItem |
|
68 // --------------------------------------------------------- |
|
69 // |
|
70 EXPORT_C CVpnApItem::~CVpnApItem() |
|
71 { |
|
72 CLOG( ( EApItem, 0, _L( "<-> CVpnApItem::~CVpnApItem" ) ) ); |
|
73 |
|
74 delete iName; |
|
75 delete iPolicy; |
|
76 delete iProxyServerAddress; |
|
77 delete iRealIapName; |
|
78 delete iPolicyId; |
|
79 delete iVpnIapNetworkName; |
|
80 |
|
81 } |
|
82 |
|
83 |
|
84 // --------------------------------------------------------- |
|
85 // CVpnApItem::ConstructL |
|
86 // --------------------------------------------------------- |
|
87 // |
|
88 EXPORT_C void CVpnApItem::ConstructL() |
|
89 { |
|
90 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::ConstructL" ) ) ); |
|
91 |
|
92 // as we are in ConstructL called from NewLC, |
|
93 // 'this' is already on the CleanupStack, |
|
94 // so do not push members onto it! |
|
95 iName = HBufC::NewL( KApItemInitialTxtBufSize ); |
|
96 iPolicy = HBufC::NewL( KApItemInitialTxtBufSize ); |
|
97 iProxyServerAddress = HBufC::NewL( KApItemInitialTxtBufSize ); |
|
98 iRealIapName = HBufC::NewL( KApItemInitialTxtBufSize ); |
|
99 iPolicyId = HBufC::NewL( KApItemInitialTxtBufSize ); |
|
100 iVpnIapNetworkName = HBufC::NewL( KApItemInitialTxtBufSize ); |
|
101 |
|
102 RFs fs; |
|
103 CleanupClosePushL<RFs>( fs ); |
|
104 User::LeaveIfError( fs.Connect() ); |
|
105 |
|
106 // can't use resource here because it is not added yet.... |
|
107 TFileName resourceFile; |
|
108 resourceFile.Append( KApEngineResDriveZ ); |
|
109 resourceFile.Append( KDC_RESOURCE_FILES_DIR ); |
|
110 resourceFile.Append( KApEngineResFileName ); |
|
111 BaflUtils::NearestLanguageFile( fs, resourceFile ); |
|
112 |
|
113 RResourceFile rf; |
|
114 CleanupClosePushL<RResourceFile>( rf ); |
|
115 rf.OpenL( fs, resourceFile ); |
|
116 rf.ConfirmSignatureL( 0 ); |
|
117 HBufC8* readBuffer = rf.AllocReadLC( R_APNG_DEFAULT_VPN_AP_NAME ); |
|
118 // as we are expecting HBufC16... |
|
119 __ASSERT_DEBUG( ( readBuffer->Length()%2 ) == 0, |
|
120 ApCommons::Panic( EWrongResourceFormat ) ); |
|
121 const TPtrC16 ptrReadBuffer( (TText16*) readBuffer->Ptr(), |
|
122 ( readBuffer->Length() + 1 ) >> 1 ); |
|
123 HBufC16* textBuffer=HBufC16::NewL( ptrReadBuffer.Length() ); |
|
124 *textBuffer=ptrReadBuffer; |
|
125 CleanupStack::PopAndDestroy( readBuffer ); // readbuffer |
|
126 CleanupStack::PushL( textBuffer ); |
|
127 |
|
128 WriteTextL( EApVpnWapAccessPointName, *textBuffer ); |
|
129 |
|
130 WriteUint( EApVpnProxyPortNumber, KVpnDefProxyPortNumber ); |
|
131 |
|
132 CleanupStack::PopAndDestroy( 3 ); // textbuffer, fs, rf |
|
133 |
|
134 CLOG( ( EApItem, 0, _L( "<- CVpnApItem::ConstructL" ) ) ); |
|
135 |
|
136 } |
|
137 |
|
138 |
|
139 // --------------------------------------------------------- |
|
140 // CVpnApItem::CVpnApItem |
|
141 // --------------------------------------------------------- |
|
142 // |
|
143 EXPORT_C CVpnApItem::CVpnApItem() |
|
144 { |
|
145 CLOG( ( EApItem, 0, _L( "<-> CVpnApItem::CVpnApItem" ) ) ); |
|
146 } |
|
147 |
|
148 |
|
149 |
|
150 // --------------------------------------------------------- |
|
151 // CVpnApItem::CopyFromL |
|
152 // --------------------------------------------------------- |
|
153 // |
|
154 EXPORT_C void CVpnApItem::CopyFromL( const CVpnApItem& aCopyFrom ) |
|
155 { |
|
156 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::CopyFromL" ) ) ); |
|
157 |
|
158 iVpnTableId = aCopyFrom.iVpnTableId; |
|
159 iVpnIapId = aCopyFrom.iVpnIapId; |
|
160 iRealIapId = aCopyFrom.iRealIapId; |
|
161 iVpnRealWapId = aCopyFrom.iVpnRealWapId; |
|
162 iVirtualBearerID = aCopyFrom.iVirtualBearerID; |
|
163 iProxyPort = aCopyFrom.iProxyPort; |
|
164 iHomeNetwork = aCopyFrom.iHomeNetwork; |
|
165 |
|
166 WriteTextL( EApVpnWapAccessPointName, *aCopyFrom.iName ); |
|
167 WriteTextL( EApVpnPolicy, *aCopyFrom.iPolicy ); |
|
168 WriteLongTextL( EApVpnProxyServerAddress, *aCopyFrom.iProxyServerAddress ); |
|
169 WriteTextL( EApVpnRealIapName, *aCopyFrom.iRealIapName ); |
|
170 WriteTextL( EApVpnPolicyId, *aCopyFrom.iPolicyId ); |
|
171 WriteTextL( EApVpnIapNetworkName, *aCopyFrom.iVpnIapNetworkName ); |
|
172 |
|
173 CLOG( ( EApItem, 0, _L( "<- CVpnApItem::CopyFromL" ) ) ); |
|
174 } |
|
175 |
|
176 |
|
177 |
|
178 |
|
179 // --------------------------------------------------------- |
|
180 // CVpnApItem::operator== |
|
181 // --------------------------------------------------------- |
|
182 // |
|
183 EXPORT_C TBool CVpnApItem::operator==( const CVpnApItem& aItem ) const |
|
184 { |
|
185 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::operator==" ) ) ); |
|
186 |
|
187 TBool retval( EFalse ); |
|
188 |
|
189 if ( ( iVpnTableId == aItem.iVpnTableId ) && |
|
190 ( iVpnIapId == aItem.iVpnIapId ) && |
|
191 ( iRealIapId == aItem.iRealIapId ) && |
|
192 ( iVpnRealWapId == aItem.iVpnRealWapId ) && |
|
193 ( iVirtualBearerID == aItem.iVirtualBearerID ) && |
|
194 ( iProxyPort == aItem.iProxyPort ) && |
|
195 ( iHomeNetwork == aItem.iHomeNetwork ) |
|
196 ) |
|
197 { |
|
198 if ( |
|
199 ( iName->Compare( *aItem.iName ) == 0 ) |
|
200 && ( iPolicy->Compare( *aItem.iPolicy ) == 0 ) |
|
201 && ( iProxyServerAddress->Compare( |
|
202 *aItem.iProxyServerAddress ) == 0 ) |
|
203 && ( iRealIapName->Compare( *aItem.iRealIapName ) == 0 ) |
|
204 && ( iPolicyId->Compare( *aItem.iPolicyId ) == 0 ) |
|
205 && ( iVpnIapNetworkName->Compare( |
|
206 *aItem.iVpnIapNetworkName ) == 0 ) |
|
207 ) |
|
208 { |
|
209 retval = ETrue; |
|
210 } |
|
211 } |
|
212 |
|
213 CLOG( ( EApItem, 0, _L( "<- CVpnApItem::operator==" ) ) ); |
|
214 |
|
215 return ( retval ); |
|
216 } |
|
217 |
|
218 |
|
219 // --------------------------------------------------------- |
|
220 // CVpnApItem::operator!= |
|
221 // --------------------------------------------------------- |
|
222 // |
|
223 EXPORT_C TBool CVpnApItem::operator!=( const CVpnApItem& aItem ) const |
|
224 { |
|
225 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::operator!=" ) ) ); |
|
226 |
|
227 TBool ret = ( *this == aItem ); |
|
228 |
|
229 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::operator!=" ) ) ); |
|
230 return ( !ret ); |
|
231 } |
|
232 |
|
233 |
|
234 |
|
235 // --------------------------------------------------------- |
|
236 // CVpnApItem::ReadTextL |
|
237 // --------------------------------------------------------- |
|
238 // |
|
239 EXPORT_C void CVpnApItem::ReadTextL( const TVpnApMember aColumn, |
|
240 TDes16& aValue ) |
|
241 { |
|
242 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::ReadTextL" ) ) ); |
|
243 |
|
244 switch ( aColumn ) |
|
245 { |
|
246 case EApVpnWapAccessPointName: |
|
247 { |
|
248 aValue.SetLength( iName->Length() ); |
|
249 aValue.Format( KFormat, iName ); |
|
250 break; |
|
251 } |
|
252 case EApVpnProxyServerAddress: |
|
253 { |
|
254 // make it large enough to hold |
|
255 aValue.SetLength( iProxyServerAddress->Length() ); |
|
256 aValue.Format( KFormat, iProxyServerAddress ); |
|
257 break; |
|
258 } |
|
259 case EApVpnPolicy: |
|
260 { |
|
261 aValue.SetLength( iPolicy->Length() ); |
|
262 aValue.Format( KFormat, iPolicy ); |
|
263 break; |
|
264 } |
|
265 case EApVpnRealIapName: |
|
266 { |
|
267 aValue.SetLength( iRealIapName->Length() ); |
|
268 aValue.Format( KFormat, iRealIapName ); |
|
269 break; |
|
270 } |
|
271 case EApVpnPolicyId: |
|
272 { |
|
273 aValue.SetLength( iPolicyId->Length() ); |
|
274 aValue.Format( KFormat, iPolicyId ); |
|
275 break; |
|
276 } |
|
277 case EApVpnIapNetworkName: |
|
278 { |
|
279 aValue.SetLength( iVpnIapNetworkName->Length() ); |
|
280 aValue.Format( KFormat, iVpnIapNetworkName ); |
|
281 break; |
|
282 } |
|
283 default: |
|
284 { |
|
285 __ASSERT_DEBUG( EFalse, ApCommons::Panic( EInvalidColumn ) ); |
|
286 User::Leave( KErrInvalidColumn ); |
|
287 } |
|
288 } |
|
289 |
|
290 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::ReadTextL" ) ) ); |
|
291 } |
|
292 |
|
293 |
|
294 |
|
295 // --------------------------------------------------------- |
|
296 // CVpnApItem::ReadConstLongTextL |
|
297 // --------------------------------------------------------- |
|
298 // |
|
299 EXPORT_C const HBufC* CVpnApItem::ReadConstLongTextL( |
|
300 const TVpnApMember aColumn |
|
301 ) |
|
302 { |
|
303 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::ReadConstLongTextL" ) ) ); |
|
304 |
|
305 HBufC* retval = NULL; |
|
306 switch ( aColumn ) |
|
307 { |
|
308 case EApVpnProxyServerAddress: |
|
309 { |
|
310 retval = iProxyServerAddress; |
|
311 break; |
|
312 } |
|
313 default: |
|
314 { |
|
315 __ASSERT_DEBUG( EFalse, ApCommons::Panic( EInvalidColumn ) ); |
|
316 User::Leave( KErrInvalidColumn ); |
|
317 break; |
|
318 } |
|
319 } |
|
320 |
|
321 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::ReadConstLongTextL" ) ) ); |
|
322 return retval; |
|
323 } |
|
324 |
|
325 |
|
326 // --------------------------------------------------------- |
|
327 // CVpnApItem::ReadUint |
|
328 // --------------------------------------------------------- |
|
329 // |
|
330 EXPORT_C TInt CVpnApItem::ReadUint( const TVpnApMember aColumn, |
|
331 TUint32& aValue ) |
|
332 { |
|
333 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::ReadUint" ) ) ); |
|
334 |
|
335 TInt retval ( KErrNone ); |
|
336 switch ( aColumn ) |
|
337 { |
|
338 case EApVpnWapAccessPointID: |
|
339 { |
|
340 aValue = iVpnWapId; |
|
341 break; |
|
342 } |
|
343 case EApVpnIapID: |
|
344 { |
|
345 aValue = iVpnIapId; |
|
346 break; |
|
347 } |
|
348 case EApVpnRealIapID: |
|
349 { |
|
350 aValue = iRealIapId; |
|
351 break; |
|
352 } |
|
353 case EApVpnRealWapID: |
|
354 { |
|
355 aValue = iVpnRealWapId; |
|
356 break; |
|
357 } |
|
358 case EApVpnProxyPortNumber: |
|
359 { |
|
360 aValue = iProxyPort; |
|
361 break; |
|
362 } |
|
363 case EApVpnHomeNetworkID: |
|
364 { |
|
365 aValue = iHomeNetwork; |
|
366 break; |
|
367 } |
|
368 case EApVpnIapNetworkID: |
|
369 { |
|
370 aValue = iVpnIapNetwork; |
|
371 break; |
|
372 } |
|
373 default : |
|
374 { |
|
375 __ASSERT_DEBUG( EFalse, ApCommons::Panic( EInvalidColumn ) ); |
|
376 retval = KErrInvalidColumn; |
|
377 break; |
|
378 } |
|
379 } |
|
380 |
|
381 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::ReadUint" ) ) ); |
|
382 return retval; |
|
383 } |
|
384 |
|
385 |
|
386 |
|
387 // --------------------------------------------------------- |
|
388 // CVpnApItem::ReadBool |
|
389 // --------------------------------------------------------- |
|
390 // |
|
391 EXPORT_C TInt CVpnApItem::ReadBool( const TVpnApMember /*aColumn*/, |
|
392 TBool& /*aValue*/ ) |
|
393 { |
|
394 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::ReadBool" ) ) ); |
|
395 |
|
396 // This is just a placeholder API for possible expansion... |
|
397 |
|
398 TInt retval( KErrNone ); |
|
399 |
|
400 __ASSERT_DEBUG( EFalse, ApCommons::Panic( EInvalidColumn ) ); |
|
401 retval = KErrInvalidColumn; |
|
402 |
|
403 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::ReadBool" ) ) ); |
|
404 return retval; |
|
405 } |
|
406 |
|
407 |
|
408 |
|
409 |
|
410 // --------------------------------------------------------- |
|
411 // CVpnApItem::WriteTextL |
|
412 // --------------------------------------------------------- |
|
413 // |
|
414 EXPORT_C TInt CVpnApItem::WriteTextL( const TVpnApMember aColumn, |
|
415 const TDesC16& aValue ) |
|
416 { |
|
417 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::WriteTextL" ) ) ); |
|
418 |
|
419 TInt retval( KErrNone ); |
|
420 switch ( aColumn ) |
|
421 { |
|
422 case EApVpnWapAccessPointName: |
|
423 { |
|
424 HBufC* sgd = aValue.AllocLC(); |
|
425 sgd->Des().Trim(); |
|
426 ReAllocL( iName, *sgd); |
|
427 CleanupStack::PopAndDestroy( sgd ); // sgd |
|
428 break; |
|
429 } |
|
430 case EApVpnPolicy: |
|
431 { |
|
432 ReAllocL( iPolicy, aValue); |
|
433 break; |
|
434 } |
|
435 case EApVpnProxyServerAddress: |
|
436 { |
|
437 ReAllocL( iProxyServerAddress, aValue); |
|
438 break; |
|
439 } |
|
440 case EApVpnRealIapName: |
|
441 { |
|
442 ReAllocL( iRealIapName, aValue ); |
|
443 break; |
|
444 } |
|
445 case EApVpnPolicyId: |
|
446 { |
|
447 ReAllocL( iPolicyId, aValue ); |
|
448 break; |
|
449 } |
|
450 case EApVpnIapNetworkName: |
|
451 { |
|
452 ReAllocL( iVpnIapNetworkName, aValue ); |
|
453 break; |
|
454 } |
|
455 default: |
|
456 { |
|
457 __ASSERT_DEBUG( EFalse, ApCommons::Panic( EInvalidColumn ) ); |
|
458 retval = KErrInvalidColumn; |
|
459 break; |
|
460 } |
|
461 } |
|
462 |
|
463 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::WriteTextL" ) ) ); |
|
464 return retval; |
|
465 } |
|
466 |
|
467 |
|
468 |
|
469 // --------------------------------------------------------- |
|
470 // CVpnApItem::WriteLongTextL |
|
471 // --------------------------------------------------------- |
|
472 // |
|
473 EXPORT_C TInt CVpnApItem::WriteLongTextL( const TVpnApMember aColumn, |
|
474 const TDesC& aValue ) |
|
475 { |
|
476 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::WriteLongTextL" ) ) ); |
|
477 |
|
478 TInt retval( KErrNone ); |
|
479 switch ( aColumn ) |
|
480 { |
|
481 case EApVpnProxyServerAddress: |
|
482 { |
|
483 ReAllocL( iProxyServerAddress, aValue); |
|
484 break; |
|
485 } |
|
486 default: |
|
487 { |
|
488 // unknown column... |
|
489 __ASSERT_DEBUG( EFalse, ApCommons::Panic( EInvalidColumn ) ); |
|
490 retval = KErrInvalidColumn; |
|
491 break; |
|
492 } |
|
493 } |
|
494 |
|
495 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::WriteLongTextL" ) ) ); |
|
496 return retval; |
|
497 } |
|
498 |
|
499 |
|
500 |
|
501 // --------------------------------------------------------- |
|
502 // CVpnApItem::WriteUint |
|
503 // --------------------------------------------------------- |
|
504 // |
|
505 EXPORT_C TInt CVpnApItem::WriteUint( const TVpnApMember aColumn, |
|
506 const TUint32& aValue ) |
|
507 { |
|
508 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::WriteUint" ) ) ); |
|
509 |
|
510 TInt retval( KErrNone ); |
|
511 switch ( aColumn ) |
|
512 { |
|
513 case EApVpnWapAccessPointID: |
|
514 { |
|
515 iVpnWapId = aValue; |
|
516 break; |
|
517 } |
|
518 case EApVpnIapID: |
|
519 { |
|
520 iVpnIapId = aValue; |
|
521 break; |
|
522 } |
|
523 case EApVpnRealIapID: |
|
524 { |
|
525 iRealIapId= aValue; |
|
526 break; |
|
527 } |
|
528 case EApVpnRealWapID: |
|
529 { |
|
530 iVpnRealWapId = aValue; |
|
531 break; |
|
532 } |
|
533 case EApVpnProxyPortNumber: |
|
534 { |
|
535 iProxyPort = aValue; |
|
536 break; |
|
537 } |
|
538 case EApVpnHomeNetworkID: |
|
539 { |
|
540 iHomeNetwork = aValue; |
|
541 break; |
|
542 } |
|
543 case EApVpnIapNetworkID: |
|
544 { |
|
545 iVpnIapNetwork = aValue; |
|
546 break; |
|
547 } |
|
548 default : |
|
549 { |
|
550 __ASSERT_DEBUG( EFalse, ApCommons::Panic( EInvalidColumn ) ); |
|
551 retval = KErrInvalidColumn; |
|
552 } |
|
553 } |
|
554 |
|
555 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::WriteUint" ) ) ); |
|
556 return retval; |
|
557 } |
|
558 |
|
559 |
|
560 |
|
561 // --------------------------------------------------------- |
|
562 // CVpnApItem::WriteBool |
|
563 // --------------------------------------------------------- |
|
564 // |
|
565 EXPORT_C TInt CVpnApItem::WriteBool( const TVpnApMember /*aColumn*/, |
|
566 const TBool& /*aValue*/ ) |
|
567 { |
|
568 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::WriteBool" ) ) ); |
|
569 |
|
570 TInt retval( KErrNone ); |
|
571 |
|
572 // This is just a placeholder API for possible expansion... |
|
573 |
|
574 __ASSERT_DEBUG( EFalse, ApCommons::Panic( EInvalidColumn ) ); |
|
575 retval = KErrInvalidColumn; |
|
576 |
|
577 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::WriteBool" ) ) ); |
|
578 return retval; |
|
579 } |
|
580 |
|
581 |
|
582 // Query |
|
583 // COMMON |
|
584 |
|
585 // --------------------------------------------------------- |
|
586 // CVpnApItem::WapUid |
|
587 // --------------------------------------------------------- |
|
588 // |
|
589 EXPORT_C TUint32 CVpnApItem::WapUid() const |
|
590 { |
|
591 CLOG( ( EApItem, 0, _L( "<-> CVpnApItem::WapUid" ) ) ); |
|
592 |
|
593 return iVpnWapId; |
|
594 } |
|
595 |
|
596 |
|
597 // --------------------------------------------------------- |
|
598 // CVpnApItem::Name |
|
599 // --------------------------------------------------------- |
|
600 // |
|
601 EXPORT_C const TDesC& CVpnApItem::Name() const |
|
602 { |
|
603 CLOG( ( EApItem, 0, _L( "<-> CVpnApItem::Name" ) ) ); |
|
604 |
|
605 return *iName; |
|
606 } |
|
607 |
|
608 |
|
609 |
|
610 // --------------------------------------------------------- |
|
611 // CVpnApItem::ReAllocL |
|
612 // --------------------------------------------------------- |
|
613 // |
|
614 void CVpnApItem::ReAllocL(HBufC*& aDes, const TDesC16& aValue) |
|
615 { |
|
616 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::ReAllocL" ) ) ); |
|
617 |
|
618 // now remove 'invalid' chars (TABs) as they cause problems |
|
619 // in other places, like listboxes... |
|
620 HBufC* tmp = RemoveInvalidCharsLC( aValue ); |
|
621 delete aDes; |
|
622 aDes = tmp; |
|
623 CleanupStack::Pop( tmp ); |
|
624 |
|
625 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::ReAllocL" ) ) ); |
|
626 } |
|
627 |
|
628 |
|
629 |
|
630 // --------------------------------------------------------- |
|
631 // CVpnApItem::RemoveInvalidCharsLC |
|
632 // --------------------------------------------------------- |
|
633 // |
|
634 HBufC* CVpnApItem::RemoveInvalidCharsLC( const TDesC16& aInText ) |
|
635 { |
|
636 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::RemoveInvalidCharsLC" ) ) ); |
|
637 |
|
638 TInt size = aInText.Length(); |
|
639 HBufC* aOutText = HBufC::NewLC( size ); |
|
640 TPtr ptr = aOutText->Des(); |
|
641 |
|
642 for ( TInt ii=0; ii<size; ++ii ) |
|
643 { |
|
644 TText ch = aInText[ii]; |
|
645 if ( ch == CEditableText::ETabCharacter ) |
|
646 { |
|
647 ch = ' '; |
|
648 } |
|
649 ptr.Append( ch ); |
|
650 } |
|
651 |
|
652 CLOG( ( EApItem, 1, _L( "<- CVpnApItem::RemoveInvalidCharsLC" ) ) ); |
|
653 return aOutText; |
|
654 } |
|
655 |
|
656 |
|
657 |
|
658 // --------------------------------------------------------- |
|
659 // CVpnApItem::HasProxy |
|
660 // --------------------------------------------------------- |
|
661 // |
|
662 TBool CVpnApItem::HasProxy() const |
|
663 { |
|
664 CLOG( ( EApItem, 0, _L( "-> CVpnApItem::HasProxy" ) ) ); |
|
665 |
|
666 TBool retval ( EFalse ); |
|
667 |
|
668 if ( ( iProxyServerAddress->Compare( KDynIpAddress ) |
|
669 && iProxyServerAddress->Compare( KEmpty ) ) |
|
670 && ( iProxyPort != 0 ) ) |
|
671 { |
|
672 retval = ETrue; |
|
673 } |
|
674 |
|
675 CLOG( ( EApItem, 0, _L( "<- CVpnApItem::HasProxy" ) ) ); |
|
676 |
|
677 return retval; |
|
678 } |
|
679 |
|
680 // End of File |
|