|
1 /* |
|
2 * Copyright (c) 2007-2008 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 RWsfSession |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 // CLASS HEADER |
|
21 #include "wsfsession.h" |
|
22 |
|
23 // INTERNAL INCLUDES |
|
24 #include "wsfwlaninfoarray.h" |
|
25 #include "wsfeventhandler.h" |
|
26 #include "wsfactivewaiter.h" |
|
27 #include "wsfservercommon.h" |
|
28 #include "wsflogger.h" |
|
29 |
|
30 |
|
31 |
|
32 // LOCAL DEFINITIONS |
|
33 /** |
|
34 * Number of message slots at the server |
|
35 */ |
|
36 static const TInt KIPCSlots = 6; |
|
37 |
|
38 /** |
|
39 * Number of retries to start the server |
|
40 */ |
|
41 static const TInt KRetries = 3; |
|
42 |
|
43 |
|
44 |
|
45 // --------------------------------------------------------------------------- |
|
46 // RWsfSession::RWsfSession |
|
47 // --------------------------------------------------------------------------- |
|
48 EXPORT_C RWsfSession::RWsfSession(): |
|
49 RSessionBase(), |
|
50 iEventHandler( 0 ), |
|
51 iConnectingResult( KErrNone ) |
|
52 { |
|
53 } |
|
54 |
|
55 |
|
56 // --------------------------------------------------------------------------- |
|
57 // RWsfSession::StartServer |
|
58 // --------------------------------------------------------------------------- |
|
59 TInt RWsfSession::StartServer() |
|
60 { |
|
61 LOG_ENTERFN( "RWsfSession::StartServerL" ); |
|
62 |
|
63 TInt res( KErrNone ); |
|
64 // create server - if one of this name does not already exist |
|
65 TFindServer findServer( KWlanSnifferServerName ); |
|
66 TFullName name; |
|
67 |
|
68 if ( findServer.Next( name ) != KErrNone ) // we don't exist already |
|
69 { |
|
70 RProcess server; |
|
71 // Create the server process |
|
72 res = server.Create( KWlanSnifferServerExe, KNullDesC ); |
|
73 |
|
74 if ( res != KErrNone ) // thread created ok - now start it going |
|
75 { |
|
76 return res; |
|
77 } |
|
78 |
|
79 // Rendezvous is used to detect server start |
|
80 TRequestStatus status; |
|
81 server.Rendezvous( status ); |
|
82 |
|
83 if ( status != KRequestPending ) |
|
84 { |
|
85 LOG_WRITEF( "StartServer Rendezvous ERROR: %d", status.Int() ); |
|
86 server.Kill( 0 ); // abort startup |
|
87 } |
|
88 else |
|
89 { |
|
90 server.Resume(); // logon OK - start the server |
|
91 } |
|
92 |
|
93 LOG_WRITE( "StartServer wait for start" ); |
|
94 User::WaitForRequest( status ); // wait for start or death |
|
95 |
|
96 // We can't use the 'exit reason' if the server paniced as this |
|
97 // is the panic 'reason' and may be '0' which cannot be distinguished |
|
98 // from KErrNone |
|
99 res = ( server.ExitType() == EExitPanic ) ? KErrGeneral : status.Int(); |
|
100 |
|
101 // we're no longer interested in the other process |
|
102 server.Close(); |
|
103 } |
|
104 |
|
105 return res; |
|
106 } |
|
107 |
|
108 |
|
109 // --------------------------------------------------------------------------- |
|
110 // RWsfSession::Connect |
|
111 // --------------------------------------------------------------------------- |
|
112 // |
|
113 EXPORT_C TInt RWsfSession::Connect() |
|
114 { |
|
115 LOG_ENTERFN( "RWsfSession::Connect" ); |
|
116 TInt err = StartServer(); |
|
117 |
|
118 for (TInt tries = 0; tries < KRetries; tries++) |
|
119 { |
|
120 LOG_WRITE( "server started" ); |
|
121 |
|
122 err = CreateSession( KWlanSnifferServerName, Version(), KIPCSlots ); |
|
123 |
|
124 LOG_WRITEF( "CreateSession() returned %d", err ); |
|
125 |
|
126 if (!err) |
|
127 { |
|
128 LOG_WRITE( "connected" ); |
|
129 TRAP( err, iConnWaiter = new (ELeave) CActiveSchedulerWait() ); |
|
130 break; |
|
131 } |
|
132 if (err != KErrNotFound && err != KErrServerTerminated) |
|
133 { |
|
134 LOG_WRITE( "problems session creation - break" ); |
|
135 break; |
|
136 } |
|
137 |
|
138 TInt err = StartServer(); // try to launch the server |
|
139 |
|
140 if (!err) |
|
141 { |
|
142 LOG_WRITE( "ok - try to connect again" ); |
|
143 continue; |
|
144 } |
|
145 |
|
146 if (err == KErrAlreadyExists) |
|
147 { |
|
148 LOG_WRITE( "someone else started - try to connect again" ); |
|
149 continue; |
|
150 } |
|
151 |
|
152 LOG_WRITE( "problems - break" ); |
|
153 break; |
|
154 } |
|
155 |
|
156 LOG_WRITEF( "connect exit value = %d", err ); |
|
157 |
|
158 return err; |
|
159 } |
|
160 |
|
161 |
|
162 // --------------------------------------------------------------------------- |
|
163 // RWsfSession::Version |
|
164 // --------------------------------------------------------------------------- |
|
165 // |
|
166 TVersion RWsfSession::Version() const |
|
167 { |
|
168 return TVersion( KWlanSnifferServerMajor, |
|
169 KWlanSnifferServerMinor, |
|
170 KWlanSnifferServerBuild ); |
|
171 } |
|
172 |
|
173 |
|
174 // --------------------------------------------------------------------------- |
|
175 // RWsfSession::CancelNotifyEvent |
|
176 // --------------------------------------------------------------------------- |
|
177 // |
|
178 EXPORT_C void RWsfSession::CancelNotifyEvent() |
|
179 { |
|
180 LOG_ENTERFN( "RWsfSession::CancelNotifyEvent" ); |
|
181 if ( iEventHandler ) |
|
182 { |
|
183 iEventHandler->Cancel(); |
|
184 } |
|
185 } |
|
186 |
|
187 |
|
188 // --------------------------------------------------------------------------- |
|
189 // RWsfSession::ConnectedAccountNameL |
|
190 // --------------------------------------------------------------------------- |
|
191 // |
|
192 EXPORT_C HBufC* RWsfSession::ConnectedAccountNameL() |
|
193 { |
|
194 LOG_ENTERFN("RWsfSession::ConnectedAccountNameL"); |
|
195 TPckgBuf<TWsfQueryConnectedAccount> package; |
|
196 CWsfActiveWaiter *waiter = CWsfActiveWaiter::NewL(); |
|
197 CleanupStack::PushL( waiter ); |
|
198 SendReceive( ESnifferCmdConnectionName, TIpcArgs( &package ), |
|
199 waiter->iStatus ); |
|
200 waiter->WaitForRequest(); |
|
201 LOG_WRITEF( "message[%d] call returned %d", |
|
202 ESnifferCmdConnectionName, |
|
203 waiter->iStatus.Int() ); |
|
204 User::LeaveIfError( waiter->iStatus.Int() ); |
|
205 CleanupStack::PopAndDestroy( waiter ); |
|
206 |
|
207 if ( package().iConnected ) |
|
208 { |
|
209 return package().iConnectedAccountName.AllocL(); |
|
210 } |
|
211 return KNullDesC().AllocL(); |
|
212 } |
|
213 |
|
214 |
|
215 // --------------------------------------------------------------------------- |
|
216 // RWsfSession::GetConnectedWlanDetailsL |
|
217 // --------------------------------------------------------------------------- |
|
218 // |
|
219 EXPORT_C TBool RWsfSession::GetConnectedWlanDetailsL( TWsfWlanInfo& aWlanInfo ) |
|
220 { |
|
221 LOG_ENTERFN("RWsfSession::GetConnectedWlanDetailsL"); |
|
222 TPckgBuf<TBool> ret( EFalse ); |
|
223 TPckg<TWsfWlanInfo> package( aWlanInfo ); |
|
224 |
|
225 CWsfActiveWaiter *waiter = CWsfActiveWaiter::NewL(); |
|
226 CleanupStack::PushL( waiter ); |
|
227 |
|
228 SendReceive( ESnifferCmdConnectedDetails, TIpcArgs( &ret, &package ), |
|
229 waiter->iStatus ); |
|
230 waiter->WaitForRequest(); |
|
231 LOG_WRITEF( "message[%d] call returned %d", |
|
232 ESnifferCmdConnectedDetails, |
|
233 waiter->iStatus.Int() ); |
|
234 User::LeaveIfError( waiter->iStatus.Int() ); |
|
235 CleanupStack::PopAndDestroy( waiter ); |
|
236 |
|
237 return ret(); |
|
238 } |
|
239 |
|
240 |
|
241 // --------------------------------------------------------------------------- |
|
242 // RWsfSession::GetConnectedWlanDetails |
|
243 // --------------------------------------------------------------------------- |
|
244 // |
|
245 EXPORT_C void RWsfSession::GetConnectedWlanDetails( TPckgBuf<TBool>& aPckg, |
|
246 TWsfWlanInfo& aWlanInfo, |
|
247 TRequestStatus& aStatus ) |
|
248 { |
|
249 LOG_ENTERFN("RWsfSession::GetConnectedWlanDetails"); |
|
250 TPckg<TWsfWlanInfo> package( aWlanInfo ); |
|
251 |
|
252 SendReceive( ESnifferCmdConnectedDetails, TIpcArgs( &aPckg, &package ), |
|
253 aStatus ); |
|
254 } |
|
255 |
|
256 |
|
257 // --------------------------------------------------------------------------- |
|
258 // RWsfSession::NotifyEventL |
|
259 // --------------------------------------------------------------------------- |
|
260 // |
|
261 EXPORT_C void RWsfSession::NotifyEventL( MWsfStateChangeObserver& aObserver ) |
|
262 { |
|
263 LOG_ENTERFN("RWsfSession::NotifyEventL"); |
|
264 if ( !iEventHandler ) |
|
265 { |
|
266 iEventHandler = CWsfEventHandler::NewL( *this, aObserver ); |
|
267 } |
|
268 iEventHandler->ResetObserver( aObserver ); |
|
269 if ( !iEventHandler->IsActive() ) |
|
270 { |
|
271 iEventHandler->Start(); |
|
272 SendReceive( ESnifferCmdNotifyEvents, |
|
273 TIpcArgs( &iEventHandler->EventContainer() ), |
|
274 iEventHandler->iStatus ); |
|
275 } |
|
276 } |
|
277 |
|
278 |
|
279 // --------------------------------------------------------------------------- |
|
280 // RWsfSession::EnableScanL |
|
281 // --------------------------------------------------------------------------- |
|
282 // |
|
283 EXPORT_C TBool RWsfSession::EnableScanL() |
|
284 { |
|
285 LOG_ENTERFN("RWsfSession::EnableScanL"); |
|
286 |
|
287 TInt err = Send( ESnifferCmdActivateScan ); |
|
288 LOG_WRITEF( "message[%d] call returned %d", ESnifferCmdActivateScan, err ); |
|
289 |
|
290 User::LeaveIfError( err ); |
|
291 |
|
292 return !err; |
|
293 } |
|
294 |
|
295 |
|
296 // --------------------------------------------------------------------------- |
|
297 // RWsfSession::DisableScanL |
|
298 // --------------------------------------------------------------------------- |
|
299 // |
|
300 EXPORT_C TBool RWsfSession::DisableScanL() |
|
301 { |
|
302 LOG_ENTERFN("RWsfSession::DisableScanL"); |
|
303 |
|
304 TInt err = Send( ESnifferCmdDisableScan ); |
|
305 LOG_WRITEF( "message[%d] call returned %d", ESnifferCmdDisableScan, err ); |
|
306 |
|
307 User::LeaveIfError( err ); |
|
308 |
|
309 return !err; |
|
310 } |
|
311 |
|
312 |
|
313 // --------------------------------------------------------------------------- |
|
314 // RWsfSession::IsScanEnabledL |
|
315 // --------------------------------------------------------------------------- |
|
316 // |
|
317 EXPORT_C TBool RWsfSession::IsScanEnabledL() |
|
318 { |
|
319 LOG_ENTERFN("RWsfSession::IsScanEnabledL"); |
|
320 TBool res = 0; |
|
321 TPckgBuf<TInt> pckg; |
|
322 |
|
323 CWsfActiveWaiter *waiter = CWsfActiveWaiter::NewL(); |
|
324 CleanupStack::PushL( waiter ); |
|
325 |
|
326 SendReceive( ESnifferCmdIsScanEnabled, TIpcArgs( &pckg ), |
|
327 waiter->iStatus ); |
|
328 waiter->WaitForRequest(); |
|
329 LOG_WRITEF( "message[%d] call returned %d", |
|
330 ESnifferCmdIsScanEnabled, |
|
331 waiter->iStatus.Int() ); |
|
332 User::LeaveIfError( waiter->iStatus.Int() ); |
|
333 CleanupStack::PopAndDestroy( waiter ); |
|
334 |
|
335 res = pckg(); |
|
336 return res; |
|
337 } |
|
338 |
|
339 |
|
340 // --------------------------------------------------------------------------- |
|
341 // RWsfSession::UpdateWlanListL |
|
342 // --------------------------------------------------------------------------- |
|
343 // |
|
344 EXPORT_C void RWsfSession::UpdateWlanListL( CWsfWlanInfoArray* aInfoArray ) |
|
345 { |
|
346 LOG_ENTERFN("RWsfSession::UpdateWlanListL"); |
|
347 // first request the buffer size for wlan data... |
|
348 TPckgBuf<TUint> pckg; |
|
349 TUint infoArrayElementCount = aInfoArray->Count(); |
|
350 |
|
351 CWsfActiveWaiter *waiter = CWsfActiveWaiter::NewL(); |
|
352 CleanupStack::PushL( waiter ); |
|
353 |
|
354 SendReceive( ESnifferCmdWlanDataSize, TIpcArgs( &pckg ), waiter->iStatus ); |
|
355 waiter->WaitForRequest(); |
|
356 LOG_WRITEF( "message[%d] call returned %d", |
|
357 ESnifferCmdWlanDataSize, |
|
358 waiter->iStatus.Int() ); |
|
359 User::LeaveIfError( waiter->iStatus.Int() ); |
|
360 |
|
361 // alloc the required size buffer... |
|
362 TInt requiredSize = pckg(); |
|
363 LOG_WRITEF( "WLAN data buffer size = %d", requiredSize ); |
|
364 |
|
365 if ( !requiredSize ) |
|
366 { |
|
367 // no data ... |
|
368 CleanupStack::PopAndDestroy( waiter ); |
|
369 return; |
|
370 } |
|
371 |
|
372 HBufC8* buffer = HBufC8::NewLC( requiredSize ); |
|
373 TPtr8 ptr = buffer->Des(); |
|
374 |
|
375 SendReceive( ESnifferCmdGetWlanInfo, TIpcArgs( &pckg, &ptr ), |
|
376 waiter->iStatus ); |
|
377 waiter->WaitForRequest(); |
|
378 LOG_WRITEF( "message[%d] call returned %d", |
|
379 ESnifferCmdGetWlanInfo, |
|
380 waiter->iStatus.Int() ); |
|
381 User::LeaveIfError( waiter->iStatus.Int() ); |
|
382 |
|
383 |
|
384 LOG_WRITEF( "actual bytes occupied = %d", pckg() ); |
|
385 |
|
386 if ( requiredSize != pckg() ) |
|
387 { |
|
388 // the buffer is not long enough... we must try again... |
|
389 User::Leave( KErrOverflow ); |
|
390 } |
|
391 |
|
392 // Check that aInfoArray has not been modified |
|
393 // while we waited server response |
|
394 if ( aInfoArray->Count() != infoArrayElementCount ) |
|
395 { |
|
396 LOG_WRITEF( "aInfoArray data has changed %d != %d ", |
|
397 aInfoArray->Count(), infoArrayElementCount ); |
|
398 aInfoArray->Reset(); |
|
399 } |
|
400 |
|
401 aInfoArray->AppendFromStreamBufferL( ptr ); |
|
402 CleanupStack::PopAndDestroy( buffer ); |
|
403 CleanupStack::PopAndDestroy( waiter ); |
|
404 } |
|
405 |
|
406 |
|
407 // --------------------------------------------------------------------------- |
|
408 // RWsfSession::GetWlanListSize |
|
409 // --------------------------------------------------------------------------- |
|
410 // |
|
411 EXPORT_C void RWsfSession::GetWlanListSize( TPckgBuf<TUint> &aPckg, TRequestStatus& aStatus ) |
|
412 { |
|
413 LOG_ENTERFN("RWsfSession::GetWlanListSize"); |
|
414 SendReceive( ESnifferCmdWlanDataSize, TIpcArgs( &aPckg ), aStatus ); |
|
415 } |
|
416 |
|
417 |
|
418 // --------------------------------------------------------------------------- |
|
419 // RWsfSession::GetWlanList |
|
420 // --------------------------------------------------------------------------- |
|
421 // |
|
422 EXPORT_C void RWsfSession::GetWlanList( TPckgBuf<TUint>& aPckg, TPtr8& aPtr, TRequestStatus& aStatus ) |
|
423 { |
|
424 LOG_ENTERFN("RWsfSession::GetWlanList"); |
|
425 SendReceive( ESnifferCmdGetWlanInfo, TIpcArgs( &aPckg, &aPtr ), aStatus ); |
|
426 } |
|
427 |
|
428 |
|
429 // --------------------------------------------------------------------------- |
|
430 // RWsfSession::MonitorAccessPointL |
|
431 // --------------------------------------------------------------------------- |
|
432 // |
|
433 EXPORT_C void RWsfSession::MonitorAccessPointL( TUint32 aMonitoredIap ) |
|
434 { |
|
435 LOG_ENTERFN("RWsfSession::MonitorAccessPointL"); |
|
436 |
|
437 TInt err = Send( ESnifferCmdMonitorAp, TIpcArgs( aMonitoredIap )); |
|
438 LOG_WRITEF( "message[%d] call returned %d", ESnifferCmdMonitorAp, err ); |
|
439 |
|
440 User::LeaveIfError( err ); |
|
441 } |
|
442 |
|
443 |
|
444 // --------------------------------------------------------------------------- |
|
445 // RWsfSession::RequestScanL |
|
446 // --------------------------------------------------------------------------- |
|
447 // |
|
448 EXPORT_C TBool RWsfSession::RequestScanL() |
|
449 { |
|
450 LOG_ENTERFN("RWsfSession::RequestScanL"); |
|
451 TPckgBuf<TBool> pckg; |
|
452 |
|
453 CWsfActiveWaiter *waiter = CWsfActiveWaiter::NewL(); |
|
454 CleanupStack::PushL( waiter ); |
|
455 |
|
456 SendReceive( ESnifferCmdRequestScan, TIpcArgs( &pckg ), waiter->iStatus ); |
|
457 waiter->WaitForRequest(); |
|
458 LOG_WRITEF( "message[%d] call returned %d", |
|
459 ESnifferCmdRequestScan, |
|
460 waiter->iStatus.Int() ); |
|
461 User::LeaveIfError( waiter->iStatus.Int() ); |
|
462 CleanupStack::PopAndDestroy( waiter ); |
|
463 return pckg(); |
|
464 } |
|
465 |
|
466 |
|
467 // --------------------------------------------------------------------------- |
|
468 // RWsfSession::RequestScan |
|
469 // --------------------------------------------------------------------------- |
|
470 // |
|
471 EXPORT_C void RWsfSession::RequestScan(TPckgBuf<TBool>& aPckg, TRequestStatus& aStatus ) |
|
472 { |
|
473 LOG_ENTERFN("RWsfSession::RequestScan"); |
|
474 SendReceive( ESnifferCmdRequestScan, TIpcArgs( &aPckg ), aStatus ); |
|
475 } |
|
476 |
|
477 |
|
478 // --------------------------------------------------------------------------- |
|
479 // RWsfSession::ConnectWlanBearerL |
|
480 // --------------------------------------------------------------------------- |
|
481 // |
|
482 EXPORT_C TInt RWsfSession::ConnectWlanBearerL( TUint32 aIapId, |
|
483 TBool aConnectOnly, |
|
484 TWsfIapPersistence aPersistence ) |
|
485 { |
|
486 LOG_ENTERFN( "RWsfSession::ConnectWlanBearerL" ); |
|
487 LOG_WRITEF( "IAP id = %d", aIapId ); |
|
488 |
|
489 // mark the beginning of the connection process |
|
490 iEventHandler->UnBlockNextConnectedEvent(); |
|
491 iEventHandler->SetConnecting( ETrue ); |
|
492 |
|
493 TInt res( KErrNone ); |
|
494 TPckgBuf<TInt> pckg; |
|
495 |
|
496 CWsfActiveWaiter *waiter = CWsfActiveWaiter::NewL(); |
|
497 CleanupStack::PushL( waiter ); |
|
498 |
|
499 SendReceive( ESnifferCmdConnect, |
|
500 TIpcArgs( &pckg, aIapId, aConnectOnly, aPersistence ), |
|
501 waiter->iStatus ); |
|
502 |
|
503 waiter->WaitForRequest(); |
|
504 LOG_WRITEF( "message[%d] call returned %d", |
|
505 ESnifferCmdConnect, |
|
506 waiter->iStatus.Int() ); |
|
507 User::LeaveIfError( waiter->iStatus.Int() ); |
|
508 CleanupStack::PopAndDestroy( waiter ); |
|
509 |
|
510 res = pckg(); |
|
511 |
|
512 if ( res != KErrNone ) |
|
513 { |
|
514 // on any error the flag should be cleared |
|
515 iEventHandler->SetConnecting( EFalse ); |
|
516 } |
|
517 else |
|
518 { |
|
519 // otherwise we must wait until the connected signal arrives |
|
520 iConnWaiter->Start(); |
|
521 } |
|
522 |
|
523 if ( iConnectingResult ) |
|
524 { |
|
525 // the caller must know if the connecting process was cancelled |
|
526 res = iConnectingResult; |
|
527 iConnectingResult = KErrNone; |
|
528 } |
|
529 |
|
530 return res; |
|
531 } |
|
532 |
|
533 |
|
534 // --------------------------------------------------------------------------- |
|
535 // RWsfSession::ConnectWlanBearer |
|
536 // --------------------------------------------------------------------------- |
|
537 // |
|
538 EXPORT_C void RWsfSession::ConnectWlanBearer( TPckgBuf<TBool>& aPckg, |
|
539 TUint32 aIapId, |
|
540 TBool aConnectOnly, |
|
541 TWsfIapPersistence aPersistence, |
|
542 TRequestStatus& aStatus ) |
|
543 { |
|
544 LOG_ENTERFN( "RWsfSession::ConnectWlanBearer" ); |
|
545 LOG_WRITEF( "IAP id = %d", aIapId ); |
|
546 |
|
547 // mark the beginning of the connection process |
|
548 iEventHandler->UnBlockNextConnectedEvent(); |
|
549 iEventHandler->SetConnecting( ETrue ); |
|
550 |
|
551 SendReceive( ESnifferCmdConnect, |
|
552 TIpcArgs( &aPckg, aIapId, aConnectOnly, aPersistence ), |
|
553 aStatus ); |
|
554 } |
|
555 |
|
556 |
|
557 // --------------------------------------------------------------------------- |
|
558 // RWsfSession::SetConnectWlanBearerResult |
|
559 // --------------------------------------------------------------------------- |
|
560 // |
|
561 EXPORT_C void RWsfSession::SetConnectWlanBearerResult( TInt aResult ) |
|
562 { |
|
563 LOG_ENTERFN( "RWsfSession::SetConnectWlanBearerResult" ); |
|
564 LOG_WRITEF( "Result = %d", aResult ); |
|
565 |
|
566 if ( aResult != KErrNone ) |
|
567 { |
|
568 // on any error the flag should be cleared |
|
569 iEventHandler->SetConnecting( EFalse ); |
|
570 } |
|
571 } |
|
572 |
|
573 |
|
574 // --------------------------------------------------------------------------- |
|
575 // RWsfSession::StopConnectingWait |
|
576 // --------------------------------------------------------------------------- |
|
577 // |
|
578 void RWsfSession::StopConnectingWait() |
|
579 { |
|
580 LOG_ENTERFN( "RWsfSession::StopConnectingWait" ); |
|
581 if ( iConnWaiter->IsStarted() ) |
|
582 { |
|
583 iConnWaiter->AsyncStop(); |
|
584 } |
|
585 } |
|
586 |
|
587 |
|
588 // --------------------------------------------------------------------------- |
|
589 // RWsfSession::DisconnectWlanBearerL |
|
590 // --------------------------------------------------------------------------- |
|
591 // |
|
592 EXPORT_C TBool RWsfSession::DisconnectWlanBearerL() |
|
593 { |
|
594 LOG_ENTERFN("RWsfSession::DisconnectWlanBearerL"); |
|
595 TBool res = 0; |
|
596 TPckgBuf<TInt> pckg; |
|
597 |
|
598 CWsfActiveWaiter *waiter = CWsfActiveWaiter::NewL(); |
|
599 CleanupStack::PushL( waiter ); |
|
600 |
|
601 SendReceive( ESnifferCmdDisconnect, TIpcArgs( &pckg ), waiter->iStatus ); |
|
602 waiter->WaitForRequest(); |
|
603 LOG_WRITEF( "message[%d] call returned %d", |
|
604 ESnifferCmdDisconnect, |
|
605 waiter->iStatus.Int() ); |
|
606 User::LeaveIfError( waiter->iStatus.Int() ); |
|
607 |
|
608 CleanupStack::PopAndDestroy( waiter ); |
|
609 |
|
610 res = pckg(); |
|
611 return res; |
|
612 } |
|
613 |
|
614 |
|
615 // --------------------------------------------------------------------------- |
|
616 // RWsfSession::DisconnectWlanBearer |
|
617 // --------------------------------------------------------------------------- |
|
618 // |
|
619 EXPORT_C void RWsfSession::DisconnectWlanBearer( TPckgBuf<TBool>& aPckg, TRequestStatus& aStatus ) |
|
620 { |
|
621 LOG_ENTERFN("RWsfSession::DisconnectWlanBearer"); |
|
622 SendReceive( ESnifferCmdDisconnect, TIpcArgs( &aPckg ), aStatus ); |
|
623 } |
|
624 |
|
625 |
|
626 // --------------------------------------------------------------------------- |
|
627 // RWsfSession::Close |
|
628 // --------------------------------------------------------------------------- |
|
629 // |
|
630 EXPORT_C void RWsfSession::Close() |
|
631 { |
|
632 LOG_ENTERFN("RWsfSession::Close"); |
|
633 delete iEventHandler; iEventHandler = NULL; |
|
634 delete iConnWaiter; iConnWaiter = NULL; |
|
635 |
|
636 LOG_WRITE( "close session" ); |
|
637 RSessionBase::Close(); |
|
638 } |
|
639 |
|
640 |
|
641 // --------------------------------------------------------------------------- |
|
642 // RWsfSession::DoCancelNotifyEvent |
|
643 // --------------------------------------------------------------------------- |
|
644 // |
|
645 void RWsfSession::DoCancelNotifyEvent() |
|
646 { |
|
647 LOG_ENTERFN("RWsfSession::DoCancelNotifyEvent"); |
|
648 // used only by CWsfEventHandler |
|
649 TInt err = Send( ESnifferCmdCancelNotifyEvents ); |
|
650 LOG_WRITEF( "message[%d] call returned %d", |
|
651 ESnifferCmdCancelNotifyEvents, err ); |
|
652 } |
|
653 |
|
654 |
|
655 // --------------------------------------------------------------------------- |
|
656 // RWsfSession::CancelAll |
|
657 // --------------------------------------------------------------------------- |
|
658 // |
|
659 void RWsfSession::CancelAll() |
|
660 { |
|
661 LOG_ENTERFN("RWsfSession::CancelAll"); |
|
662 TInt err = Send( ESnifferCmdCancelAll ); |
|
663 |
|
664 LOG_WRITEF( "message[%d] call returned %d", ESnifferCmdCancelAll, err ); |
|
665 } |
|
666 |
|
667 |
|
668 // --------------------------------------------------------------------------- |
|
669 // RWsfSession::IsConnectedL |
|
670 // --------------------------------------------------------------------------- |
|
671 // |
|
672 EXPORT_C TBool RWsfSession::IsConnectedL() |
|
673 { |
|
674 LOG_ENTERFN("RWsfSession::IsConnectedL"); |
|
675 TPckgBuf<TBool> pckg; |
|
676 |
|
677 CWsfActiveWaiter *waiter = CWsfActiveWaiter::NewL(); |
|
678 CleanupStack::PushL( waiter ); |
|
679 |
|
680 SendReceive( ESnifferCmdIsConnected, TIpcArgs( &pckg ), waiter->iStatus ); |
|
681 waiter->WaitForRequest(); |
|
682 LOG_WRITEF( "message[%d] call returned %d", |
|
683 ESnifferCmdIsConnected, |
|
684 waiter->iStatus.Int() ); |
|
685 User::LeaveIfError( waiter->iStatus.Int() ); |
|
686 CleanupStack::PopAndDestroy( waiter ); |
|
687 |
|
688 return pckg(); |
|
689 } |
|
690 |
|
691 |
|
692 // --------------------------------------------------------------------------- |
|
693 // RWsfSession::RecoverFromServerTermination |
|
694 // --------------------------------------------------------------------------- |
|
695 // |
|
696 TBool RWsfSession::RecoverFromServerTermination( |
|
697 MWsfStateChangeObserver& aObserver ) |
|
698 { |
|
699 RSessionBase::Close(); |
|
700 |
|
701 TBool ret( EFalse ); |
|
702 |
|
703 ret = ( Connect() == KErrNone ); |
|
704 if ( ret ) |
|
705 { |
|
706 TRAPD( err, NotifyEventL( aObserver ) ); |
|
707 ret = ( err == KErrNone ); |
|
708 } |
|
709 |
|
710 return ret; |
|
711 } |
|
712 |
|
713 |
|
714 // --------------------------------------------------------------------------- |
|
715 // RWsfSession::AbortConnectingL |
|
716 // --------------------------------------------------------------------------- |
|
717 // |
|
718 EXPORT_C void RWsfSession::AbortConnectingL() |
|
719 { |
|
720 LOG_ENTERFN("RWsfSession::AbortConnectingL"); |
|
721 |
|
722 if ( iEventHandler->Connecting() ) |
|
723 { |
|
724 iConnectingResult = KErrCancel; |
|
725 iEventHandler->BlockNextConnectedEvent(); |
|
726 |
|
727 TInt err = Send( ESnifferCmdAbortConnecting ); |
|
728 LOG_WRITEF( "message[%d] call returned %d", |
|
729 ESnifferCmdAbortConnecting, err ); |
|
730 |
|
731 User::LeaveIfError( err ); |
|
732 StopConnectingWait(); |
|
733 } |
|
734 |
|
735 } |
|
736 |
|
737 |
|
738 // --------------------------------------------------------------------------- |
|
739 // RWsfSession::AbortScanningL |
|
740 // --------------------------------------------------------------------------- |
|
741 // |
|
742 EXPORT_C void RWsfSession::AbortScanningL() |
|
743 { |
|
744 LOG_ENTERFN("RWsfSession::AbortScanningL"); |
|
745 |
|
746 TInt err = Send( ESnifferCmdAbortScanning ); |
|
747 LOG_WRITEF( "message[%d] call returned %d", |
|
748 ESnifferCmdAbortScanning, err ); |
|
749 |
|
750 User::LeaveIfError( err ); |
|
751 } |
|
752 |
|
753 |
|
754 // --------------------------------------------------------------------------- |
|
755 // RWsfSession::SetIapPersistenceL |
|
756 // --------------------------------------------------------------------------- |
|
757 // |
|
758 EXPORT_C TBool RWsfSession::SetIapPersistenceL( |
|
759 TWsfIapPersistence aPersistence ) |
|
760 { |
|
761 LOG_ENTERFN("RWsfSession::SetIapPersistenceL"); |
|
762 TPckgBuf<TBool> ret( EFalse ); |
|
763 |
|
764 CWsfActiveWaiter *waiter = CWsfActiveWaiter::NewL(); |
|
765 CleanupStack::PushL( waiter ); |
|
766 |
|
767 SendReceive( ESnifferCmdSetIapPersistence, TIpcArgs( &ret, aPersistence ), |
|
768 waiter->iStatus ); |
|
769 waiter->WaitForRequest(); |
|
770 LOG_WRITEF( "message[%d] call returned %d", |
|
771 ESnifferCmdSetIapPersistence, |
|
772 waiter->iStatus.Int() ); |
|
773 User::LeaveIfError( waiter->iStatus.Int() ); |
|
774 CleanupStack::PopAndDestroy( waiter ); |
|
775 |
|
776 return ret(); |
|
777 } |
|
778 |
|
779 |
|
780 // --------------------------------------------------------------------------- |
|
781 // RWsfSession::ControlDisconnectTimerL |
|
782 // --------------------------------------------------------------------------- |
|
783 // |
|
784 EXPORT_C TBool RWsfSession::ControlDisconnectTimerL( TUint aAdcCommand ) |
|
785 { |
|
786 LOG_ENTERFN("RWsfSession::ControlDisconnectTimerL"); |
|
787 |
|
788 TPckgBuf<TBool> ret( EFalse ); |
|
789 |
|
790 CWsfActiveWaiter *waiter = CWsfActiveWaiter::NewL(); |
|
791 CleanupStack::PushL( waiter ); |
|
792 |
|
793 SendReceive( ESnifferCmdControlDisconnectTimer, |
|
794 TIpcArgs( &ret, aAdcCommand ), |
|
795 waiter->iStatus ); |
|
796 |
|
797 waiter->WaitForRequest(); |
|
798 LOG_WRITEF( "message[%d] call returned %d", |
|
799 ESnifferCmdControlDisconnectTimer, |
|
800 waiter->iStatus.Int() ); |
|
801 User::LeaveIfError( waiter->iStatus.Int() ); |
|
802 CleanupStack::PopAndDestroy( waiter ); |
|
803 |
|
804 return ret(); |
|
805 } |
|
806 |
|
807 |