|
1 // Copyright (c) 2006-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 : InviteUACStates.cpp |
|
15 // Part of : TransactionUser |
|
16 // Version : SIP/5.0 |
|
17 // |
|
18 |
|
19 |
|
20 |
|
21 #include "siperr.h" |
|
22 #include "siprequest.h" |
|
23 #include "sipresponse.h" |
|
24 #include "SipAssert.h" |
|
25 |
|
26 #include "InviteUAC.h" |
|
27 #include "InviteUACStates.h" |
|
28 |
|
29 |
|
30 // ----------------------------------------------------------------------------- |
|
31 // CInviteUAC_Start::CInviteUAC_Start |
|
32 // ----------------------------------------------------------------------------- |
|
33 // |
|
34 CInviteUAC_Start::CInviteUAC_Start() |
|
35 { |
|
36 } |
|
37 |
|
38 // ----------------------------------------------------------------------------- |
|
39 // CInviteUAC_Start::~CInviteUAC_Start |
|
40 // ----------------------------------------------------------------------------- |
|
41 // |
|
42 CInviteUAC_Start::~CInviteUAC_Start() |
|
43 { |
|
44 } |
|
45 |
|
46 // ----------------------------------------------------------------------------- |
|
47 // CInviteUAC_Start::SetNeighbourStates |
|
48 // ----------------------------------------------------------------------------- |
|
49 // |
|
50 void CInviteUAC_Start::SetNeighbourStates(CUserAgentState& aResolveAddress) |
|
51 { |
|
52 iResolveAddress = &aResolveAddress; |
|
53 } |
|
54 |
|
55 // ----------------------------------------------------------------------------- |
|
56 // CInviteUAC_Start::SendRequestL |
|
57 // ----------------------------------------------------------------------------- |
|
58 // |
|
59 void CInviteUAC_Start::SendRequestL(CUserAgent& aUserAgent, |
|
60 CSIPRequest* aReq, |
|
61 TRegistrationId aRegisterId, |
|
62 const CURIContainer& aRemoteTarget) const |
|
63 { |
|
64 __SIP_ASSERT_LEAVE(aReq, KErrArgument); |
|
65 |
|
66 CInviteUAC::Ptr(aUserAgent).HandleSendRequestL(aReq, |
|
67 aRegisterId, |
|
68 aRemoteTarget, |
|
69 *iResolveAddress); |
|
70 } |
|
71 |
|
72 // ----------------------------------------------------------------------------- |
|
73 // CInviteUAC_Start::SendAckL |
|
74 // Can't send ACK before a 2xx has been received |
|
75 // ----------------------------------------------------------------------------- |
|
76 // |
|
77 void CInviteUAC_Start::SendAckL(CUserAgent& /*aUserAgent*/, |
|
78 CSIPRequest* aAck, |
|
79 MTransactionOwner& /*aObserver*/, |
|
80 const TSIPTransportParams& /*aParams*/, |
|
81 TRegistrationId /*aRegisterId*/, |
|
82 const CURIContainer& /*aRemoteTarget*/, |
|
83 TBool /*aDeleteRequest*/, |
|
84 RStringF /*aBranch*/) const |
|
85 { |
|
86 __SIP_ASSERT_LEAVE(aAck, KErrArgument); |
|
87 |
|
88 User::Leave(KErrSIPInvalidTransactionState); |
|
89 } |
|
90 |
|
91 // ----------------------------------------------------------------------------- |
|
92 // CInviteUAC_ResolveAddress::CInviteUAC_ResolveAddress |
|
93 // ----------------------------------------------------------------------------- |
|
94 // |
|
95 CInviteUAC_ResolveAddress::CInviteUAC_ResolveAddress() |
|
96 { |
|
97 } |
|
98 |
|
99 // ----------------------------------------------------------------------------- |
|
100 // CInviteUAC_ResolveAddress::~CInviteUAC_ResolveAddress |
|
101 // ----------------------------------------------------------------------------- |
|
102 // |
|
103 CInviteUAC_ResolveAddress::~CInviteUAC_ResolveAddress() |
|
104 { |
|
105 } |
|
106 |
|
107 // ----------------------------------------------------------------------------- |
|
108 // CInviteUAC_ResolveAddress::SetNeighbourStates |
|
109 // ----------------------------------------------------------------------------- |
|
110 // |
|
111 void |
|
112 CInviteUAC_ResolveAddress::SetNeighbourStates(CUserAgentState& aWaitResponse) |
|
113 { |
|
114 iWaitResponse = &aWaitResponse; |
|
115 } |
|
116 |
|
117 // ----------------------------------------------------------------------------- |
|
118 // CInviteUAC_ResolveAddress::IsResolving |
|
119 // ----------------------------------------------------------------------------- |
|
120 // |
|
121 TBool CInviteUAC_ResolveAddress::IsResolving() const |
|
122 { |
|
123 return ETrue; |
|
124 } |
|
125 |
|
126 // ----------------------------------------------------------------------------- |
|
127 // CInviteUAC_ResolveAddress::AddressResolvedL |
|
128 // ----------------------------------------------------------------------------- |
|
129 // |
|
130 void CInviteUAC_ResolveAddress::AddressResolvedL(CUserAgent& aUserAgent) const |
|
131 { |
|
132 CInviteUAC::Ptr(aUserAgent).RemoteAddressResolvedL(*iWaitResponse); |
|
133 } |
|
134 |
|
135 // ----------------------------------------------------------------------------- |
|
136 // CInviteUAC_ResolveAddress::ResolvingFailed |
|
137 // ----------------------------------------------------------------------------- |
|
138 // |
|
139 void CInviteUAC_ResolveAddress::ResolvingFailed(CUserAgent& aUserAgent) const |
|
140 { |
|
141 CInviteUAC::Ptr(aUserAgent).HandleResolvingFailure(*this, *iWaitResponse); |
|
142 } |
|
143 |
|
144 // ----------------------------------------------------------------------------- |
|
145 // CInviteUAC_ResolveAddress::SendAckL |
|
146 // Can't send ACK before a 2xx has been received |
|
147 // ----------------------------------------------------------------------------- |
|
148 // |
|
149 void CInviteUAC_ResolveAddress::SendAckL(CUserAgent& /*aUserAgent*/, |
|
150 CSIPRequest* aAck, |
|
151 MTransactionOwner& /*aObserver*/, |
|
152 const TSIPTransportParams& /*aParams*/, |
|
153 TRegistrationId /*aRegisterId*/, |
|
154 const CURIContainer& /*aRemoteTarget*/, |
|
155 TBool /*aDeleteRequest*/, |
|
156 RStringF /*aBranch*/) const |
|
157 { |
|
158 __SIP_ASSERT_LEAVE(aAck, KErrArgument); |
|
159 |
|
160 User::Leave(KErrSIPInvalidTransactionState); |
|
161 } |
|
162 |
|
163 // ----------------------------------------------------------------------------- |
|
164 // CInviteUAC_WaitResponse::CInviteUAC_WaitResponse |
|
165 // ----------------------------------------------------------------------------- |
|
166 // |
|
167 CInviteUAC_WaitResponse::CInviteUAC_WaitResponse() |
|
168 { |
|
169 } |
|
170 |
|
171 // ----------------------------------------------------------------------------- |
|
172 // CInviteUAC_WaitResponse::~CInviteUAC_WaitResponse |
|
173 // ----------------------------------------------------------------------------- |
|
174 // |
|
175 CInviteUAC_WaitResponse::~CInviteUAC_WaitResponse() |
|
176 { |
|
177 } |
|
178 |
|
179 // ----------------------------------------------------------------------------- |
|
180 // CInviteUAC_WaitResponse::SetNeighbourStates |
|
181 // ----------------------------------------------------------------------------- |
|
182 // |
|
183 void CInviteUAC_WaitResponse::SetNeighbourStates( |
|
184 CUserAgentState& aWaitAckFromApp, |
|
185 CUserAgentState& aWaitTransactionToEnd, |
|
186 CUserAgentState& aResolveAddress, |
|
187 CUserAgentState& aWaitAuthentication) |
|
188 { |
|
189 iWaitAckFromApp = &aWaitAckFromApp; |
|
190 iWaitTransactionToEnd = &aWaitTransactionToEnd; |
|
191 iResolveAddress = &aResolveAddress; |
|
192 iWaitAuthentication = &aWaitAuthentication; |
|
193 } |
|
194 |
|
195 // ----------------------------------------------------------------------------- |
|
196 // CInviteUAC_WaitResponse::ReceiveL |
|
197 // ----------------------------------------------------------------------------- |
|
198 // |
|
199 void CInviteUAC_WaitResponse::ReceiveL(CUserAgent& aUserAgent, |
|
200 CSIPResponse* aResponse) const |
|
201 { |
|
202 __SIP_ASSERT_LEAVE(aResponse, KErrArgument); |
|
203 |
|
204 CInviteUAC& ua = CInviteUAC::Ptr(aUserAgent); |
|
205 |
|
206 //If a final response has been passed to TransactionOwner, UA should be in |
|
207 //CInviteUAC_WaitAckFromApp state |
|
208 __SIP_ASSERT_LEAVE(!ua.FinalRespPassed(), KErrSIPInvalidTransactionState); |
|
209 |
|
210 TBool wait(EFalse); |
|
211 TRAPD(err,wait = ua.PassResponseToSIPSecL(*aResponse)) |
|
212 |
|
213 if(err ) |
|
214 { |
|
215 if(aResponse->IsErrorResponse()) |
|
216 |
|
217 ua.SetSipSecError(err); |
|
218 else |
|
219 User::Leave(err); |
|
220 } |
|
221 |
|
222 if (wait) |
|
223 { |
|
224 //Wait for SIPSec to handle response |
|
225 ua.StoreResponse(aResponse); |
|
226 aUserAgent.ChangeState(*iWaitAuthentication); |
|
227 } |
|
228 else |
|
229 { |
|
230 if (aResponse->ResponseCode() >= 300) |
|
231 { |
|
232 ua.StartSIPSecTimerL(); |
|
233 ua.StoreResponse(aResponse); |
|
234 aUserAgent.ChangeState(*iWaitAuthentication); |
|
235 } |
|
236 else |
|
237 { |
|
238 ua.ReceiveResponseL(aResponse, |
|
239 *iResolveAddress, |
|
240 *this, |
|
241 *iWaitAckFromApp, |
|
242 *iWaitTransactionToEnd); |
|
243 } |
|
244 } |
|
245 } |
|
246 |
|
247 // ----------------------------------------------------------------------------- |
|
248 // CInviteUAC_WaitResponse::TransactionEndsL |
|
249 // ----------------------------------------------------------------------------- |
|
250 // |
|
251 void CInviteUAC_WaitResponse::TransactionEndsL(CUserAgent& aUserAgent, |
|
252 TInt aReason) const |
|
253 { |
|
254 CInviteUAC::Ptr(aUserAgent).TransactionEndsWithoutFinalResponseL(aReason, |
|
255 *iResolveAddress, |
|
256 *this); |
|
257 } |
|
258 |
|
259 // ----------------------------------------------------------------------------- |
|
260 // CInviteUAC_WaitResponse::SendAckL |
|
261 // Can't send ACK before a 2xx has been received |
|
262 // ----------------------------------------------------------------------------- |
|
263 // |
|
264 void CInviteUAC_WaitResponse::SendAckL(CUserAgent& /*aUserAgent*/, |
|
265 CSIPRequest* aAck, |
|
266 MTransactionOwner& /*aObserver*/, |
|
267 const TSIPTransportParams& /*aParams*/, |
|
268 TRegistrationId /*aRegisterId*/, |
|
269 const CURIContainer& /*aRemoteTarget*/, |
|
270 TBool /*aDeleteRequest*/, |
|
271 RStringF /*aBranch*/) const |
|
272 { |
|
273 __SIP_ASSERT_LEAVE(aAck, KErrArgument); |
|
274 |
|
275 User::Leave(KErrSIPInvalidTransactionState); |
|
276 } |
|
277 |
|
278 // ----------------------------------------------------------------------------- |
|
279 // CInviteUAC_WaitAckFromApp::CInviteUAC_WaitAckFromApp |
|
280 // ----------------------------------------------------------------------------- |
|
281 // |
|
282 CInviteUAC_WaitAckFromApp::CInviteUAC_WaitAckFromApp() |
|
283 { |
|
284 } |
|
285 |
|
286 // ----------------------------------------------------------------------------- |
|
287 // CInviteUAC_WaitAckFromApp::~CInviteUAC_WaitAckFromApp |
|
288 // ----------------------------------------------------------------------------- |
|
289 // |
|
290 CInviteUAC_WaitAckFromApp::~CInviteUAC_WaitAckFromApp() |
|
291 { |
|
292 } |
|
293 |
|
294 // ----------------------------------------------------------------------------- |
|
295 // CInviteUAC_WaitAckFromApp::SetNeighbourStates |
|
296 // ----------------------------------------------------------------------------- |
|
297 // |
|
298 void CInviteUAC_WaitAckFromApp::SetNeighbourStates( |
|
299 CUserAgentState& aResolveAckAddress) |
|
300 { |
|
301 iResolveAckAddress = &aResolveAckAddress; |
|
302 } |
|
303 |
|
304 // ----------------------------------------------------------------------------- |
|
305 // CInviteUAC_WaitAckFromApp::SendAckL |
|
306 // ACK's headers are not updated to CTransactionStore, as an ACK to a 2xx has a |
|
307 // different branch than the original INVITE, and further 2xx responses couldn't |
|
308 // be routed to this UAC anymore if the new branch is put to CTransactionStore. |
|
309 // ----------------------------------------------------------------------------- |
|
310 // |
|
311 void CInviteUAC_WaitAckFromApp::SendAckL(CUserAgent& aUserAgent, |
|
312 CSIPRequest* aAck, |
|
313 MTransactionOwner& aObserver, |
|
314 const TSIPTransportParams& aParams, |
|
315 TRegistrationId aRegisterId, |
|
316 const CURIContainer& aRemoteTarget, |
|
317 TBool aDeleteRequest, |
|
318 RStringF aBranch) const |
|
319 { |
|
320 __SIP_ASSERT_LEAVE(aAck, KErrArgument); |
|
321 |
|
322 CInviteUAC::Ptr(aUserAgent).SendFirstAckL(aAck, |
|
323 aObserver, |
|
324 aParams, |
|
325 aRegisterId, |
|
326 aRemoteTarget, |
|
327 aDeleteRequest, |
|
328 aBranch); |
|
329 aUserAgent.ChangeState(*iResolveAckAddress); |
|
330 } |
|
331 |
|
332 // ----------------------------------------------------------------------------- |
|
333 // CInviteUAC_WaitAckFromApp::ReceiveL |
|
334 // As incoming responses are routed using Via's branch parameter, the 2xx |
|
335 // responses will be received by the same UAC regardless of the To-tag value. |
|
336 // ----------------------------------------------------------------------------- |
|
337 // |
|
338 void CInviteUAC_WaitAckFromApp::ReceiveL(CUserAgent& aUserAgent, |
|
339 CSIPResponse* aResponse) const |
|
340 { |
|
341 __SIP_ASSERT_LEAVE(aResponse, KErrArgument); |
|
342 |
|
343 CInviteUAC::Ptr(aUserAgent).HandleAdditional2xxL(aResponse); |
|
344 } |
|
345 |
|
346 // ----------------------------------------------------------------------------- |
|
347 // CInviteUAC_WaitAckFromApp::TimerExpiredL |
|
348 // ----------------------------------------------------------------------------- |
|
349 // |
|
350 void CInviteUAC_WaitAckFromApp::TimerExpiredL(CUserAgent& aUserAgent, |
|
351 TTimerId aTimerId, |
|
352 TAny* aTimerParam) const |
|
353 { |
|
354 __SIP_ASSERT_LEAVE(aTimerParam, KErrArgument); |
|
355 |
|
356 HandleTimerExpirationL(aUserAgent, aTimerId, aTimerParam); |
|
357 } |
|
358 |
|
359 // ----------------------------------------------------------------------------- |
|
360 // CInviteUAC_ResolveAckAddress::CInviteUAC_ResolveAckAddress |
|
361 // ----------------------------------------------------------------------------- |
|
362 // |
|
363 CInviteUAC_ResolveAckAddress::CInviteUAC_ResolveAckAddress() |
|
364 { |
|
365 } |
|
366 |
|
367 // ----------------------------------------------------------------------------- |
|
368 // CInviteUAC_ResolveAckAddress::~CInviteUAC_ResolveAckAddress |
|
369 // ----------------------------------------------------------------------------- |
|
370 // |
|
371 CInviteUAC_ResolveAckAddress::~CInviteUAC_ResolveAckAddress() |
|
372 { |
|
373 } |
|
374 |
|
375 // ----------------------------------------------------------------------------- |
|
376 // CInviteUAC_ResolveAckAddress::SetNeighbourStates |
|
377 // ----------------------------------------------------------------------------- |
|
378 // |
|
379 void |
|
380 CInviteUAC_ResolveAckAddress::SetNeighbourStates(CUserAgentState& aSendingAck) |
|
381 { |
|
382 iSendingAck = &aSendingAck; |
|
383 } |
|
384 |
|
385 // ----------------------------------------------------------------------------- |
|
386 // CInviteUAC_ResolveAckAddress::IsResolving |
|
387 // ----------------------------------------------------------------------------- |
|
388 // |
|
389 TBool CInviteUAC_ResolveAckAddress::IsResolving() const |
|
390 { |
|
391 return ETrue; |
|
392 } |
|
393 |
|
394 // ----------------------------------------------------------------------------- |
|
395 // CInviteUAC_ResolveAckAddress::AddressResolvedL |
|
396 // Remote address for ACK resolved, send the ACK from send buffer |
|
397 // ----------------------------------------------------------------------------- |
|
398 // |
|
399 void |
|
400 CInviteUAC_ResolveAckAddress::AddressResolvedL(CUserAgent& aUserAgent) const |
|
401 { |
|
402 CInviteUAC::Ptr(aUserAgent).AckAddressResolvedL(); |
|
403 aUserAgent.ChangeState(*iSendingAck); |
|
404 } |
|
405 |
|
406 // ----------------------------------------------------------------------------- |
|
407 // CInviteUAC_ResolveAckAddress::ResolvingFailed |
|
408 // ----------------------------------------------------------------------------- |
|
409 // |
|
410 void CInviteUAC_ResolveAckAddress::ResolvingFailed(CUserAgent& aUserAgent) const |
|
411 { |
|
412 CInviteUAC::Ptr(aUserAgent).HandleResolvingFailure(*this, *iSendingAck); |
|
413 } |
|
414 |
|
415 // ----------------------------------------------------------------------------- |
|
416 // CInviteUAC_ResolveAckAddress::SendAckL |
|
417 // ----------------------------------------------------------------------------- |
|
418 // |
|
419 void CInviteUAC_ResolveAckAddress::SendAckL(CUserAgent& aUserAgent, |
|
420 CSIPRequest* aAck, |
|
421 MTransactionOwner& aObserver, |
|
422 const TSIPTransportParams& aParams, |
|
423 TRegistrationId aRegisterId, |
|
424 const CURIContainer& aRemoteTarget, |
|
425 TBool aDeleteRequest, |
|
426 RStringF /*aBranch*/) const |
|
427 { |
|
428 __SIP_ASSERT_LEAVE(aAck, KErrArgument); |
|
429 |
|
430 CInviteUAC::Ptr(aUserAgent).SendAdditionalAckL(aAck, |
|
431 aObserver, |
|
432 aParams, |
|
433 aRegisterId, |
|
434 aRemoteTarget, |
|
435 aDeleteRequest); |
|
436 } |
|
437 |
|
438 // ----------------------------------------------------------------------------- |
|
439 // CInviteUAC_ResolveAckAddress::ReceiveL |
|
440 // Incoming responses are routed by Via branch, so 2xx responses are received |
|
441 // by the same UAC regardless of the To-tag value. |
|
442 // ----------------------------------------------------------------------------- |
|
443 // |
|
444 void CInviteUAC_ResolveAckAddress::ReceiveL(CUserAgent& aUserAgent, |
|
445 CSIPResponse* aResponse) const |
|
446 { |
|
447 __SIP_ASSERT_LEAVE(aResponse, KErrArgument); |
|
448 |
|
449 CInviteUAC::Ptr(aUserAgent).HandleAdditional2xxL(aResponse); |
|
450 } |
|
451 |
|
452 // ----------------------------------------------------------------------------- |
|
453 // CInviteUAC_ResolveAckAddress::TimerExpiredL |
|
454 // ----------------------------------------------------------------------------- |
|
455 // |
|
456 void CInviteUAC_ResolveAckAddress::TimerExpiredL(CUserAgent& aUserAgent, |
|
457 TTimerId aTimerId, |
|
458 TAny* aTimerParam) const |
|
459 { |
|
460 __SIP_ASSERT_LEAVE(aTimerParam, KErrArgument); |
|
461 |
|
462 HandleTimerExpirationL(aUserAgent, aTimerId, aTimerParam); |
|
463 } |
|
464 |
|
465 // ----------------------------------------------------------------------------- |
|
466 // CInviteUAC_SendingAck::CInviteUAC_SendingAck |
|
467 // ----------------------------------------------------------------------------- |
|
468 // |
|
469 CInviteUAC_SendingAck::CInviteUAC_SendingAck() |
|
470 { |
|
471 } |
|
472 |
|
473 // ----------------------------------------------------------------------------- |
|
474 // CInviteUAC_SendingAck::~CInviteUAC_SendingAck |
|
475 // ----------------------------------------------------------------------------- |
|
476 // |
|
477 CInviteUAC_SendingAck::~CInviteUAC_SendingAck() |
|
478 { |
|
479 } |
|
480 |
|
481 // ----------------------------------------------------------------------------- |
|
482 // CInviteUAC_SendingAck::SetNeighbourStates |
|
483 // ----------------------------------------------------------------------------- |
|
484 // |
|
485 void |
|
486 CInviteUAC_SendingAck::SetNeighbourStates(CUserAgentState& aResolveAckAddress) |
|
487 { |
|
488 iResolveAckAddress = &aResolveAckAddress; |
|
489 } |
|
490 |
|
491 // ----------------------------------------------------------------------------- |
|
492 // CInviteUAC_SendingAck::SendCompleteL |
|
493 // No action, UAC ends when iTimerWait2xxRetransmissions expires |
|
494 // ----------------------------------------------------------------------------- |
|
495 // |
|
496 void CInviteUAC_SendingAck::SendCompleteL(CUserAgent& /*aUserAgent*/) const |
|
497 { |
|
498 } |
|
499 |
|
500 // ----------------------------------------------------------------------------- |
|
501 // CInviteUAC_SendingAck::SendFailedL |
|
502 // ----------------------------------------------------------------------------- |
|
503 // |
|
504 void CInviteUAC_SendingAck::SendFailedL(CUserAgent& aUserAgent, |
|
505 TInt aError) const |
|
506 { |
|
507 if (!CInviteUAC::Ptr(aUserAgent).TryNextAddressL(aError, |
|
508 *iResolveAckAddress, |
|
509 *this)) |
|
510 { |
|
511 aUserAgent.Stop(aError); |
|
512 } |
|
513 } |
|
514 |
|
515 // ----------------------------------------------------------------------------- |
|
516 // CInviteUAC_SendingAck::SendAckL |
|
517 // ----------------------------------------------------------------------------- |
|
518 // |
|
519 void CInviteUAC_SendingAck::SendAckL(CUserAgent& aUserAgent, |
|
520 CSIPRequest* aAck, |
|
521 MTransactionOwner& aObserver, |
|
522 const TSIPTransportParams& aParams, |
|
523 TRegistrationId aRegisterId, |
|
524 const CURIContainer& aRemoteTarget, |
|
525 TBool aDeleteRequest, |
|
526 RStringF /*aBranch*/) const |
|
527 { |
|
528 __SIP_ASSERT_LEAVE(aAck, KErrArgument); |
|
529 |
|
530 CInviteUAC::Ptr(aUserAgent).SendAdditionalAckL(aAck, |
|
531 aObserver, |
|
532 aParams, |
|
533 aRegisterId, |
|
534 aRemoteTarget, |
|
535 aDeleteRequest); |
|
536 } |
|
537 |
|
538 // ----------------------------------------------------------------------------- |
|
539 // CInviteUAC_SendingAck::ReceiveL |
|
540 // ----------------------------------------------------------------------------- |
|
541 // |
|
542 void CInviteUAC_SendingAck::ReceiveL(CUserAgent& aUserAgent, |
|
543 CSIPResponse* aResponse) const |
|
544 { |
|
545 __SIP_ASSERT_LEAVE(aResponse, KErrArgument); |
|
546 |
|
547 CInviteUAC::Ptr(aUserAgent).HandleAdditional2xxL(aResponse); |
|
548 } |
|
549 |
|
550 // ----------------------------------------------------------------------------- |
|
551 // CInviteUAC_SendingAck::IcmpErrorL |
|
552 // InviteUAC handles IcmpErrorL only in states where it has sent a request |
|
553 // ----------------------------------------------------------------------------- |
|
554 // |
|
555 void CInviteUAC_SendingAck::IcmpErrorL(CUserAgent& aUserAgent, |
|
556 const TInetAddr& aAddress, |
|
557 CSipConnectionMgr::TICMPError /*aError*/) const |
|
558 { |
|
559 CInviteUAC::Ptr(aUserAgent).HandleIcmpErrorL(aAddress, |
|
560 *iResolveAckAddress, |
|
561 *this); |
|
562 } |
|
563 |
|
564 // ----------------------------------------------------------------------------- |
|
565 // CInviteUAC_SendingAck::TimerExpiredL |
|
566 // ----------------------------------------------------------------------------- |
|
567 // |
|
568 void CInviteUAC_SendingAck::TimerExpiredL(CUserAgent& aUserAgent, |
|
569 TTimerId aTimerId, |
|
570 TAny* aTimerParam) const |
|
571 { |
|
572 __SIP_ASSERT_LEAVE(aTimerParam, KErrArgument); |
|
573 |
|
574 HandleTimerExpirationL(aUserAgent, aTimerId, aTimerParam); |
|
575 } |
|
576 |
|
577 // ----------------------------------------------------------------------------- |
|
578 // CInviteUAC_WaitTransactionToEnd::CInviteUAC_WaitTransactionToEnd |
|
579 // ----------------------------------------------------------------------------- |
|
580 // |
|
581 CInviteUAC_WaitTransactionToEnd::CInviteUAC_WaitTransactionToEnd() |
|
582 { |
|
583 } |
|
584 |
|
585 // ----------------------------------------------------------------------------- |
|
586 // CInviteUAC_WaitTransactionToEnd::~CInviteUAC_WaitTransactionToEnd |
|
587 // ----------------------------------------------------------------------------- |
|
588 // |
|
589 CInviteUAC_WaitTransactionToEnd::~CInviteUAC_WaitTransactionToEnd() |
|
590 { |
|
591 } |
|
592 |
|
593 // ----------------------------------------------------------------------------- |
|
594 // CInviteUAC_WaitTransactionToEnd::CanContinueWithoutOutgoingMsg |
|
595 // ----------------------------------------------------------------------------- |
|
596 // |
|
597 TBool CInviteUAC_WaitTransactionToEnd::CanContinueWithoutOutgoingMsg( |
|
598 TBool /*aFinalRespPassed*/) const |
|
599 { |
|
600 return ETrue; |
|
601 } |
|
602 |
|
603 // ----------------------------------------------------------------------------- |
|
604 // CInviteUAC_WaitTransactionToEnd::TransactionEndsL |
|
605 // ----------------------------------------------------------------------------- |
|
606 // |
|
607 void CInviteUAC_WaitTransactionToEnd::TransactionEndsL(CUserAgent& aUserAgent, |
|
608 TInt aReason) const |
|
609 { |
|
610 aUserAgent.Stop(aReason); |
|
611 } |
|
612 |
|
613 // ----------------------------------------------------------------------------- |
|
614 // CInviteUAC_WaitTransactionToEnd::SendAckL |
|
615 // Upper layer can't send ACK, as a 3xx-6xx response was received. |
|
616 // ----------------------------------------------------------------------------- |
|
617 // |
|
618 void CInviteUAC_WaitTransactionToEnd::SendAckL(CUserAgent& /*aUserAgent*/, |
|
619 CSIPRequest* aAck, |
|
620 MTransactionOwner& /*aObserver*/, |
|
621 const TSIPTransportParams& /*aParams*/, |
|
622 TRegistrationId /*aRegisterId*/, |
|
623 const CURIContainer& /*aRemoteTarget*/, |
|
624 TBool /*aDeleteRequest*/, |
|
625 RStringF /*aBranch*/) const |
|
626 { |
|
627 __SIP_ASSERT_LEAVE(aAck, KErrArgument); |
|
628 |
|
629 User::Leave(KErrSIPInvalidTransactionState); |
|
630 } |
|
631 |
|
632 // ----------------------------------------------------------------------------- |
|
633 // CInviteUAC_WaitAuthentication::CInviteUAC_WaitAuthentication |
|
634 // ----------------------------------------------------------------------------- |
|
635 // |
|
636 CInviteUAC_WaitAuthentication::CInviteUAC_WaitAuthentication() |
|
637 { |
|
638 } |
|
639 |
|
640 // ----------------------------------------------------------------------------- |
|
641 // CInviteUAC_WaitAuthentication::~CInviteUAC_WaitAuthentication |
|
642 // ----------------------------------------------------------------------------- |
|
643 // |
|
644 CInviteUAC_WaitAuthentication::~CInviteUAC_WaitAuthentication() |
|
645 { |
|
646 } |
|
647 |
|
648 // ----------------------------------------------------------------------------- |
|
649 // CInviteUAC_WaitAuthentication::SetNeighbourStates |
|
650 // ----------------------------------------------------------------------------- |
|
651 // |
|
652 void CInviteUAC_WaitAuthentication::SetNeighbourStates( |
|
653 CUserAgentState& aResolveAddress, |
|
654 CUserAgentState& aWaitResponse, |
|
655 CUserAgentState& aWaitAckFromApp, |
|
656 CUserAgentState& aWaitTransactionToEnd) |
|
657 { |
|
658 iResolveAddress = &aResolveAddress; |
|
659 iWaitResponse = &aWaitResponse; |
|
660 iWaitAckFromApp = &aWaitAckFromApp; |
|
661 iWaitTransactionToEnd = &aWaitTransactionToEnd; |
|
662 } |
|
663 |
|
664 // ----------------------------------------------------------------------------- |
|
665 // CInviteUAC_WaitAuthentication::SIPSecCacheUpdatedL |
|
666 // ----------------------------------------------------------------------------- |
|
667 // |
|
668 void |
|
669 CInviteUAC_WaitAuthentication::SIPSecCacheUpdatedL(CUserAgent& aUserAgent, |
|
670 TBool aSuccess) const |
|
671 { |
|
672 CInviteUAC::Ptr(aUserAgent).SIPSecCacheUpdatedL(aSuccess, |
|
673 *iResolveAddress, |
|
674 *iWaitResponse, |
|
675 *iWaitAckFromApp, |
|
676 *iWaitTransactionToEnd); |
|
677 } |
|
678 |
|
679 // ----------------------------------------------------------------------------- |
|
680 // CInviteUAC_WaitAuthentication::TimerExpiredL |
|
681 // ----------------------------------------------------------------------------- |
|
682 // |
|
683 void CInviteUAC_WaitAuthentication::TimerExpiredL(CUserAgent& aUserAgent, |
|
684 TTimerId aTimerId, |
|
685 TAny* aTimerParam) const |
|
686 { |
|
687 __SIP_ASSERT_LEAVE(aTimerParam, KErrArgument); |
|
688 |
|
689 HandleTimerExpirationL(aUserAgent, aTimerId, aTimerParam); |
|
690 } |
|
691 |
|
692 // ----------------------------------------------------------------------------- |
|
693 // CInviteUAC_WaitAuthentication::TransactionEndsL |
|
694 // ----------------------------------------------------------------------------- |
|
695 // |
|
696 void CInviteUAC_WaitAuthentication::TransactionEndsL(CUserAgent& aUserAgent, |
|
697 TInt /*aReason*/) const |
|
698 { |
|
699 aUserAgent.RequestDeletionOfTransactionL(); |
|
700 CInviteUAC::Ptr(aUserAgent).IgnoreResponseRetransmissionsL(); |
|
701 } |
|
702 |
|
703 // ----------------------------------------------------------------------------- |
|
704 // CInviteUAC_WaitAuthentication::SendAckL |
|
705 // 2xx hasn't been received, so application can't send ACK. |
|
706 // ----------------------------------------------------------------------------- |
|
707 // |
|
708 void CInviteUAC_WaitAuthentication::SendAckL(CUserAgent& /*aUserAgent*/, |
|
709 CSIPRequest* aAck, |
|
710 MTransactionOwner& /*aObserver*/, |
|
711 const TSIPTransportParams& /*aParams*/, |
|
712 TRegistrationId /*aRegisterId*/, |
|
713 const CURIContainer& /*aRemoteTarget*/, |
|
714 TBool /*aDeleteRequest*/, |
|
715 RStringF /*aBranch*/) const |
|
716 { |
|
717 __SIP_ASSERT_LEAVE(aAck, KErrArgument); |
|
718 |
|
719 User::Leave(KErrSIPInvalidTransactionState); |
|
720 } |