|
1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // Name : CSipCSSession.cpp |
|
15 // Part of : SIPServerCore |
|
16 // Version : SIP/6.0 |
|
17 // |
|
18 |
|
19 |
|
20 |
|
21 #include "CSipServerCore.h" |
|
22 #include "CSipCSServer.h" |
|
23 #include "CSipCSSession.h" |
|
24 #include "CSipCSSessionReceiver.h" |
|
25 #include "CSipCSServerITC.h" |
|
26 #include "CSipCSSubSession.h" |
|
27 #include "CTransactionUser.h" |
|
28 #include "CSipDialogMgr.h" |
|
29 #include "CSIPRegistrationMgr.h" |
|
30 #include "sipheaderbase.h" |
|
31 #include "MSigComp.h" |
|
32 #include "SipRequestHandlerBase.h" |
|
33 #include "SipAssert.h" |
|
34 #include "sipsec.h" |
|
35 #include "MSipRefreshMgr.h" |
|
36 |
|
37 |
|
38 // ----------------------------------------------------------------------------- |
|
39 // CSipCSSession::NewL |
|
40 // ----------------------------------------------------------------------------- |
|
41 // |
|
42 CSipCSSession* CSipCSSession::NewL (CSipServerCore& aServerCore) |
|
43 { |
|
44 CSipCSSession* self = CSipCSSession::NewLC(aServerCore); |
|
45 CleanupStack::Pop(self); |
|
46 return self; |
|
47 } |
|
48 |
|
49 // ----------------------------------------------------------------------------- |
|
50 // CSipCSSession::NewLC |
|
51 // ----------------------------------------------------------------------------- |
|
52 // |
|
53 CSipCSSession* CSipCSSession::NewLC (CSipServerCore& aServerCore) |
|
54 { |
|
55 CSipCSSession* self = new(ELeave)CSipCSSession(aServerCore); |
|
56 CleanupStack::PushL(self); |
|
57 self->ConstructL(); |
|
58 return self; |
|
59 } |
|
60 |
|
61 // ----------------------------------------------------------------------------- |
|
62 // CSipCSSession::CSipCSSession |
|
63 // ----------------------------------------------------------------------------- |
|
64 // |
|
65 CSipCSSession::CSipCSSession (CSipServerCore& aServerCore) |
|
66 : iServerCore (aServerCore), |
|
67 iByPassSIPSec(EFalse) |
|
68 { |
|
69 iServerCore.IncrementSessions(); |
|
70 } |
|
71 |
|
72 // ----------------------------------------------------------------------------- |
|
73 // CSipCSSession::ConstructL |
|
74 // ----------------------------------------------------------------------------- |
|
75 // |
|
76 void CSipCSSession::ConstructL () |
|
77 { |
|
78 iReceiver = CSipCSSessionReceiver::NewL(iServerCore.ITC(),*this); |
|
79 // second-phase construct base class |
|
80 iSubSessions = iServerCore.ObjectConIx().CreateL(); |
|
81 iSubSessionIndex = CObjectIx::NewL(); |
|
82 } |
|
83 |
|
84 // ----------------------------------------------------------------------------- |
|
85 // CSipCSSession::~CSipCSSession |
|
86 // ----------------------------------------------------------------------------- |
|
87 // |
|
88 CSipCSSession::~CSipCSSession() |
|
89 { |
|
90 if (iReceiver) |
|
91 { |
|
92 iServerCore.TU().ClearTransactionOwner(iReceiver); |
|
93 } |
|
94 iServerCore.RequestHandler().Deregister(iClientUid); |
|
95 delete iSubSessionIndex; |
|
96 iServerCore.ObjectConIx().Remove(iSubSessions); |
|
97 iSubSessions = 0; |
|
98 delete iReceiver; |
|
99 iServerCore.DecrementSessions(); |
|
100 } |
|
101 |
|
102 // ----------------------------------------------------------------------------- |
|
103 // CSipCSSession::ITC |
|
104 // ----------------------------------------------------------------------------- |
|
105 // |
|
106 CSipCSServerITC& CSipCSSession::ITC () |
|
107 { |
|
108 return iServerCore.ITC(); |
|
109 } |
|
110 |
|
111 // ----------------------------------------------------------------------------- |
|
112 // CSipCSSession::ServerCore |
|
113 // ----------------------------------------------------------------------------- |
|
114 // |
|
115 CSipServerCore& CSipCSSession::ServerCore () |
|
116 { |
|
117 return iServerCore; |
|
118 } |
|
119 |
|
120 // ----------------------------------------------------------------------------- |
|
121 // CSipCSSession::FindOwner |
|
122 // From MSipCSSession |
|
123 // ----------------------------------------------------------------------------- |
|
124 // |
|
125 MTransactionOwner& CSipCSSession::FindOwner(TUint32 aIapId) |
|
126 { |
|
127 MTransactionOwner* transactionOwner = iReceiver; |
|
128 CSipCSSubSession* subSession = 0; |
|
129 for (TInt i=0; i < iSubSessions->Count(); i++) |
|
130 { |
|
131 subSession = static_cast<CSipCSSubSession*>((*iSubSessions)[i]); |
|
132 if (subSession->IapId() == aIapId) |
|
133 { |
|
134 transactionOwner = subSession->TransactionOwner(); |
|
135 } |
|
136 } |
|
137 return *transactionOwner; |
|
138 } |
|
139 |
|
140 // ----------------------------------------------------------------------------- |
|
141 // CSipCSSession::SIPSecUser |
|
142 // From MSipCSSession |
|
143 // ----------------------------------------------------------------------------- |
|
144 // |
|
145 const MSIPSecUser* CSipCSSession::SIPSecUser( |
|
146 const TRegistrationId& aRegistrationId) |
|
147 { |
|
148 return ServerCore().RegistrationMgr().SIPSecUser(aRegistrationId); |
|
149 } |
|
150 |
|
151 // ----------------------------------------------------------------------------- |
|
152 // CSipCSSession::ByPassSIPSec() |
|
153 // From MSipCSSession |
|
154 // ----------------------------------------------------------------------------- |
|
155 // |
|
156 TBool CSipCSSession::ByPassSIPSec() const |
|
157 { |
|
158 return iByPassSIPSec; |
|
159 } |
|
160 |
|
161 // ----------------------------------------------------------------------------- |
|
162 // CSipCSSession::ServiceL |
|
163 // From CSession |
|
164 // ----------------------------------------------------------------------------- |
|
165 // |
|
166 void CSipCSSession::ServiceL (const RMessage2& aMessage) |
|
167 { |
|
168 DoServiceL(aMessage.Function(),aMessage); |
|
169 } |
|
170 |
|
171 // ----------------------------------------------------------------------------- |
|
172 // CSipCSSession::Uid |
|
173 // ----------------------------------------------------------------------------- |
|
174 // |
|
175 TUid CSipCSSession::Uid () |
|
176 { |
|
177 return iClientUid; |
|
178 } |
|
179 |
|
180 // ----------------------------------------------------------------------------- |
|
181 // CSipCSSession::ConnectionStateChangedL |
|
182 // From MConnectionStateObserver: |
|
183 // ----------------------------------------------------------------------------- |
|
184 // |
|
185 void CSipCSSession::ConnectionStateChangedL (TUint32 aIapId, |
|
186 CSIPConnection::TState aState) |
|
187 { |
|
188 CSipCSSubSession* subSession = 0; |
|
189 for (TInt i=0; i < iSubSessions->Count(); i++) |
|
190 { |
|
191 subSession = static_cast<CSipCSSubSession*>((*iSubSessions)[i]); |
|
192 if (subSession->IapId() == aIapId) |
|
193 { |
|
194 subSession->SetStateL(aState); |
|
195 } |
|
196 } |
|
197 } |
|
198 |
|
199 // ----------------------------------------------------------------------------- |
|
200 // CSipCSSession::DoServiceL |
|
201 // ----------------------------------------------------------------------------- |
|
202 // |
|
203 void CSipCSSession::DoServiceL (TInt aFunction, const RMessage2& aMessage) |
|
204 { |
|
205 switch (aFunction) |
|
206 { |
|
207 #ifndef PLAT_SEC_TEST |
|
208 case ESipItcSetAppUid: |
|
209 SetClientUidL (aMessage); break; |
|
210 |
|
211 case ESipItcSupportedSecurityMechanisms: |
|
212 SupportedSecurityMechanismsL (aMessage); break; |
|
213 |
|
214 case ESipItcNegotiatedSecurityMechanism: |
|
215 NegotiatedSecurityMechanismL (aMessage); break; |
|
216 |
|
217 case ESipItcSetHttpDigestObserver: |
|
218 SetHttpDigestObserverL(aMessage); break; |
|
219 |
|
220 case ESipItcSetCredentials: |
|
221 SetCredentialsL(aMessage); break; |
|
222 |
|
223 case ESipItcRemoveCredentials: |
|
224 RemoveCredentialsL(aMessage); break; |
|
225 |
|
226 case ESipItcIgnoreChallenge: |
|
227 IgnoreChallengeL(aMessage); break; |
|
228 |
|
229 case ESipItcSetSecurityHandling: |
|
230 SetSecurityHandlingL(aMessage); break; |
|
231 |
|
232 case ESipItcIsSigCompSupported: |
|
233 SigCompSupportedL (); break; |
|
234 |
|
235 case ESipItcGetTransactionState: |
|
236 GetTransactionStateL (aMessage); break; |
|
237 |
|
238 case ESipItcGetDialogState: |
|
239 GetDialogStateL (aMessage); break; |
|
240 |
|
241 case ESipItcGetCompartmentCount: |
|
242 GetCompartmentCountL (aMessage); break; |
|
243 |
|
244 case ESipItcOpenSubSession: |
|
245 { |
|
246 TUint32 iapId = ITC().ReadSipIdsL(aMessage).iIapId; |
|
247 OpenSubSessionL (iapId,aMessage); |
|
248 } |
|
249 break; |
|
250 |
|
251 case ESipItcCloseSubSession: |
|
252 { |
|
253 TInt handle = 0; |
|
254 ITC().ReadL(aMessage,handle,ESipItcArgSubSessionHandle); |
|
255 CloseSubSession (handle); |
|
256 } |
|
257 break; |
|
258 |
|
259 case ESipItcClientReadyToReceive: // Asynchronous. Do not complete yet. |
|
260 ClientReadyToReceiveL (aMessage); return; |
|
261 |
|
262 case ESipItcClientReceiveSipMessage: |
|
263 ReceiveSipMessageL (aMessage); break; |
|
264 |
|
265 case ESipItcClientCancelReceive: |
|
266 CancelClientReceiveL (); break; |
|
267 |
|
268 default: |
|
269 { |
|
270 TInt handle = 0; |
|
271 ITC().ReadL(aMessage,handle,ESipItcArgSubSessionHandle); |
|
272 CallSubSessionL (handle, aMessage); |
|
273 } |
|
274 return; |
|
275 #endif |
|
276 } |
|
277 ITC().Complete (aMessage, KErrNone); |
|
278 } |
|
279 |
|
280 // ----------------------------------------------------------------------------- |
|
281 // CSipCSSession::SetClientUidL |
|
282 // ----------------------------------------------------------------------------- |
|
283 // |
|
284 void CSipCSSession::SetClientUidL (const RMessage2& aMessage) |
|
285 { |
|
286 iClientUid.iUid = ITC().ReadAppUidL (aMessage).iUid; |
|
287 ServerCore().RequestHandler().RegisterL(iClientUid); |
|
288 } |
|
289 |
|
290 // ----------------------------------------------------------------------------- |
|
291 // CSipCSSession::SupportedSecurityMechanismsL |
|
292 // ----------------------------------------------------------------------------- |
|
293 // |
|
294 void CSipCSSession::SupportedSecurityMechanismsL (const RMessage2& aMessage) |
|
295 { |
|
296 CDesC8Array* mechanisms = |
|
297 ServerCore().SIPSec().SupportedSecurityMechanismsL(); |
|
298 __SIP_ASSERT_LEAVE (mechanisms!=0,KErrArgument); |
|
299 CleanupStack::PushL (mechanisms); |
|
300 ITC().WriteL(aMessage,*mechanisms); |
|
301 CleanupStack::PopAndDestroy(mechanisms); |
|
302 } |
|
303 |
|
304 // ----------------------------------------------------------------------------- |
|
305 // CSipCSSession::NegotiatedSecurityMechanismL |
|
306 // ----------------------------------------------------------------------------- |
|
307 // |
|
308 void CSipCSSession::NegotiatedSecurityMechanismL (const RMessage2& aMessage) |
|
309 { |
|
310 HBufC8* nextHop = ITC().ReadLC(aMessage,ESipItcArgNextHop); |
|
311 HBufC8* mechanism = |
|
312 ServerCore().SIPSec().NegotiatedSecurityMechanismL(*nextHop); |
|
313 CleanupStack::PopAndDestroy(nextHop); |
|
314 if (mechanism) |
|
315 { |
|
316 CleanupStack::PushL(mechanism); |
|
317 ITC().WriteL(aMessage,*mechanism,ESipItcArgAuthenticationMechanism); |
|
318 CleanupStack::PopAndDestroy(mechanism); |
|
319 } |
|
320 else |
|
321 { |
|
322 ITC().WriteL(aMessage,KNullDesC8,ESipItcArgAuthenticationMechanism); |
|
323 } |
|
324 } |
|
325 |
|
326 // ----------------------------------------------------------------------------- |
|
327 // CSipCSSession::SetHttpDigestObserverL |
|
328 // ----------------------------------------------------------------------------- |
|
329 // |
|
330 void CSipCSSession::SetHttpDigestObserverL (const RMessage2& aMessage) |
|
331 { |
|
332 TInt observerType(0); |
|
333 ITC().ReadL(aMessage,observerType,ESipItcArgHttpDigestObserverType); |
|
334 iReceiver->SetHttpDigestObserver( |
|
335 static_cast<TSipHttpDigestObserverType>(observerType)); |
|
336 } |
|
337 |
|
338 // ----------------------------------------------------------------------------- |
|
339 // CSipCSSession::SetCredentialsL |
|
340 // ----------------------------------------------------------------------------- |
|
341 // |
|
342 void CSipCSSession::SetCredentialsL (const RMessage2& aMessage) |
|
343 { |
|
344 HBufC8* realm = ITC().ReadLC(aMessage,ESipItcArgRealm); |
|
345 |
|
346 CDesC8Array* credentials = ITC().ReadCredentialsLC(aMessage); |
|
347 TInt credentialsCount = credentials->MdcaCount(); |
|
348 __ASSERT_ALWAYS(credentialsCount > 1, User::Leave(KErrArgument)); |
|
349 TPtrC8 outboundproxy(KNullDesC8); |
|
350 if (credentialsCount == EOutboundProxyIndex+1) |
|
351 { |
|
352 outboundproxy.Set(credentials->MdcaPoint(EOutboundProxyIndex)); |
|
353 } |
|
354 |
|
355 TSIPIds ids = ITC().ReadSipIdsL(aMessage); |
|
356 const MSIPSecUser* sipSecUser = |
|
357 FindSIPSecUser(ids.iRefreshId,ids.iRequestId); |
|
358 |
|
359 if (sipSecUser) |
|
360 { |
|
361 ServerCore().SIPSec().SetCredentialsL( |
|
362 *sipSecUser, |
|
363 *realm, |
|
364 outboundproxy, |
|
365 credentials->MdcaPoint(EUserIndex), |
|
366 credentials->MdcaPoint(EPasswdIndex)); |
|
367 } |
|
368 else |
|
369 { |
|
370 ServerCore().SIPSec().SetCredentialsL( |
|
371 KEmptyTransactionId, |
|
372 *realm, |
|
373 outboundproxy, |
|
374 credentials->MdcaPoint(EUserIndex), |
|
375 credentials->MdcaPoint(EPasswdIndex)); |
|
376 } |
|
377 |
|
378 CleanupStack::PopAndDestroy(credentials); |
|
379 CleanupStack::PopAndDestroy(realm); |
|
380 } |
|
381 |
|
382 // ----------------------------------------------------------------------------- |
|
383 // CSipCSSession::RemoveCredentialsL |
|
384 // ----------------------------------------------------------------------------- |
|
385 // |
|
386 void CSipCSSession::RemoveCredentialsL (const RMessage2& aMessage) |
|
387 { |
|
388 HBufC8* realm = ITC().ReadLC(aMessage,ESipItcArgRealm); |
|
389 User::LeaveIfError(ServerCore().SIPSec().RemoveCredentials(*realm)); |
|
390 CleanupStack::PopAndDestroy(realm); |
|
391 } |
|
392 |
|
393 // ----------------------------------------------------------------------------- |
|
394 // CSipCSSession::IgnoreChallengeL |
|
395 // ----------------------------------------------------------------------------- |
|
396 // |
|
397 void CSipCSSession::IgnoreChallengeL (const RMessage2& aMessage) |
|
398 { |
|
399 HBufC8* realm = ITC().ReadLC(aMessage,ESipItcArgRealm); |
|
400 TSIPIds ids = ITC().ReadSipIdsL(aMessage); |
|
401 TTransactionId taId = ids.iRequestId; |
|
402 const MSIPSecUser* sipSecUser = FindSIPSecUser(ids.iRefreshId,taId); |
|
403 User::LeaveIfError( |
|
404 ServerCore().SIPSec().IgnoreChallenge(taId,*realm,sipSecUser)); |
|
405 CleanupStack::PopAndDestroy(realm); |
|
406 } |
|
407 |
|
408 // ----------------------------------------------------------------------------- |
|
409 // CSipCSSession::SetSecurityHandlingL |
|
410 // ----------------------------------------------------------------------------- |
|
411 // |
|
412 void CSipCSSession::SetSecurityHandlingL(const RMessage2& aMessage) |
|
413 { |
|
414 TInt securityHandlingEnabled(0); |
|
415 ITC().ReadL(aMessage,securityHandlingEnabled,ESipItcArgSecurityHandling); |
|
416 iByPassSIPSec = !securityHandlingEnabled; |
|
417 } |
|
418 |
|
419 // ----------------------------------------------------------------------------- |
|
420 // CSipCSSession::SigCompSupportedL |
|
421 // ----------------------------------------------------------------------------- |
|
422 // |
|
423 void CSipCSSession::SigCompSupportedL () |
|
424 { |
|
425 if (!ServerCore().SigComp().IsSupported()) |
|
426 { |
|
427 User::Leave(KErrNotSupported); |
|
428 } |
|
429 } |
|
430 |
|
431 // ----------------------------------------------------------------------------- |
|
432 // CSipCSSession::GetTransactionStateL |
|
433 // ----------------------------------------------------------------------------- |
|
434 // |
|
435 void CSipCSSession::GetTransactionStateL (const RMessage2& aMessage) |
|
436 { |
|
437 TSIPIds ids = ITC().ReadSipIdsL(aMessage); |
|
438 CSIPInternalStates::TState state; |
|
439 ServerCore().TU().GetStateL(ids.iRequestId,state); |
|
440 ITC().WriteL(aMessage,state,ESipItcArgInternalState); |
|
441 } |
|
442 |
|
443 // ----------------------------------------------------------------------------- |
|
444 // CSipCSSession::GetDialogStateL |
|
445 // ----------------------------------------------------------------------------- |
|
446 // |
|
447 void CSipCSSession::GetDialogStateL (const RMessage2& aMessage) |
|
448 { |
|
449 TSIPIds ids = ITC().ReadSipIdsL(aMessage); |
|
450 CSIPInternalStates::TState state; |
|
451 ServerCore().DialogMgr().GetStateL(ids.iDialogId,state); |
|
452 ITC().WriteL(aMessage,state,ESipItcArgInternalState); |
|
453 } |
|
454 |
|
455 // ----------------------------------------------------------------------------- |
|
456 // CSipCSSession::GetCompartmentCountL |
|
457 // ----------------------------------------------------------------------------- |
|
458 // |
|
459 void CSipCSSession::GetCompartmentCountL (const RMessage2& aMessage) |
|
460 { |
|
461 TInt count = ServerCore().SigComp().CompartmentCount(); |
|
462 ITC().WriteL(aMessage,count,ESipItcArgInternalState); |
|
463 } |
|
464 |
|
465 // ----------------------------------------------------------------------------- |
|
466 // CSipCSSession::OpenSubSessionL |
|
467 // ----------------------------------------------------------------------------- |
|
468 // |
|
469 void CSipCSSession::OpenSubSessionL (TUint32 aIapId, const RMessage2& aMessage) |
|
470 { |
|
471 TInt err; |
|
472 if (Exists(aIapId)) |
|
473 { |
|
474 User::Leave(KErrAlreadyExists); |
|
475 } |
|
476 CSipCSSubSession* subSession = |
|
477 CSipCSSubSession::NewLC(*this,*iReceiver,aIapId); |
|
478 iReceiver->MovePendingErrorsL(aIapId,subSession->Receiver()); |
|
479 iSubSessions->AddL(subSession); |
|
480 TInt handle = iSubSessionIndex->AddL(subSession); |
|
481 CleanupStack::Pop(); // subSession |
|
482 TRAP (err, subSession->OpenIapL(aMessage)); |
|
483 if (err) |
|
484 { |
|
485 iSubSessionIndex->Remove(handle); |
|
486 User::Leave(err); |
|
487 } |
|
488 TRAP (err, ITC().WriteL(aMessage,handle,ESipItcArgSubSessionHandle)); |
|
489 if (err) |
|
490 { |
|
491 iSubSessionIndex->Remove(handle); |
|
492 User::Leave(err); |
|
493 } |
|
494 } |
|
495 |
|
496 // ----------------------------------------------------------------------------- |
|
497 // CSipCSSession::CloseSubSession |
|
498 // ----------------------------------------------------------------------------- |
|
499 // |
|
500 void CSipCSSession::CloseSubSession (TInt aSubSessionHandle) |
|
501 { |
|
502 iSubSessionIndex->Remove(aSubSessionHandle); |
|
503 } |
|
504 |
|
505 // ----------------------------------------------------------------------------- |
|
506 // CSipCSSession::ClientReadyToReceiveL |
|
507 // ----------------------------------------------------------------------------- |
|
508 // |
|
509 void CSipCSSession::ClientReadyToReceiveL (const RMessage2& aMessage) |
|
510 { |
|
511 iReceiver->ClientReadyToReceiveL(aMessage); |
|
512 } |
|
513 |
|
514 // ----------------------------------------------------------------------------- |
|
515 // CSipCSSession::ReceiveSipMessageL |
|
516 // ----------------------------------------------------------------------------- |
|
517 // |
|
518 void CSipCSSession::ReceiveSipMessageL (const RMessage2& aMessage) |
|
519 { |
|
520 iReceiver->WriteSipMessageToClientL(aMessage); |
|
521 } |
|
522 |
|
523 // ----------------------------------------------------------------------------- |
|
524 // CSipCSSession::CancelClientReceiveL |
|
525 // ----------------------------------------------------------------------------- |
|
526 // |
|
527 void CSipCSSession::CancelClientReceiveL () |
|
528 { |
|
529 iReceiver->CancelClientReceiveL(); |
|
530 } |
|
531 |
|
532 // ----------------------------------------------------------------------------- |
|
533 // CSipCSSession::CallSubSessionL |
|
534 // ----------------------------------------------------------------------------- |
|
535 // |
|
536 void CSipCSSession::CallSubSessionL (TInt aSubSessionHandle, |
|
537 const RMessage2& aMessage) |
|
538 { |
|
539 CSipCSSubSession* subSession = |
|
540 static_cast<CSipCSSubSession*>( |
|
541 iSubSessionIndex->AtL(aSubSessionHandle)); |
|
542 TSIPIds ids = ITC().ReadSipIdsL(aMessage); |
|
543 subSession->ServiceL(ids,aMessage.Function(),aMessage); |
|
544 } |
|
545 |
|
546 // ----------------------------------------------------------------------------- |
|
547 // CSipCSSession::Exists |
|
548 // ----------------------------------------------------------------------------- |
|
549 // |
|
550 TBool CSipCSSession::Exists (TUint32 aIapId) |
|
551 { |
|
552 for (TInt i=0; i < iSubSessions->Count(); i++) |
|
553 { |
|
554 CSipCSSubSession* subSession = |
|
555 static_cast<CSipCSSubSession*>((*iSubSessions)[i]); |
|
556 if (subSession->IapId() == aIapId) |
|
557 { |
|
558 return ETrue; |
|
559 } |
|
560 } |
|
561 return EFalse; |
|
562 } |
|
563 |
|
564 // ----------------------------------------------------------------------------- |
|
565 // CSipCSSession::FindSIPSecUser |
|
566 // ----------------------------------------------------------------------------- |
|
567 // |
|
568 const MSIPSecUser* CSipCSSession::FindSIPSecUser( |
|
569 TRefreshId aRefreshId, |
|
570 TTransactionId aTransactionId) |
|
571 { |
|
572 if (aRefreshId != KEmptyRefreshId) |
|
573 { |
|
574 return ServerCore().RefreshMgr().SIPSecUser(aRefreshId); |
|
575 } |
|
576 if (aTransactionId == KEmptyTransactionId) |
|
577 { |
|
578 return NULL; |
|
579 } |
|
580 |
|
581 const MSIPSecUser* user = |
|
582 ServerCore().RegistrationMgr().SIPSecUserForTransaction(aTransactionId); |
|
583 if (!user) |
|
584 { |
|
585 user = |
|
586 ServerCore().DialogMgr().SIPSecUserForTransaction(aTransactionId); |
|
587 } |
|
588 if (!user) |
|
589 { |
|
590 // If the transaction ID is not empty, |
|
591 // the user of SIP API implements MSIPHttpDigestChallengeObserver2 |
|
592 user = iReceiver; |
|
593 } |
|
594 return user; |
|
595 } |