|
1 /* |
|
2 * Copyright (c) 2009 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: Implementation of internet access point handling. |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 // INCLUDE FILES |
|
20 #include "HtiMessagesServicePlugin.h" |
|
21 #include "HtiIAPHandler.h" |
|
22 |
|
23 #include <HtiDispatcherInterface.h> |
|
24 #include <HTILogging.h> |
|
25 #include <cmconnectionmethodext.h> |
|
26 #include <cmconnectionmethoddef.h> |
|
27 #include <cmdestinationext.h> |
|
28 #include <cmmanagerext.h> |
|
29 #include <cmplugincsddef.h> |
|
30 #include <cmpluginhscsddef.h> |
|
31 #include <cmpluginpacketdatadef.h> |
|
32 #include <cmpluginwlandef.h> |
|
33 #include <RConnMon.h> |
|
34 |
|
35 using namespace CMManager; |
|
36 |
|
37 // EXTERNAL DATA STRUCTURES |
|
38 |
|
39 // EXTERNAL FUNCTION PROTOTYPES |
|
40 |
|
41 // CONSTANTS |
|
42 const TInt KMinCreateMsgLength = 5; |
|
43 const TInt KMinDeleteMsgLength = 3; |
|
44 const TInt KMinCreateDestMsgLength = 3; |
|
45 const TInt KMinDeleteDestMsgLength = 3; |
|
46 const TInt KMinModifyDestMsgLength = 5; |
|
47 const TInt KMinSetDefConMsgLength = 3; |
|
48 |
|
49 // MACROS |
|
50 |
|
51 // LOCAL CONSTANTS AND MACROS |
|
52 _LIT8( KErrorInvalidParameters, "Invalid command parameters" ); |
|
53 _LIT8( KErrorCreateFailed, "Access Point creation failed" ); |
|
54 _LIT8( KErrorDeleteFailed, "Access Point deletion failed" ); |
|
55 _LIT8( KErrorDestCreateFailed, "Destination creation failed" ); |
|
56 _LIT8( KErrorDestDeleteFailed, "Destination deletion failed" ); |
|
57 _LIT8( KErrorApAlreadyExists, "Access Point with same name already exists" ); |
|
58 _LIT8( KErrorApNotFound, "Access Point with given name not found" ); |
|
59 _LIT8( KErrorConnCloseFailed, |
|
60 "Failed to close a connection using the Access Point" ); |
|
61 _LIT8( KErrorAddToDestFailed, "Adding to destination failed" ); |
|
62 _LIT8( KErrorRemoveFromDestFailed, "Removing from destination failed" ); |
|
63 _LIT8( KErrorDestNotFound, "Destination with given name not found" ); |
|
64 _LIT8( KErrorSetDefConFailed, "Setting default connection failed" ); |
|
65 |
|
66 // MODULE DATA STRUCTURES |
|
67 |
|
68 // LOCAL FUNCTION PROTOTYPES |
|
69 |
|
70 // FORWARD DECLARATIONS |
|
71 |
|
72 // ============================ MEMBER FUNCTIONS =============================== |
|
73 |
|
74 // ----------------------------------------------------------------------------- |
|
75 // CHtiIAPHandler::NewL |
|
76 // Two-phased constructor. |
|
77 // ----------------------------------------------------------------------------- |
|
78 CHtiIAPHandler* CHtiIAPHandler::NewL() |
|
79 { |
|
80 HTI_LOG_FUNC_IN( "CHtiIAPHandler::NewL" ); |
|
81 CHtiIAPHandler* self = new (ELeave) CHtiIAPHandler(); |
|
82 CleanupStack::PushL ( self ); |
|
83 self->ConstructL(); |
|
84 CleanupStack::Pop(); |
|
85 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::NewL" ); |
|
86 return self; |
|
87 } |
|
88 |
|
89 |
|
90 // ---------------------------------------------------------------------------- |
|
91 // CHtiIAPHandler::CHtiIAPHandler |
|
92 // C++ default constructor can NOT contain any code, that |
|
93 // might leave. |
|
94 // ---------------------------------------------------------------------------- |
|
95 CHtiIAPHandler::CHtiIAPHandler() |
|
96 { |
|
97 HTI_LOG_FUNC_IN( "CHtiIAPHandler::CHtiIAPHandler" ); |
|
98 |
|
99 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::CHtiIAPHandler" ); |
|
100 } |
|
101 |
|
102 |
|
103 // ----------------------------------------------------------------------------- |
|
104 // CHtiIAPHandler::~CHtiIAPHandler |
|
105 // Destructor. |
|
106 // ----------------------------------------------------------------------------- |
|
107 CHtiIAPHandler::~CHtiIAPHandler() |
|
108 { |
|
109 HTI_LOG_FUNC_IN( "CHtiIAPHandler::~CHtiIAPHandler" ); |
|
110 |
|
111 for ( TInt i = 0; i < iFields.Count(); i++ ) |
|
112 { |
|
113 delete iFields[i].iData; |
|
114 } |
|
115 iFields.Reset(); |
|
116 iFields.Close(); |
|
117 |
|
118 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::~CHtiIAPHandler" ); |
|
119 } |
|
120 |
|
121 |
|
122 // ----------------------------------------------------------------------------- |
|
123 // CHtiIAPHandler::ConstructL |
|
124 // Symbian 2nd phase constructor can leave. |
|
125 // ----------------------------------------------------------------------------- |
|
126 void CHtiIAPHandler::ConstructL() |
|
127 { |
|
128 HTI_LOG_FUNC_IN( "CHtiIAPHandler::ConstructL" ); |
|
129 |
|
130 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::ConstructL" ); |
|
131 } |
|
132 |
|
133 |
|
134 // ----------------------------------------------------------------------------- |
|
135 // CHtiIAPHandler::SetDispatcher |
|
136 // Sets the dispatcher pointer. |
|
137 // ----------------------------------------------------------------------------- |
|
138 |
|
139 void CHtiIAPHandler::SetDispatcher( MHtiDispatcher* aDispatcher ) |
|
140 { |
|
141 HTI_LOG_FUNC_IN( "CHtiIAPHandler::SetDispatcher" ); |
|
142 iDispatcher = aDispatcher; |
|
143 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::SetDispatcher" ); |
|
144 } |
|
145 |
|
146 |
|
147 // ----------------------------------------------------------------------------- |
|
148 // CHtiIAPHandler::ProcessMessageL |
|
149 // Parses the received message and calls handler functions. |
|
150 // ----------------------------------------------------------------------------- |
|
151 void CHtiIAPHandler::ProcessMessageL( const TDesC8& aMessage, |
|
152 THtiMessagePriority /*aPriority*/ ) |
|
153 { |
|
154 HTI_LOG_FUNC_IN( "CHtiIAPHandler::ProcessMessageL" ); |
|
155 |
|
156 for ( TInt i = 0; i < iFields.Count(); i++ ) |
|
157 delete iFields[i].iData; |
|
158 iFields.Reset(); |
|
159 iFields.Close(); |
|
160 iConnName.Zero(); |
|
161 iBearerType = 0; |
|
162 |
|
163 // Zero length message and command code validity already checked |
|
164 // in HtiMessagesServicePlugin. |
|
165 |
|
166 if ( aMessage[0] == CHtiMessagesServicePlugin::ECreateIAP ) |
|
167 { |
|
168 if ( aMessage.Length() < KMinCreateMsgLength ) |
|
169 { |
|
170 SendErrorMessageL( KErrArgument, KErrorInvalidParameters ); |
|
171 } |
|
172 else |
|
173 { |
|
174 TRAPD( err, HandleCreateIapL( aMessage.Mid( 1 ) ) ); |
|
175 if ( err != KErrNone ) |
|
176 { |
|
177 SendErrorMessageL( err, KErrorCreateFailed ); |
|
178 } |
|
179 } |
|
180 } |
|
181 |
|
182 else if ( aMessage[0] == CHtiMessagesServicePlugin::EDeleteIAP ) |
|
183 { |
|
184 if ( aMessage.Length() < KMinDeleteMsgLength ) |
|
185 { |
|
186 SendErrorMessageL( KErrArgument, KErrorInvalidParameters ); |
|
187 } |
|
188 else |
|
189 { |
|
190 TRAPD( err, HandleDeleteIapL( aMessage.Mid( 1 ) ) ); |
|
191 if ( err != KErrNone ) |
|
192 { |
|
193 SendErrorMessageL( err, KErrorDeleteFailed ); |
|
194 } |
|
195 } |
|
196 } |
|
197 |
|
198 else if ( aMessage[0] == CHtiMessagesServicePlugin::ECreateDestination ) |
|
199 { |
|
200 if ( aMessage.Length() < KMinCreateDestMsgLength ) |
|
201 { |
|
202 SendErrorMessageL( KErrArgument, KErrorInvalidParameters ); |
|
203 } |
|
204 else |
|
205 { |
|
206 TRAPD( err, HandleCreateDestinationL( aMessage.Mid( 1 ) ) ); |
|
207 if ( err != KErrNone ) |
|
208 { |
|
209 SendErrorMessageL( err, KErrorDestCreateFailed ); |
|
210 } |
|
211 } |
|
212 } |
|
213 |
|
214 else if ( aMessage[0] == CHtiMessagesServicePlugin::EDeleteDestination ) |
|
215 { |
|
216 if ( aMessage.Length() < KMinDeleteDestMsgLength ) |
|
217 { |
|
218 SendErrorMessageL( KErrArgument, KErrorInvalidParameters ); |
|
219 } |
|
220 else |
|
221 { |
|
222 TRAPD( err, HandleDeleteDestinationL( aMessage.Mid( 1 ) ) ); |
|
223 if ( err != KErrNone ) |
|
224 { |
|
225 SendErrorMessageL( err, KErrorDestDeleteFailed ); |
|
226 } |
|
227 } |
|
228 } |
|
229 |
|
230 else if ( aMessage[0] == CHtiMessagesServicePlugin::EAddToDestination || |
|
231 aMessage[0] == CHtiMessagesServicePlugin::ERemoveFromDestination ) |
|
232 { |
|
233 if ( aMessage.Length() < KMinModifyDestMsgLength ) |
|
234 { |
|
235 SendErrorMessageL( KErrArgument, KErrorInvalidParameters ); |
|
236 } |
|
237 else |
|
238 { |
|
239 TRAPD( err, ModifyDestinationL( aMessage[0], aMessage.Mid( 1 ) ) ); |
|
240 if ( err != KErrNone ) |
|
241 { |
|
242 if ( aMessage[0] == CHtiMessagesServicePlugin::EAddToDestination ) |
|
243 { |
|
244 SendErrorMessageL( err, KErrorAddToDestFailed ); |
|
245 } |
|
246 else |
|
247 { |
|
248 SendErrorMessageL( err, KErrorRemoveFromDestFailed ); |
|
249 } |
|
250 } |
|
251 } |
|
252 } |
|
253 else if ( aMessage[0] == CHtiMessagesServicePlugin::ESetDefaultConnection ) |
|
254 { |
|
255 if ( aMessage.Length() < KMinSetDefConMsgLength ) |
|
256 { |
|
257 SendErrorMessageL( KErrArgument, KErrorInvalidParameters ); |
|
258 } |
|
259 else |
|
260 { |
|
261 TRAPD( err, SetDefaultConnectionL( aMessage.Mid( 1 ) ) ); |
|
262 if ( err != KErrNone ) |
|
263 { |
|
264 SendErrorMessageL( err, KErrorSetDefConFailed ); |
|
265 } |
|
266 } |
|
267 } |
|
268 |
|
269 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::ProcessMessageL" ); |
|
270 } |
|
271 |
|
272 |
|
273 // ---------------------------------------------------------------------------- |
|
274 // CHtiIAPHandler::HandleCreateIapL |
|
275 // Creates new Internet Access Point. |
|
276 // ---------------------------------------------------------------------------- |
|
277 void CHtiIAPHandler::HandleCreateIapL( const TDesC8& aData ) |
|
278 { |
|
279 HTI_LOG_FUNC_IN( "CHtiIAPHandler::HandleCreateIapL" ); |
|
280 |
|
281 TRAPD( err, ParseCreateMessageL( aData ) ); |
|
282 if ( err != KErrNone ) |
|
283 { |
|
284 SendErrorMessageL( err, KErrorInvalidParameters ); |
|
285 return; |
|
286 } |
|
287 |
|
288 if ( GetAccessPointUIDL() != KErrNotFound ) |
|
289 { |
|
290 SendErrorMessageL( KErrAlreadyExists, KErrorApAlreadyExists ); |
|
291 return; |
|
292 } |
|
293 |
|
294 MapLegacyFieldIDs(); |
|
295 ResolveFieldDataTypes(); |
|
296 |
|
297 RCmManagerExt cmManager; |
|
298 cmManager.OpenL(); |
|
299 CleanupClosePushL( cmManager ); |
|
300 |
|
301 RCmConnectionMethodExt cm = cmManager.CreateConnectionMethodL( iBearerType ); |
|
302 CleanupClosePushL( cm ); |
|
303 HTI_LOG_TEXT( "Connection method created" ); |
|
304 |
|
305 cm.SetStringAttributeL( ECmName, iConnName ); |
|
306 HTI_LOG_TEXT( "Name set" ); |
|
307 |
|
308 TUint32 requestedSeamlessness = 1; // default |
|
309 |
|
310 // Set attributes |
|
311 HTI_LOG_FORMAT( "Fields to write: %d", iFields.Count() ); |
|
312 for ( TInt i = 0; i < iFields.Count(); i++ ) |
|
313 { |
|
314 if ( err != KErrNone ) break; |
|
315 |
|
316 HTI_LOG_FORMAT( "Writing field %d", ( i + 1 ) ); |
|
317 TApField field = iFields[i]; |
|
318 HTI_LOG_FORMAT( "Field ID = %d", field.iId ); |
|
319 |
|
320 switch ( field.iDataType ) |
|
321 { |
|
322 case EDataTypeText: |
|
323 { |
|
324 TRAP( err, cm.SetStringAttributeL( field.iId, *field.iData ) ); |
|
325 break; |
|
326 } |
|
327 case EDataTypeBool: |
|
328 { |
|
329 TLex lex( *field.iData ); |
|
330 TInt result = 0; |
|
331 lex.Val( result ); |
|
332 TRAP( err, cm.SetBoolAttributeL( field.iId, ( TBool ) result ) ); |
|
333 break; |
|
334 } |
|
335 case EDataTypeUint: |
|
336 { |
|
337 TLex lex( *field.iData ); |
|
338 TUint32 result; |
|
339 err = lex.Val( result, EDecimal ); |
|
340 if ( err == KErrNone ) |
|
341 TRAP( err, cm.SetIntAttributeL( field.iId, result ) ); |
|
342 if ( field.iId == ECmSeamlessnessLevel ) |
|
343 requestedSeamlessness = result; |
|
344 break; |
|
345 } |
|
346 case EDataTypeText8: |
|
347 { |
|
348 HBufC8* buf8 = HBufC8::NewL( field.iData->Length() ); |
|
349 buf8->Des().Copy( *field.iData ); |
|
350 TRAP( err, cm.SetString8AttributeL( field.iId, *buf8 ) ); |
|
351 delete buf8; |
|
352 buf8 = NULL; |
|
353 break; |
|
354 } |
|
355 default: |
|
356 { |
|
357 HTI_LOG_FORMAT( "Unsupported field type %d", field.iDataType ); |
|
358 err = KErrNotSupported; |
|
359 break; |
|
360 } |
|
361 } |
|
362 } |
|
363 |
|
364 if ( err != KErrNone ) |
|
365 { |
|
366 HTI_LOG_FORMAT( "Error occurred %d", err ); |
|
367 User::Leave( err ); |
|
368 } |
|
369 |
|
370 cm.UpdateL(); |
|
371 TUint32 uid = cm.GetIntAttributeL( ECmId ); |
|
372 CleanupStack::PopAndDestroy(); // cm |
|
373 |
|
374 // The seamlessness value is not always set correctly when the connection |
|
375 // method is created. Have to update seamlessness value separately after |
|
376 // creation. |
|
377 cm = cmManager.ConnectionMethodL( uid ); |
|
378 CleanupClosePushL( cm ); |
|
379 TUint32 currentSeamlessness = cm.GetIntAttributeL( ECmSeamlessnessLevel ); |
|
380 HTI_LOG_FORMAT( "Requested seamlessness = %d", requestedSeamlessness ); |
|
381 HTI_LOG_FORMAT( "Current seamlessness = %d", currentSeamlessness ); |
|
382 if ( currentSeamlessness != requestedSeamlessness ) |
|
383 { |
|
384 cm.SetIntAttributeL( ECmSeamlessnessLevel, requestedSeamlessness ); |
|
385 cm.UpdateL(); |
|
386 HTI_LOG_TEXT( "Seamlessness value updated" ); |
|
387 } |
|
388 CleanupStack::PopAndDestroy(); // cm |
|
389 CleanupStack::PopAndDestroy(); // cmManager |
|
390 |
|
391 HTI_LOG_FORMAT( "AP created with uid %d", uid ); |
|
392 |
|
393 TBuf8<4> idBuf; |
|
394 idBuf.Append( ( TUint8* ) &uid, 4 ); |
|
395 SendOkMsgL( idBuf ); |
|
396 |
|
397 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::HandleCreateIapL" ); |
|
398 } |
|
399 |
|
400 |
|
401 // ---------------------------------------------------------------------------- |
|
402 // CHtiIAPHandler::HandleDeleteIapL |
|
403 // Deletes the named Internet Access Point |
|
404 // ---------------------------------------------------------------------------- |
|
405 void CHtiIAPHandler::HandleDeleteIapL( const TDesC8& aData ) |
|
406 { |
|
407 HTI_LOG_FUNC_IN( "CHtiIAPHandler::HandleDeleteIapL" ); |
|
408 if ( aData.Length() < KMinDeleteMsgLength ) |
|
409 { |
|
410 SendErrorMessageL( KErrArgument, KErrorInvalidParameters ); |
|
411 return; |
|
412 } |
|
413 |
|
414 TInt nameLength = aData[0]; |
|
415 if ( nameLength > KMaxConnNameLength || |
|
416 aData.Length() != ( nameLength + 1 ) ) |
|
417 { |
|
418 SendErrorMessageL( KErrArgument, KErrorInvalidParameters ); |
|
419 return; |
|
420 } |
|
421 |
|
422 iConnName.Copy( aData.Mid( 1, nameLength ) ); |
|
423 HTI_LOG_FORMAT( "Searching connection with name: %S", &iConnName ); |
|
424 TInt uid = GetAccessPointUIDL(); |
|
425 |
|
426 if ( uid == KErrNotFound ) |
|
427 { |
|
428 SendErrorMessageL( KErrNotFound, KErrorApNotFound ); |
|
429 return; |
|
430 } |
|
431 |
|
432 RCmManagerExt cmManagerExt; |
|
433 cmManagerExt.OpenL(); |
|
434 CleanupClosePushL( cmManagerExt ); |
|
435 RCmConnectionMethodExt connMethod = cmManagerExt.ConnectionMethodL( uid ); |
|
436 CleanupClosePushL( connMethod ); |
|
437 if ( connMethod.GetBoolAttributeL( ECmConnected ) ) |
|
438 { |
|
439 HTI_LOG_TEXT( "AP in use - trying to close connections" ); |
|
440 TRAPD( err, CloseActiveConnectionsL() ); |
|
441 if ( err != KErrNone ) |
|
442 { |
|
443 SendErrorMessageL( err, KErrorConnCloseFailed ); |
|
444 CleanupStack::PopAndDestroy( 2 ); // connMethod, cmManagerExt |
|
445 return; |
|
446 } |
|
447 } |
|
448 |
|
449 HTI_LOG_TEXT( "AP not in use - unlinking from all destinations" ); |
|
450 cmManagerExt.RemoveAllReferencesL( connMethod ); |
|
451 HTI_LOG_TEXT( "Deleting the AP" ); |
|
452 TBool deleted = connMethod.DeleteL(); // returns ETrue if really deleted |
|
453 if ( !deleted ) |
|
454 { |
|
455 HTI_LOG_TEXT( "Delete failed" ); |
|
456 User::Leave( KErrGeneral ); |
|
457 } |
|
458 HTI_LOG_FORMAT( "AP deleted with uid %d", uid ); |
|
459 CleanupStack::PopAndDestroy(); // connMethod |
|
460 CleanupStack::PopAndDestroy(); // cmManagerExt |
|
461 |
|
462 SendOkMsgL( KNullDesC8 ); |
|
463 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::HandleDeleteIapL" ); |
|
464 } |
|
465 |
|
466 |
|
467 // ---------------------------------------------------------------------------- |
|
468 // CHtiIAPHandler::HandleCreateDestinationL |
|
469 // Creates a new Destination. |
|
470 // ---------------------------------------------------------------------------- |
|
471 void CHtiIAPHandler::HandleCreateDestinationL( const TDesC8& aData ) |
|
472 { |
|
473 HTI_LOG_FUNC_IN( "CHtiIAPHandler::HandleCreateDestinationL" ); |
|
474 |
|
475 TInt nameLength = aData[0]; |
|
476 if ( aData.Length() - 1 != nameLength || nameLength > KMaxConnNameLength ) |
|
477 { |
|
478 SendErrorMessageL( KErrArgument, KErrorInvalidParameters ); |
|
479 return; |
|
480 } |
|
481 |
|
482 RCmManagerExt cmManager; |
|
483 cmManager.OpenL(); |
|
484 CleanupClosePushL( cmManager ); |
|
485 |
|
486 iDestName.Copy( aData.Mid( 1 ) ); |
|
487 |
|
488 RCmDestinationExt dest = cmManager.CreateDestinationL( iDestName ); |
|
489 CleanupClosePushL( dest ); |
|
490 dest.UpdateL(); |
|
491 |
|
492 CleanupStack::PopAndDestroy( 2 ); // dest, cmManager |
|
493 SendOkMsgL( KNullDesC8 ); |
|
494 |
|
495 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::HandleCreateDestinationL" ); |
|
496 } |
|
497 |
|
498 |
|
499 // ---------------------------------------------------------------------------- |
|
500 // CHtiIAPHandler::HandleDeleteDestinationL |
|
501 // Deletes a named Destination. |
|
502 // ---------------------------------------------------------------------------- |
|
503 void CHtiIAPHandler::HandleDeleteDestinationL( const TDesC8& aData ) |
|
504 { |
|
505 HTI_LOG_FUNC_IN( "CHtiIAPHandler::HandleDeleteDestinationL" ); |
|
506 |
|
507 TInt nameLength = aData[0]; |
|
508 if ( aData.Length() - 1 != nameLength || nameLength > KMaxConnNameLength ) |
|
509 { |
|
510 SendErrorMessageL( KErrArgument, KErrorInvalidParameters ); |
|
511 return; |
|
512 } |
|
513 |
|
514 iDestName.Copy( aData.Mid( 1 ) ); |
|
515 TInt id = GetDestinationIDL( iDestName ); |
|
516 |
|
517 RCmManagerExt cmManager; |
|
518 cmManager.OpenL(); |
|
519 CleanupClosePushL( cmManager ); |
|
520 |
|
521 RCmDestinationExt dest = cmManager.DestinationL ( id ); |
|
522 dest.DeleteLD(); |
|
523 |
|
524 CleanupStack::PopAndDestroy(); // cmManager |
|
525 SendOkMsgL( KNullDesC8 ); |
|
526 |
|
527 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::HandleDeleteDestinationL" ); |
|
528 } |
|
529 |
|
530 |
|
531 // ---------------------------------------------------------------------------- |
|
532 // CHtiIAPHandler::ModifyDestinationL |
|
533 // Adds or removes IAP to/from a Destination. |
|
534 // ---------------------------------------------------------------------------- |
|
535 void CHtiIAPHandler::ModifyDestinationL( const TInt aCommand, const TDesC8& aData ) |
|
536 { |
|
537 HTI_LOG_FUNC_IN( "CHtiIAPHandler::ModifyDestinationL" ); |
|
538 |
|
539 TInt dataLength = aData.Length(); |
|
540 TInt offset = 0; |
|
541 TInt cmNameLength = aData[offset]; |
|
542 offset++; |
|
543 if ( dataLength < cmNameLength + 3 || cmNameLength > KMaxConnNameLength ) |
|
544 { |
|
545 SendErrorMessageL( KErrArgument, KErrorInvalidParameters ); |
|
546 return; |
|
547 } |
|
548 iConnName.Copy( aData.Mid( offset, cmNameLength ) ); |
|
549 offset += cmNameLength; |
|
550 TInt destNameLength = aData[offset]; |
|
551 offset++; |
|
552 if ( dataLength != cmNameLength + destNameLength + 2 || |
|
553 destNameLength > KMaxConnNameLength ) |
|
554 { |
|
555 SendErrorMessageL( KErrArgument, KErrorInvalidParameters ); |
|
556 return; |
|
557 } |
|
558 |
|
559 iDestName.Copy( aData.Mid( offset, destNameLength ) ); |
|
560 |
|
561 TInt cmId = GetAccessPointUIDL(); |
|
562 if ( cmId == KErrNotFound ) |
|
563 { |
|
564 SendErrorMessageL( KErrNotFound, KErrorApNotFound ); |
|
565 return; |
|
566 } |
|
567 TInt destId = GetDestinationIDL( iDestName ); |
|
568 if ( destId == KErrNotFound ) |
|
569 { |
|
570 SendErrorMessageL( KErrNotFound, KErrorDestNotFound ); |
|
571 return; |
|
572 } |
|
573 |
|
574 RCmManagerExt cmManager; |
|
575 cmManager.OpenL(); |
|
576 CleanupClosePushL( cmManager ); |
|
577 |
|
578 RCmConnectionMethodExt cm = cmManager.ConnectionMethodL( cmId ); |
|
579 CleanupClosePushL( cm ); |
|
580 HTI_LOG_TEXT( "Got Connection Method" ); |
|
581 |
|
582 RCmDestinationExt dest = cmManager.DestinationL( destId ); |
|
583 CleanupClosePushL( dest ); |
|
584 HTI_LOG_TEXT( "Got Destination" ); |
|
585 |
|
586 if ( aCommand == CHtiMessagesServicePlugin::EAddToDestination ) |
|
587 { |
|
588 dest.AddConnectionMethodL( cm ); |
|
589 } |
|
590 else if ( aCommand == CHtiMessagesServicePlugin::ERemoveFromDestination) |
|
591 { |
|
592 dest.RemoveConnectionMethodL( cm ); |
|
593 } |
|
594 else |
|
595 { |
|
596 // Programming error |
|
597 User::Panic( _L( "CHtiIAPHandler"), 1 ); |
|
598 } |
|
599 dest.UpdateL(); |
|
600 HTI_LOG_TEXT( "Destination updated" ); |
|
601 |
|
602 CleanupStack::PopAndDestroy( 3 ); // dest, cm, cmManager |
|
603 SendOkMsgL( KNullDesC8 ); |
|
604 |
|
605 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::ModifyDestinationL" ); |
|
606 } |
|
607 |
|
608 |
|
609 // ---------------------------------------------------------------------------- |
|
610 // CHtiIAPHandler::SetDefaultConnectionL |
|
611 // Sets the default connection setting. |
|
612 // ---------------------------------------------------------------------------- |
|
613 void CHtiIAPHandler::SetDefaultConnectionL( const TDesC8& aData ) |
|
614 { |
|
615 HTI_LOG_FUNC_IN( "CHtiIAPHandler::SetDefaultConnectionL" ); |
|
616 |
|
617 if ( aData[0] > 3 || aData.Length() != aData[1] + 2 ) |
|
618 { |
|
619 User::Leave( KErrArgument ); |
|
620 } |
|
621 |
|
622 TCmDefConnValue defConnValue; |
|
623 defConnValue.iType = ( TCmDefConnType ) aData[0]; // cmdefconnvalues.h |
|
624 HTI_LOG_FORMAT( "Requested type: %d", defConnValue.iType ); |
|
625 |
|
626 TInt id = 0; |
|
627 if ( defConnValue.iType == ECmDefConnDestination ) |
|
628 { |
|
629 if ( aData[1] == 0 || aData[1] > KMaxConnNameLength ) |
|
630 { |
|
631 User::Leave( KErrArgument ); |
|
632 } |
|
633 iDestName.Copy( aData.Mid( 2 ) ); |
|
634 HTI_LOG_FORMAT( "Destination name: %S", &iDestName ); |
|
635 id = GetDestinationIDL( iDestName ); |
|
636 if ( id == KErrNotFound ) |
|
637 { |
|
638 SendErrorMessageL( KErrNotFound, KErrorDestNotFound ); |
|
639 return; |
|
640 } |
|
641 } |
|
642 |
|
643 else if ( defConnValue.iType == ECmDefConnConnectionMethod ) |
|
644 { |
|
645 if ( aData[1] == 0 || aData[1] > KMaxConnNameLength ) |
|
646 { |
|
647 User::Leave( KErrArgument ); |
|
648 } |
|
649 iConnName.Copy( aData.Mid( 2 ) ); |
|
650 HTI_LOG_FORMAT( "Connection method name: %S", &iConnName ); |
|
651 id = GetAccessPointUIDL(); |
|
652 if ( id == KErrNotFound ) |
|
653 { |
|
654 SendErrorMessageL( KErrNotFound, KErrorApNotFound ); |
|
655 return; |
|
656 } |
|
657 } |
|
658 |
|
659 defConnValue.iId = id; |
|
660 |
|
661 RCmManagerExt cmManager; |
|
662 cmManager.OpenL(); |
|
663 CleanupClosePushL( cmManager ); |
|
664 cmManager.WriteDefConnL( defConnValue ); |
|
665 CleanupStack::PopAndDestroy(); |
|
666 SendOkMsgL( KNullDesC8 ); |
|
667 |
|
668 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::SetDefaultConnectionL" ); |
|
669 } |
|
670 |
|
671 |
|
672 // ---------------------------------------------------------------------------- |
|
673 // CHtiIAPHandler::ParseCreateMessageL |
|
674 // Parses the parameters from the create IAP message. Leaves on error. |
|
675 // ---------------------------------------------------------------------------- |
|
676 void CHtiIAPHandler::ParseCreateMessageL( const TDesC8& aData ) |
|
677 { |
|
678 HTI_LOG_FUNC_IN( "CHtiIAPHandler::ParseCreateMessageL" ); |
|
679 |
|
680 TInt dataLength = aData.Length(); |
|
681 TInt offset = 0; |
|
682 |
|
683 iBearerType = GetBearerUID( aData[offset] ); |
|
684 offset++; |
|
685 HTI_LOG_FORMAT( "Bearer type %d", iBearerType ); |
|
686 if ( iBearerType == 0 ) |
|
687 { |
|
688 User::Leave( KErrArgument ); |
|
689 } |
|
690 |
|
691 TInt nameLength = aData[offset]; |
|
692 offset++; |
|
693 if ( dataLength < ( nameLength + offset + 1 ) || |
|
694 nameLength > KMaxConnNameLength ) |
|
695 { |
|
696 User::Leave( KErrArgument ); |
|
697 } |
|
698 iConnName.Copy( aData.Mid( offset, nameLength ) ); |
|
699 offset += nameLength; |
|
700 HTI_LOG_FORMAT( "Connection name: %S", &iConnName ); |
|
701 |
|
702 TInt fieldCount = aData[offset]; |
|
703 offset++; |
|
704 HTI_LOG_FORMAT( "Field count %d", fieldCount ); |
|
705 |
|
706 for ( TInt i = 0; i < fieldCount; i++ ) |
|
707 { |
|
708 if ( dataLength < ( offset + 3 ) ) |
|
709 { |
|
710 User::Leave( KErrArgument ); |
|
711 } |
|
712 HTI_LOG_FORMAT( "Parsing field %d", i + 1 ); |
|
713 TApField field; |
|
714 field.iId = aData[offset]; |
|
715 offset++; |
|
716 TInt fieldLength = aData[offset]; |
|
717 offset++; |
|
718 HTI_LOG_FORMAT( "Field data length %d", fieldLength ); |
|
719 if ( fieldLength < 1 || dataLength < ( fieldLength + offset ) ) |
|
720 { |
|
721 User::Leave( KErrArgument ); |
|
722 } |
|
723 field.iData = HBufC::NewL( fieldLength ); |
|
724 field.iData->Des().Copy( aData.Mid( offset, fieldLength ) ); |
|
725 offset += fieldLength; |
|
726 HTI_LOG_FORMAT( "Field data: %S", field.iData ); |
|
727 field.iDataType = EDataTypeUnknown; // set later |
|
728 User::LeaveIfError( iFields.Append( field ) ); |
|
729 } |
|
730 |
|
731 if ( offset != dataLength ) // too much data |
|
732 { |
|
733 User::Leave( KErrArgument ); |
|
734 } |
|
735 |
|
736 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::ParseCreateMessageL" ); |
|
737 } |
|
738 |
|
739 // ---------------------------------------------------------------------------- |
|
740 // CHtiIAPHandler::GetAccessPointUIDL |
|
741 // Gets the UID of Access Point named by iConnName. |
|
742 // Returns KErrNotFound if AP not found. |
|
743 // ---------------------------------------------------------------------------- |
|
744 TInt CHtiIAPHandler::GetAccessPointUIDL() |
|
745 { |
|
746 HTI_LOG_FUNC_IN( "CHtiIAPHandler::GetAccessPointUIDL" ); |
|
747 TInt uid = KErrNotFound; |
|
748 |
|
749 RCmManagerExt cmManager; |
|
750 cmManager.OpenL(); |
|
751 CleanupClosePushL( cmManager ); |
|
752 |
|
753 // Search from uncategorised first |
|
754 RArray<TUint32> array = RArray<TUint32>(); |
|
755 cmManager.ConnectionMethodL( array ); |
|
756 CleanupClosePushL( array ); |
|
757 TInt i = 0; |
|
758 while ( i < array.Count() && uid == KErrNotFound ) |
|
759 { |
|
760 RCmConnectionMethodExt cm = cmManager.ConnectionMethodL( array[i] ); |
|
761 CleanupClosePushL( cm ); |
|
762 HBufC* name = cm.GetStringAttributeL( ECmName ); |
|
763 HTI_LOG_FORMAT( "Found name: %S", name ); |
|
764 CleanupStack::PushL( name ); |
|
765 if ( iConnName.Compare( *name ) == 0 ) |
|
766 { |
|
767 uid = cm.GetIntAttributeL( ECmId ); |
|
768 HTI_LOG_FORMAT( "Match: UID = %d", uid ); |
|
769 } |
|
770 CleanupStack::PopAndDestroy(); // name |
|
771 CleanupStack::PopAndDestroy(); // cm |
|
772 i++; |
|
773 } |
|
774 CleanupStack::PopAndDestroy(); // array |
|
775 |
|
776 // If not found from uncategorised, search from all destinations |
|
777 if ( uid == KErrNotFound ) |
|
778 { |
|
779 HTI_LOG_TEXT( "Not found from uncategorised" ); |
|
780 RArray<TUint32> destIdArray = RArray<TUint32>(); |
|
781 cmManager.AllDestinationsL( destIdArray ); |
|
782 CleanupClosePushL( destIdArray ); |
|
783 i = 0; |
|
784 while ( i < destIdArray.Count() && uid == KErrNotFound ) |
|
785 { |
|
786 RCmDestinationExt dest = cmManager.DestinationL( destIdArray[i] ); |
|
787 CleanupClosePushL( dest ); |
|
788 TInt j = 0; |
|
789 while ( j < dest.ConnectionMethodCount() && uid == KErrNotFound ) |
|
790 { |
|
791 HBufC* name = dest.ConnectionMethodL( j ).GetStringAttributeL( |
|
792 ECmName ); |
|
793 CleanupStack::PushL( name ); |
|
794 HTI_LOG_FORMAT( "Found name: %S", name ); |
|
795 if ( iConnName.Compare( *name ) == 0 ) |
|
796 { |
|
797 uid = dest.ConnectionMethodL( j ).GetIntAttributeL( |
|
798 ECmId ); |
|
799 HTI_LOG_FORMAT( "Match: UID = %d", uid ); |
|
800 } |
|
801 CleanupStack::PopAndDestroy(); // name |
|
802 j++; |
|
803 } |
|
804 CleanupStack::PopAndDestroy(); // dest |
|
805 i++; |
|
806 } |
|
807 CleanupStack::PopAndDestroy(); // destIdArray |
|
808 } |
|
809 |
|
810 CleanupStack::PopAndDestroy(); // cmManager |
|
811 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::GetAccessPointUIDL" ); |
|
812 return uid; |
|
813 } |
|
814 |
|
815 // ---------------------------------------------------------------------------- |
|
816 // CHtiIAPHandler::GetDestinationIDL |
|
817 // Gets the ID of Destination named by aName. |
|
818 // Returns KErrNotFound if Destination is not found. |
|
819 // ---------------------------------------------------------------------------- |
|
820 TInt CHtiIAPHandler::GetDestinationIDL( const TDesC& aName ) |
|
821 { |
|
822 HTI_LOG_FUNC_IN( "CHtiIAPHandler::GetDestinationIDL" ); |
|
823 HTI_LOG_FORMAT( "Searching Destination %S", &aName ); |
|
824 |
|
825 RCmManagerExt cmManager; |
|
826 cmManager.OpenL(); |
|
827 CleanupClosePushL( cmManager ); |
|
828 |
|
829 TInt id = KErrNotFound; |
|
830 RArray<TUint32> destIdArray = RArray<TUint32>( 8 ); |
|
831 CleanupClosePushL( destIdArray ); |
|
832 |
|
833 cmManager.AllDestinationsL( destIdArray ); |
|
834 TInt i = 0; |
|
835 while ( i < destIdArray.Count() && id == KErrNotFound ) |
|
836 { |
|
837 RCmDestinationExt dest = cmManager.DestinationL( destIdArray[i] ); |
|
838 CleanupClosePushL( dest ); |
|
839 HBufC* destName = dest.NameLC(); |
|
840 HTI_LOG_FORMAT( "Found Destination: %S", destName ); |
|
841 if ( destName->Compare( aName ) == 0 ) |
|
842 { |
|
843 id = dest.Id(); |
|
844 HTI_LOG_FORMAT( "Match: ID = %d", id ); |
|
845 } |
|
846 CleanupStack::PopAndDestroy( 2 ); // destName, dest |
|
847 i++; |
|
848 } |
|
849 |
|
850 CleanupStack::PopAndDestroy( 2 ); // destIdArray, cmManager |
|
851 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::GetDestinationIDL" ); |
|
852 return id; |
|
853 } |
|
854 |
|
855 |
|
856 // ---------------------------------------------------------------------------- |
|
857 // CHtiIAPHandler::CloseActiveConnectionsL |
|
858 // Closes connection(s) that are using the Access Point named by iConnName. |
|
859 // Leaves if closing fails. |
|
860 // ---------------------------------------------------------------------------- |
|
861 void CHtiIAPHandler::CloseActiveConnectionsL() |
|
862 { |
|
863 HTI_LOG_FUNC_IN( "CHtiIAPHandler::CloseActiveConnectionsL" ); |
|
864 |
|
865 RConnectionMonitor monitor; |
|
866 monitor.ConnectL(); |
|
867 CleanupClosePushL( monitor ); |
|
868 HTI_LOG_TEXT( "RConnectionMonitor connected" ); |
|
869 |
|
870 TUint connCount = 0; |
|
871 TUint subConnCount = 0; |
|
872 TUint connId = 0; |
|
873 //TUint iapId = 0; |
|
874 TName iapName; |
|
875 TRequestStatus status; |
|
876 |
|
877 monitor.GetConnectionCount( connCount, status ); |
|
878 User::WaitForRequest( status ); |
|
879 User::LeaveIfError( status.Int() ); |
|
880 HTI_LOG_FORMAT( "Found %d connections", connCount ); |
|
881 |
|
882 for ( TUint i = 1; i <= connCount; i++ ) |
|
883 { |
|
884 HTI_LOG_FORMAT( "Connection %d", i ); |
|
885 User::LeaveIfError( |
|
886 monitor.GetConnectionInfo( i, connId, subConnCount ) ); |
|
887 HTI_LOG_FORMAT( " Connection ID = %d", connId ); |
|
888 HTI_LOG_FORMAT( " Sub connections = %d", subConnCount ); |
|
889 /* |
|
890 monitor.GetUintAttribute( connId, 0, KIAPId, iapId, status ); |
|
891 User::WaitForRequest( status ); |
|
892 User::LeaveIfError( status.Int() ); |
|
893 HTI_LOG_FORMAT( " IAP ID = %d", iapId ); |
|
894 */ |
|
895 monitor.GetStringAttribute( connId, 0, KIAPName, iapName, status ); |
|
896 User::WaitForRequest( status ); |
|
897 User::LeaveIfError( status.Int() ); |
|
898 HTI_LOG_FORMAT( " IAP name = %S", &iapName ); |
|
899 if ( iapName.Compare( iConnName ) == 0 ) |
|
900 { |
|
901 HTI_LOG_TEXT( " Match: Trying to close this connection" ); |
|
902 User::LeaveIfError( |
|
903 monitor.SetBoolAttribute( connId, 0, KConnectionStop, ETrue ) ); |
|
904 } |
|
905 } |
|
906 |
|
907 CleanupStack::PopAndDestroy(); // monitor |
|
908 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::CloseActiveConnectionsL" ); |
|
909 } |
|
910 |
|
911 // ---------------------------------------------------------------------------- |
|
912 // CHtiIAPHandler::GetBearerUID |
|
913 // Helper function for mapping old TApBearerType value to new bearer type |
|
914 // ECom UID. |
|
915 // ---------------------------------------------------------------------------- |
|
916 TUint CHtiIAPHandler::GetBearerUID( const TInt aBearerType ) |
|
917 { |
|
918 HTI_LOG_FUNC_IN( "CHtiIAPHandler::GetBearerUID" ); |
|
919 TUint uid = 0; |
|
920 switch ( aBearerType ) |
|
921 { |
|
922 case 0x01: // CSD |
|
923 uid = KUidCSDBearerType; |
|
924 break; |
|
925 case 0x02: // GPRS |
|
926 uid = KUidPacketDataBearerType; |
|
927 break; |
|
928 case 0x04: // HSCSD |
|
929 uid = KUidHSCSDBearerType; |
|
930 break; |
|
931 case 0x10: // CDMA |
|
932 uid = KUidPacketDataBearerType; |
|
933 break; |
|
934 case 0x20: // WLAN |
|
935 uid = KUidWlanBearerType; |
|
936 break; |
|
937 default: |
|
938 break; |
|
939 |
|
940 } |
|
941 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::GetBearerUID" ); |
|
942 return uid; |
|
943 } |
|
944 |
|
945 // ---------------------------------------------------------------------------- |
|
946 // CHtiIAPHandler::MapLegacyFieldIDs |
|
947 // Helper function for mapping the old access point field ID numbers to |
|
948 // new ones. |
|
949 // ---------------------------------------------------------------------------- |
|
950 void CHtiIAPHandler::MapLegacyFieldIDs() |
|
951 { |
|
952 HTI_LOG_FUNC_IN( "CHtiIAPHandler::MapLegacyFieldIDs" ); |
|
953 |
|
954 for ( TInt i = 0; i < iFields.Count(); i++ ) |
|
955 { |
|
956 TApField field = iFields[i]; |
|
957 switch ( field.iId ) |
|
958 { |
|
959 case EApWapStartPage: |
|
960 { |
|
961 field.iId = ECmStartPage; |
|
962 break; |
|
963 } |
|
964 case EApIspDefaultTelNumber: |
|
965 { |
|
966 field.iId = EDialDefaultTelNum; |
|
967 break; |
|
968 } |
|
969 case EApIspUseLoginScript: |
|
970 { |
|
971 field.iId = EDialUseLoginScript; |
|
972 break; |
|
973 } |
|
974 case EApIspLoginScript: |
|
975 { |
|
976 field.iId = EDialLoginScript; |
|
977 break; |
|
978 } |
|
979 case EApIspLoginName: |
|
980 { |
|
981 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType ) |
|
982 field.iId = EDialIFAuthName; |
|
983 else if ( iBearerType == KUidPacketDataBearerType ) |
|
984 field.iId = EPacketDataIFAuthName; |
|
985 else |
|
986 field.iId = ECmIFAuthName; |
|
987 break; |
|
988 } |
|
989 case EApIspLoginPass: |
|
990 { |
|
991 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType ) |
|
992 field.iId = EDialIFAuthPass; |
|
993 else if ( iBearerType == KUidPacketDataBearerType ) |
|
994 field.iId = EPacketDataIFAuthPass; |
|
995 else |
|
996 field.iId = ECmIFAuthPass; |
|
997 break; |
|
998 } |
|
999 case EApIspIfPromptForAuth: |
|
1000 { |
|
1001 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType ) |
|
1002 field.iId = EDialIFPromptForAuth; |
|
1003 else if ( iBearerType == KUidPacketDataBearerType ) |
|
1004 field.iId = EPacketDataIFPromptForAuth; |
|
1005 else |
|
1006 field.iId = ECmIFPromptForAuth; |
|
1007 break; |
|
1008 } |
|
1009 case EApIspIfCallbackEnabled: |
|
1010 { |
|
1011 field.iId = EDialIFCallbackEnabled; |
|
1012 break; |
|
1013 } |
|
1014 case EApIspIfCallbackType: |
|
1015 { |
|
1016 field.iId = EDialIFCallbackType; |
|
1017 break; |
|
1018 } |
|
1019 case EApIspIfCallbackInfo: |
|
1020 { |
|
1021 field.iId = EDialIFCallbackInfo; |
|
1022 break; |
|
1023 } |
|
1024 case EApIspIPAddr: |
|
1025 { |
|
1026 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType ) |
|
1027 field.iId = EDialIPAddress; |
|
1028 else if ( iBearerType == KUidPacketDataBearerType ) |
|
1029 field.iId = EPacketDataIPAddr; |
|
1030 else if ( iBearerType == KUidWlanBearerType ) |
|
1031 field.iId = EWlanIpAddr; |
|
1032 else |
|
1033 field.iId = ECmIPAddress; |
|
1034 break; |
|
1035 } |
|
1036 case EApIspIPNameServer1: |
|
1037 { |
|
1038 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType ) |
|
1039 field.iId = EDialIPNameServer1; |
|
1040 else if ( iBearerType == KUidPacketDataBearerType ) |
|
1041 field.iId = EPacketDataIPNameServer1; |
|
1042 else if ( iBearerType == KUidWlanBearerType ) |
|
1043 field.iId = EWlanIpNameServer1; |
|
1044 else |
|
1045 field.iId = ECmIPNameServer1; |
|
1046 break; |
|
1047 } |
|
1048 case EApIspIPNameServer2: |
|
1049 { |
|
1050 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType ) |
|
1051 field.iId = EDialIPNameServer2; |
|
1052 else if ( iBearerType == KUidPacketDataBearerType ) |
|
1053 field.iId = EPacketDataIPNameServer2; |
|
1054 else if ( iBearerType == KUidWlanBearerType ) |
|
1055 field.iId = EWlanIpNameServer2; |
|
1056 else |
|
1057 field.iId = ECmIPNameServer2; |
|
1058 break; |
|
1059 } |
|
1060 case EApIspEnableIpHeaderComp: |
|
1061 { |
|
1062 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType ) |
|
1063 field.iId = EDialEnableIPHeaderComp; |
|
1064 else if ( iBearerType == KUidPacketDataBearerType ) |
|
1065 field.iId = EPacketDataHeaderCompression; |
|
1066 break; |
|
1067 } |
|
1068 case EApIspDisablePlainTextAuth: |
|
1069 { |
|
1070 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType ) |
|
1071 field.iId = EDialDisablePlainTextAuth; |
|
1072 else if ( iBearerType == KUidPacketDataBearerType ) |
|
1073 field.iId = EPacketDataDisablePlainTextAuth; |
|
1074 else |
|
1075 field.iId = ECmDisablePlainTextAuth; |
|
1076 break; |
|
1077 } |
|
1078 case EApIspBearerSpeed: |
|
1079 { |
|
1080 field.iId = EDialMaxConnSpeed; |
|
1081 break; |
|
1082 } |
|
1083 case EApIspBearerCallTypeIsdn: |
|
1084 { |
|
1085 field.iId = EDialCallType; |
|
1086 break; |
|
1087 } |
|
1088 case EApIspInitString: |
|
1089 { |
|
1090 field.iId = EDialInitString; |
|
1091 break; |
|
1092 } |
|
1093 case EApGprsAccessPointName: |
|
1094 { |
|
1095 field.iId = EPacketDataAPName; |
|
1096 break; |
|
1097 } |
|
1098 case EApGprsPdpType: |
|
1099 { |
|
1100 field.iId = EPacketDataPDPType; |
|
1101 break; |
|
1102 } |
|
1103 case EApProxyServerAddress: |
|
1104 { |
|
1105 field.iId = ECmProxyServerName; |
|
1106 break; |
|
1107 } |
|
1108 case EApProxyPortNumber: |
|
1109 { |
|
1110 field.iId = ECmProxyPortNumber; |
|
1111 break; |
|
1112 } |
|
1113 case EApIP6NameServer1: |
|
1114 { |
|
1115 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType ) |
|
1116 field.iId = EDialIP6NameServer1; |
|
1117 else if ( iBearerType == KUidPacketDataBearerType ) |
|
1118 field.iId = EPacketDataIPIP6NameServer1; |
|
1119 else if ( iBearerType == KUidWlanBearerType ) |
|
1120 field.iId = EWlanIp6NameServer1; |
|
1121 else |
|
1122 field.iId = ECmIP6NameServer1; |
|
1123 break; |
|
1124 } |
|
1125 case EApIP6NameServer2: |
|
1126 { |
|
1127 if ( iBearerType == KUidCSDBearerType || iBearerType == KUidHSCSDBearerType ) |
|
1128 field.iId = EDialIP6NameServer2; |
|
1129 else if ( iBearerType == KUidPacketDataBearerType ) |
|
1130 field.iId = EPacketDataIPIP6NameServer2; |
|
1131 else if ( iBearerType == KUidWlanBearerType ) |
|
1132 field.iId = EWlanIp6NameServer2; |
|
1133 else |
|
1134 field.iId = ECmIP6NameServer2; |
|
1135 break; |
|
1136 } |
|
1137 case EApWlanNetworkName: |
|
1138 { |
|
1139 field.iId = EWlanSSID; |
|
1140 break; |
|
1141 } |
|
1142 case EApWlanNetworkMode: |
|
1143 { |
|
1144 field.iId = EWlanConnectionMode; |
|
1145 break; |
|
1146 } |
|
1147 case EApWlanSecurityMode: |
|
1148 { |
|
1149 field.iId = EWlanSecurityMode; |
|
1150 break; |
|
1151 } |
|
1152 case EApSeamlessnessLevel: |
|
1153 { |
|
1154 field.iId = ECmSeamlessnessLevel; |
|
1155 break; |
|
1156 } |
|
1157 default: |
|
1158 break; |
|
1159 } |
|
1160 iFields[i] = field; |
|
1161 } |
|
1162 |
|
1163 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::MapLegacyFieldIDs" ); |
|
1164 } |
|
1165 |
|
1166 // ---------------------------------------------------------------------------- |
|
1167 // CHtiIAPHandler::ResolveFieldDataTypes |
|
1168 // Helper function for resolving the data types for different AP settings |
|
1169 // fields based on field ID and bearer type. |
|
1170 // ---------------------------------------------------------------------------- |
|
1171 void CHtiIAPHandler::ResolveFieldDataTypes() |
|
1172 { |
|
1173 HTI_LOG_FUNC_IN( "CHtiIAPHandler::ResolveFieldDataTypes" ); |
|
1174 |
|
1175 for ( TInt i = 0; i < iFields.Count(); i++ ) |
|
1176 { |
|
1177 if ( iFields[i].iDataType != EDataTypeUnknown ) continue; // already set |
|
1178 |
|
1179 // Common fields |
|
1180 switch ( iFields[i].iId ) |
|
1181 { |
|
1182 // String types |
|
1183 case ECmStartPage: |
|
1184 case ECmProxyServerName: |
|
1185 case ECmProxyProtocolName: |
|
1186 case ECmProxyExceptions: |
|
1187 case ECmIFName: |
|
1188 case ECmIFParams: |
|
1189 case ECmIFNetworks: |
|
1190 case ECmIFAuthName: |
|
1191 case ECmIFAuthPass: |
|
1192 case ECmIPGateway: |
|
1193 case ECmIPAddress: |
|
1194 case ECmIPNameServer1: |
|
1195 case ECmIPNameServer2: |
|
1196 case ECmIP6NameServer1: |
|
1197 case ECmIP6NameServer2: |
|
1198 iFields[i].iDataType = EDataTypeText; |
|
1199 break; |
|
1200 |
|
1201 // Bool types |
|
1202 case ECmProtected: |
|
1203 case ECmIFPromptForAuth: |
|
1204 case ECmIPAddFromServer: |
|
1205 case ECmIPDNSAddrFromServer: |
|
1206 case ECmIP6DNSAddrFromServer: |
|
1207 case ECmEnableLPCExtension: |
|
1208 case ECmDisablePlainTextAuth: |
|
1209 iFields[i].iDataType = EDataTypeBool; |
|
1210 break; |
|
1211 |
|
1212 // Uint types |
|
1213 case ECmSeamlessnessLevel: |
|
1214 case ECmProxyPortNumber: |
|
1215 case ECmIFAuthRetries: |
|
1216 iFields[i].iDataType = EDataTypeUint; |
|
1217 break; |
|
1218 |
|
1219 default: |
|
1220 break; |
|
1221 } |
|
1222 |
|
1223 // If it was found from common fields, we can continue to next field |
|
1224 if ( iFields[i].iDataType != EDataTypeUnknown ) continue; |
|
1225 |
|
1226 // Check from bearer specific fields. |
|
1227 // Different bearers have to be in separate switch-cases because |
|
1228 // there are same values in different bearers. |
|
1229 |
|
1230 // Data call fields |
|
1231 if ( iBearerType == KUidCSDBearerType || |
|
1232 iBearerType == KUidHSCSDBearerType ) |
|
1233 { |
|
1234 switch ( iFields[i].iId ) |
|
1235 { |
|
1236 // String types |
|
1237 case EDialDescription: |
|
1238 case EDialDefaultTelNum: |
|
1239 case EDialLoginScript: |
|
1240 case EDialLoginName: |
|
1241 case EDialLoginPassword: |
|
1242 case EDialIFParams: |
|
1243 case EDialIFNetworks: |
|
1244 case EDialIFAuthName: |
|
1245 case EDialIFAuthPass: |
|
1246 case EDialIPAddress: |
|
1247 case EDialIPNetmask: |
|
1248 case EDialIPGateway: |
|
1249 case EDialIPNameServer1: |
|
1250 case EDialIPNameServer2: |
|
1251 case EDialIP6NameServer1: |
|
1252 case EDialIP6NameServer2: |
|
1253 iFields[i].iDataType = EDataTypeText; |
|
1254 break; |
|
1255 |
|
1256 // Bool types |
|
1257 case EDialOut: |
|
1258 case EDialDialResolution: |
|
1259 case EDialUseLoginScript: |
|
1260 case EDialPromptForLogin: |
|
1261 case EDialDisplayPCT: |
|
1262 case EDialIFPromptForAuth: |
|
1263 case EDialIFCallbackEnabled: |
|
1264 case EDialIFServerMode: |
|
1265 case EDialIPAddressFromServer: |
|
1266 case EDialIPDNSAddressFromServer: |
|
1267 case EDialIP6DNSAddressFromServer: |
|
1268 case EDialEnableIPHeaderComp: |
|
1269 case EDialEnableLCPExtension: |
|
1270 case EDialDisablePlainTextAuth: |
|
1271 case EDialEnableSWComp: |
|
1272 case EDialUseEdge: |
|
1273 iFields[i].iDataType = EDataTypeBool; |
|
1274 break; |
|
1275 |
|
1276 // Uint types |
|
1277 case EDialCallType: |
|
1278 case EDialMaxConnSpeed: |
|
1279 case EDialType: |
|
1280 case EDialChargeCard: |
|
1281 case EDialIFAuthRetries: |
|
1282 case EDialIFCallbackType: |
|
1283 case EDialCallbackTimeout: |
|
1284 case EDialBearerName: |
|
1285 case EDialBearerSpeed: |
|
1286 case EDialBearerCE: |
|
1287 case EDialBearerService: |
|
1288 case EDialBearerProtocol: |
|
1289 case EDialRLPVersion: |
|
1290 case EDialIWFtoMS: |
|
1291 case EDialMStoIWF: |
|
1292 case EDialAckTimer: |
|
1293 case EDialRetransmissionAttempts: |
|
1294 case EDialResequencePeriod: |
|
1295 case EDialV42Compression: |
|
1296 case EDialV42CodeWords: |
|
1297 case EDialV42MaxLength: |
|
1298 case EHscsdAsymmetry: |
|
1299 case EHscsdUserInitUpgrade: |
|
1300 iFields[i].iDataType = EDataTypeUint; |
|
1301 break; |
|
1302 |
|
1303 // 8-bit string types |
|
1304 case EDialIFCallbackInfo: |
|
1305 case EDialInitString: |
|
1306 iFields[i].iDataType = EDataTypeText8; |
|
1307 break; |
|
1308 |
|
1309 default: |
|
1310 break; |
|
1311 } |
|
1312 } |
|
1313 |
|
1314 // Packet data fields |
|
1315 else if ( iBearerType == KUidPacketDataBearerType ) |
|
1316 { |
|
1317 switch ( iFields[i].iId ) |
|
1318 { |
|
1319 // String types |
|
1320 case EPacketDataAPName: |
|
1321 case EPacketDataPDPAddress: |
|
1322 case EPacketDataIFParams: |
|
1323 case EPacketDataIFNetworks: |
|
1324 case EPacketDataIFAuthName: |
|
1325 case EPacketDataIFAuthPass: |
|
1326 case EPacketDataIPNetmask: |
|
1327 case EPacketDataIPGateway: |
|
1328 case EPacketDataIPAddr: |
|
1329 case EPacketDataIPNameServer1: |
|
1330 case EPacketDataIPNameServer2: |
|
1331 case EPacketDataIPIP6NameServer1: |
|
1332 case EPacketDataIPIP6NameServer2: |
|
1333 iFields[i].iDataType = EDataTypeText; |
|
1334 break; |
|
1335 |
|
1336 // Bool types |
|
1337 case EPacketDataDataCompression: |
|
1338 case EPacketDataHeaderCompression: |
|
1339 case EPacketDataUseEdge: |
|
1340 case EPacketDataAnonymousAccess: |
|
1341 case EPacketDataIFPromptForAuth: |
|
1342 case EPacketDataIPAddrFromServer: |
|
1343 case EPacketDataIPDNSAddrFromServer: |
|
1344 case EPacketDataIPIP6DNSAddrFromServer: |
|
1345 case EPacketDataEnableLcpExtension: |
|
1346 case EPacketDataDisablePlainTextAuth: |
|
1347 case EPacketDataServiceEnableLLMNR: |
|
1348 iFields[i].iDataType = EDataTypeBool; |
|
1349 break; |
|
1350 |
|
1351 // Uint types |
|
1352 case EPacketDataPDPType: |
|
1353 case EPacketDataIFAuthRetries: |
|
1354 case EPacketDataApType: |
|
1355 iFields[i].iDataType = EDataTypeUint; |
|
1356 break; |
|
1357 |
|
1358 default: |
|
1359 break; |
|
1360 } |
|
1361 } |
|
1362 |
|
1363 // WLAN fields |
|
1364 else if ( iBearerType == KUidWlanBearerType ) |
|
1365 { |
|
1366 switch ( iFields[i].iId ) |
|
1367 { |
|
1368 // String types |
|
1369 case EWlanIfNetworks: |
|
1370 case EWlanIpNetMask: |
|
1371 case EWlanIpGateway: |
|
1372 case EWlanIpAddr: |
|
1373 case EWlanIpNameServer1: |
|
1374 case EWlanIpNameServer2: |
|
1375 case EWlanIp6NameServer1: |
|
1376 case EWlanIp6NameServer2: |
|
1377 case EWlanSSID: |
|
1378 case EWlanUsedSSID: |
|
1379 iFields[i].iDataType = EDataTypeText; |
|
1380 break; |
|
1381 |
|
1382 // Bool types |
|
1383 case EWlanIpAddrFromServer: |
|
1384 case EWlanIpDNSAddrFromServer: |
|
1385 case EWlanIp6DNSAddrFromServer: |
|
1386 case EWlanScanSSID: |
|
1387 case EWlanAllowSSIDRoaming: |
|
1388 iFields[i].iDataType = EDataTypeBool; |
|
1389 break; |
|
1390 |
|
1391 // Uint types |
|
1392 case EWlanServiceId: |
|
1393 case EWlanConnectionMode: |
|
1394 case EWlanSecurityMode: |
|
1395 case EWlanAuthenticationMode: |
|
1396 case EWlanChannelID: |
|
1397 iFields[i].iDataType = EDataTypeUint; |
|
1398 break; |
|
1399 |
|
1400 default: |
|
1401 break; |
|
1402 } |
|
1403 } |
|
1404 |
|
1405 else |
|
1406 { |
|
1407 HTI_LOG_TEXT( "Unknown bearer type" ) |
|
1408 } |
|
1409 } |
|
1410 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::ResolveFieldDataTypes" ); |
|
1411 } |
|
1412 |
|
1413 |
|
1414 // ---------------------------------------------------------------------------- |
|
1415 // CHtiIAPHandler::SendOkMsgL |
|
1416 // Helper function for sending response messages. |
|
1417 // ---------------------------------------------------------------------------- |
|
1418 void CHtiIAPHandler::SendOkMsgL( const TDesC8& aData ) |
|
1419 { |
|
1420 HTI_LOG_FUNC_IN( "CHtiIAPHandler::SendOkMsgL" ); |
|
1421 User::LeaveIfNull( iDispatcher ); |
|
1422 HBufC8* temp = HBufC8::NewL( aData.Length() + 1 ); |
|
1423 TPtr8 response = temp->Des(); |
|
1424 response.Append( ( TChar ) CHtiMessagesServicePlugin::EResultOk ); |
|
1425 response.Append( aData ); |
|
1426 User::LeaveIfError( iDispatcher->DispatchOutgoingMessage( |
|
1427 temp, KHtiMessagesServiceUid ) ); |
|
1428 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::SendOkMsgL" ); |
|
1429 } |
|
1430 |
|
1431 |
|
1432 // ---------------------------------------------------------------------------- |
|
1433 // CHtiIAPHandler::SendErrorMessageL |
|
1434 // Helper function for sending error response messages. |
|
1435 // ---------------------------------------------------------------------------- |
|
1436 void CHtiIAPHandler::SendErrorMessageL( TInt aError, const TDesC8& aDescription ) |
|
1437 { |
|
1438 HTI_LOG_FUNC_IN( "CHtiIAPHandler::SendErrorMessageL" ); |
|
1439 User::LeaveIfNull( iDispatcher ); |
|
1440 User::LeaveIfError( iDispatcher->DispatchOutgoingErrorMessage( |
|
1441 aError, aDescription, KHtiMessagesServiceUid ) ); |
|
1442 HTI_LOG_FUNC_OUT( "CHtiIAPHandler::SendErrorMessageL" ); |
|
1443 } |
|
1444 |
|
1445 |
|
1446 // End of file |