|
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 : CSipCSSubSession.cpp |
|
15 // Part of : SIPServerCore |
|
16 // Version : SIP/6.0 |
|
17 // |
|
18 |
|
19 |
|
20 |
|
21 #include "SipCSServer.pan" |
|
22 #include "CSipCSSubSession.h" |
|
23 #include "CSipCSSession.h" |
|
24 #include "CSipServerCore.h" |
|
25 #include "CSipCSServerITC.h" |
|
26 #include "CSipCSSubSessionReceiver.h" |
|
27 #include "CTransactionUser.h" |
|
28 #include "CSipDialogMgr.h" |
|
29 #include "CSIPRegistrationMgr.h" |
|
30 #include "MSipRegistrations.h" |
|
31 #include "MSipRefreshMgr.h" |
|
32 #include "siprequest.h" |
|
33 #include "sipresponse.h" |
|
34 #include "siprouteheader.h" |
|
35 #include "sipexpiresheader.h" |
|
36 #include "siptoheader.h" |
|
37 #include "sipfromheader.h" |
|
38 #include "sipcontactheader.h" |
|
39 #include "sipcallidheader.h" |
|
40 #include "sipaddress.h" |
|
41 #include "uricontainer.h" |
|
42 #include "sipuri.h" |
|
43 #include "TSIPRemoteTargetAndProxy.h" |
|
44 #include "SipAssert.h" |
|
45 #include "sipstrings.h" |
|
46 #include "sipstrconsts.h" |
|
47 #include "sipcodecutils.h" |
|
48 #include "sipsec.h" |
|
49 #include "CSipConnectionMgr.h" |
|
50 |
|
51 |
|
52 // ----------------------------------------------------------------------------- |
|
53 // CSipCSSubSession::NewLC |
|
54 // ----------------------------------------------------------------------------- |
|
55 // |
|
56 CSipCSSubSession* CSipCSSubSession::NewLC (CSipCSSession& aSession, |
|
57 MSIPSecUser& aSIPSecUser, |
|
58 TUint32 aIapId) |
|
59 { |
|
60 CSipCSSubSession* self = |
|
61 new(ELeave)CSipCSSubSession(aSession,aSIPSecUser,aIapId); |
|
62 CleanupClosePushL(*self); // CObject: Close will call the destructor. |
|
63 self->ConstructL(); |
|
64 return self; |
|
65 } |
|
66 |
|
67 // ----------------------------------------------------------------------------- |
|
68 // CSipCSSubSession::CSipCSSubSession |
|
69 // ----------------------------------------------------------------------------- |
|
70 // |
|
71 CSipCSSubSession::CSipCSSubSession (CSipCSSession& aSession, |
|
72 MSIPSecUser& aSIPSecUser, |
|
73 TUint32 aIapId) |
|
74 : iSession (aSession), |
|
75 iSIPSecUser (aSIPSecUser), |
|
76 iTransportParams (aSession.ServerCore().CreateTransportOwnerId(), aIapId), |
|
77 iState (CSIPConnection::EInit), |
|
78 iIapOpened (EFalse) |
|
79 { |
|
80 } |
|
81 |
|
82 // ----------------------------------------------------------------------------- |
|
83 // CSipCSSubSession::ConstructL |
|
84 // ----------------------------------------------------------------------------- |
|
85 // |
|
86 void CSipCSSubSession::ConstructL () |
|
87 { |
|
88 iReceiver = CSipCSSubSessionReceiver::NewL(ITC(),iSIPSecUser,*this); |
|
89 } |
|
90 |
|
91 // ----------------------------------------------------------------------------- |
|
92 // CSipCSSubSession::~CSipCSSubSession |
|
93 // ----------------------------------------------------------------------------- |
|
94 // |
|
95 CSipCSSubSession::~CSipCSSubSession() |
|
96 { |
|
97 if (iReceiver) |
|
98 { |
|
99 Server().DialogMgr().TerminateDialogsFor(iReceiver); |
|
100 Server().RegistrationMgr().ClearRegistrationOwner(iReceiver); |
|
101 Server().RefreshMgr().RemoveRefreshesFor(iReceiver); |
|
102 Server().TU().ClearTransactionOwner(iReceiver); |
|
103 } |
|
104 Server().SIPSec().ClearCache(&iSIPSecUser); |
|
105 delete iReceiver; |
|
106 if (iIapOpened && iState != CSIPConnection::EUnavailable) |
|
107 { |
|
108 // When a connection goes unavailable, |
|
109 // ConnectionMgr destroys it immediately. |
|
110 // After this the connection must not be closed from here, |
|
111 // since this might mix up the reference count in ConnectionMgr. |
|
112 Server().ConnectionMgr().Close(iTransportParams); |
|
113 } |
|
114 } |
|
115 |
|
116 // ----------------------------------------------------------------------------- |
|
117 // CSipCSSubSession::TransportParams |
|
118 // From MSIPCSReceiverOwner |
|
119 // ----------------------------------------------------------------------------- |
|
120 // |
|
121 const TSIPTransportParams& CSipCSSubSession::TransportParams() const |
|
122 { |
|
123 return iTransportParams; |
|
124 } |
|
125 |
|
126 // ----------------------------------------------------------------------------- |
|
127 // CSipCSSubSession::TransportParams |
|
128 // From MSIPCSReceiverOwner |
|
129 // ----------------------------------------------------------------------------- |
|
130 // |
|
131 TSIPTransportParams CSipCSSubSession::TransportParams( |
|
132 const TRegistrationId& aRegistrationId) |
|
133 { |
|
134 TSIPTransportParams transportParams(iTransportParams); |
|
135 if (aRegistrationId != KEmptyRegistrationId) |
|
136 { |
|
137 Server().RegistrationMgr().FillTransportParams(aRegistrationId, |
|
138 transportParams); |
|
139 |
|
140 // Filling params overrides ownerid, set correct value back |
|
141 transportParams.SetOwnerId( iTransportParams.OwnerId() ); |
|
142 } |
|
143 return transportParams; |
|
144 } |
|
145 |
|
146 // ----------------------------------------------------------------------------- |
|
147 // CSipCSSubSession::SIPSecUser |
|
148 // From MSIPCSReceiverOwner |
|
149 // ----------------------------------------------------------------------------- |
|
150 // |
|
151 const MSIPSecUser* CSipCSSubSession::SIPSecUser( |
|
152 const TRegistrationId& aRegistrationId) |
|
153 { |
|
154 return Server().RegistrationMgr().SIPSecUser(aRegistrationId); |
|
155 } |
|
156 |
|
157 // ----------------------------------------------------------------------------- |
|
158 // CSipCSSubSession::TransactionOwner |
|
159 // ----------------------------------------------------------------------------- |
|
160 // |
|
161 MTransactionOwner* CSipCSSubSession::TransactionOwner () |
|
162 { |
|
163 return iReceiver; |
|
164 } |
|
165 |
|
166 // ----------------------------------------------------------------------------- |
|
167 // CSipCSSubSession::Receiver |
|
168 // ----------------------------------------------------------------------------- |
|
169 // |
|
170 CSipCSReceiverBase& CSipCSSubSession::Receiver() |
|
171 { |
|
172 return *iReceiver; |
|
173 } |
|
174 |
|
175 // ----------------------------------------------------------------------------- |
|
176 // CSipCSSubSession::IapId |
|
177 // ----------------------------------------------------------------------------- |
|
178 // |
|
179 TUint32 CSipCSSubSession::IapId () const |
|
180 { |
|
181 return iTransportParams.IapId(); |
|
182 } |
|
183 |
|
184 // ----------------------------------------------------------------------------- |
|
185 // CSipCSSubSession::OpenIapL |
|
186 // ----------------------------------------------------------------------------- |
|
187 // |
|
188 void CSipCSSubSession::OpenIapL (const RMessage2& aMessage) |
|
189 { |
|
190 iState = Server().ConnectionMgr().OpenL(iTransportParams); |
|
191 iIapOpened = ETrue; |
|
192 ITC().WriteL(aMessage,iState); |
|
193 } |
|
194 |
|
195 // ----------------------------------------------------------------------------- |
|
196 // CSipCSSubSession::SetStateL |
|
197 // ----------------------------------------------------------------------------- |
|
198 // |
|
199 void CSipCSSubSession::SetStateL (CSIPConnection::TState aState) |
|
200 { |
|
201 if (iState != aState) |
|
202 { |
|
203 iState = aState; |
|
204 iReceiver->ConnectionStateChangedL(aState); |
|
205 } |
|
206 } |
|
207 |
|
208 // ----------------------------------------------------------------------------- |
|
209 // CSipCSSubSession::ServiceL |
|
210 // ----------------------------------------------------------------------------- |
|
211 // |
|
212 void CSipCSSubSession::ServiceL (TSIPIds& aIds, |
|
213 TInt aFunction, |
|
214 const RMessage2& aMessage) |
|
215 { |
|
216 switch (aFunction) |
|
217 { |
|
218 case ESipItcGetLocalAddr: |
|
219 GetLocalAddrL(aMessage); break; |
|
220 |
|
221 case ESipItcSetSIPSockOpt: |
|
222 SetSIPSockOptL(aMessage); break; |
|
223 |
|
224 case ESipItcSetSIPSockOptWithDes: |
|
225 SetSIPSockOptL(aMessage,ETrue); break; |
|
226 |
|
227 case ESipItcSetOutboundProxy: |
|
228 SetOutboundProxyL(aIds,aMessage); break; |
|
229 |
|
230 case ESipItcOutboundProxy: |
|
231 OutboundProxyL(aIds,aMessage); break; |
|
232 |
|
233 case ESipItcRemoveOutboundProxy: |
|
234 RemoveOutboundProxyL(aIds); break; |
|
235 |
|
236 case ESipItcRegister: |
|
237 RegisterL(aIds,aMessage); break; |
|
238 |
|
239 case ESipItcRegisterAndSetOutboundProxy: |
|
240 RegisterAndSetOutboundProxyL(aIds,aMessage); break; |
|
241 |
|
242 case ESipItcUpdateRegistration: |
|
243 UpdateRegistrationL(aIds,aMessage); break; |
|
244 |
|
245 case ESipItcUnRegister: |
|
246 UnRegisterL(aIds,aMessage); break; |
|
247 |
|
248 case ESipItcFetchRegistrations: |
|
249 FetchRegistrationsL(aMessage); break; |
|
250 |
|
251 case ESipItcSendRequest: |
|
252 SendRequestL(aIds,aMessage); break; |
|
253 |
|
254 case ESipItcSendRequestAndUpdateRefresh: |
|
255 SendRequestAndUpdateRefreshL (aIds,aMessage); break; |
|
256 |
|
257 case ESipItcSendRequestAndTerminateRefresh: |
|
258 SendRequestAndTerminateRefreshL (aIds,aMessage); break; |
|
259 |
|
260 case ESipItcSendResponse: |
|
261 SendResponseL(aIds,aMessage); break; |
|
262 |
|
263 case ESipItcSendCancel: |
|
264 SendCancelL(aIds,aMessage); break; |
|
265 |
|
266 case ESipItcSendResponseAndCreateDialog: |
|
267 SendResponseAndCreateDialogL(aIds,aMessage); break; |
|
268 |
|
269 case ESipItcSendResponseInDialog: |
|
270 SendResponseInDialogL(aIds,aMessage); break; |
|
271 |
|
272 case ESipItcSendRequestAndCreateDialog: |
|
273 SendRequestAndCreateDialogL(aIds,aMessage); break; |
|
274 |
|
275 case ESipItcSendRequestInDialog: |
|
276 SendRequestInDialogL(aIds,aMessage); break; |
|
277 |
|
278 case ESipItcSendRequestInDialogAndUpdateRefresh: |
|
279 SendRequestInDialogAndUpdateRefreshL(aIds,aMessage); break; |
|
280 |
|
281 case ESipItcTerminateDialog: |
|
282 TerminateDialogL(aIds.iDialogId); break; |
|
283 |
|
284 case ESipItcTerminateRefresh: |
|
285 TerminateRefreshL(aIds.iRefreshId); break; |
|
286 |
|
287 case ESipItcTerminateDialogRefresh: |
|
288 TerminateDialogRefreshL(aIds.iDialogId,aIds.iRefreshId); break; |
|
289 |
|
290 case ESipItcTerminateRegistration: |
|
291 TerminateRegistrationL(aIds.iRegistrationId); break; |
|
292 |
|
293 case ESipItcConnectionReadyToReceive: // Async. Do not complete yet. |
|
294 ClientReadyToReceiveL(aMessage); return; |
|
295 |
|
296 case ESipItcConnectionReceiveSipMessage: |
|
297 ReceiveSipMessageL(aMessage); break; |
|
298 |
|
299 case ESipItcConnectionCancelReceive: |
|
300 CancelClientReceiveL(); break; |
|
301 |
|
302 case ESipItcGetFromHeader: |
|
303 GetFromHeaderL(aIds.iRegistrationId,aMessage); break; |
|
304 |
|
305 case ESipItcSetRefreshInterval: |
|
306 SetRefreshIntervalL(aIds.iRefreshId,aMessage); break; |
|
307 |
|
308 case ESipItcGetRefreshInterval: |
|
309 GetRefreshIntervalL(aIds.iRefreshId,aMessage); break; |
|
310 |
|
311 case ESipItcGetCallIDHeader: |
|
312 GetCallIDHeaderL(aIds.iDialogId,aMessage); break; |
|
313 |
|
314 case ESipItcGetLocalTag: |
|
315 GetLocalTagL(aIds.iDialogId,aMessage); break; |
|
316 |
|
317 case ESipItcGetRegisteredContact: |
|
318 GetRegisteredContactL(aIds.iRegistrationId,aMessage); break; |
|
319 |
|
320 case ESipItcResetDialogState: |
|
321 ResetDialogStateL(aIds.iDialogId); break; |
|
322 |
|
323 case ESipItcRefreshConnection: |
|
324 RefreshConnectionL(aIds.iIapId); break; |
|
325 |
|
326 case ESipItcGetConnectionError: |
|
327 GetConnectionErrorL(aIds,aMessage); break; |
|
328 |
|
329 default: ITC().PanicClient (aMessage, EBadRequest); break; |
|
330 } |
|
331 ITC().Complete (aMessage, KErrNone); |
|
332 } |
|
333 |
|
334 // ----------------------------------------------------------------------------- |
|
335 // CSipCSSubSession::GetLocalAddrL |
|
336 // ----------------------------------------------------------------------------- |
|
337 // |
|
338 void CSipCSSubSession::GetLocalAddrL(const RMessage2& aMessage) |
|
339 { |
|
340 TInt err = Server().ConnectionMgr().GetLocalAddress( |
|
341 iTransportParams.IapId(),iLocalAddr); |
|
342 User::LeaveIfError(err); |
|
343 ITC().WriteL(aMessage,iLocalAddr); |
|
344 } |
|
345 |
|
346 // ----------------------------------------------------------------------------- |
|
347 // CSipCSSubSession::SetSIPSockOptL |
|
348 // ----------------------------------------------------------------------------- |
|
349 // |
|
350 void CSipCSSubSession::SetSIPSockOptL(const RMessage2& aMessage, TBool aDesOpt) |
|
351 { |
|
352 TSIPSockOpt opt(ITC().ReadSIPSockOptL(aMessage)); |
|
353 if (aDesOpt) |
|
354 { |
|
355 HBufC8* desOptBuf = ITC().ReadLC(aMessage,ESipItcArgSockOptDes); |
|
356 Server().ConnectionMgr().SetOptL( |
|
357 iTransportParams, opt.iOptionName, opt.iOptionLevel, *desOptBuf); |
|
358 CleanupStack::PopAndDestroy(desOptBuf); |
|
359 } |
|
360 else |
|
361 { |
|
362 Server().ConnectionMgr().SetOptL( |
|
363 iTransportParams, opt.iOptionName, opt.iOptionLevel, opt.iOption); |
|
364 } |
|
365 } |
|
366 |
|
367 // ----------------------------------------------------------------------------- |
|
368 // CSipCSSubSession::SetOutboundProxyL |
|
369 // ----------------------------------------------------------------------------- |
|
370 // |
|
371 void CSipCSSubSession::SetOutboundProxyL (TSIPIds& aIds, |
|
372 const RMessage2& aMessage) |
|
373 { |
|
374 CSIPRouteHeader* proxy = ITC().ReadProxyLC(aMessage); |
|
375 Server().RegistrationMgr().SetOutboundProxyL(aIds.iRegistrationId,proxy, |
|
376 iReceiver); |
|
377 CleanupStack::Pop(proxy); |
|
378 } |
|
379 |
|
380 // ----------------------------------------------------------------------------- |
|
381 // CSipCSSubSession::OutboundProxyL |
|
382 // ----------------------------------------------------------------------------- |
|
383 // |
|
384 void CSipCSSubSession::OutboundProxyL (TSIPIds& aIds, const RMessage2& aMessage) |
|
385 { |
|
386 if (Server().Registrations().HasOutboundProxy(aIds.iRegistrationId)) |
|
387 { |
|
388 const CSIPRouteHeader* proxy = |
|
389 Server().Registrations().OutboundProxy(aIds.iRegistrationId); |
|
390 if (proxy) |
|
391 { |
|
392 ITC().WriteL(aMessage,*proxy); |
|
393 } |
|
394 else |
|
395 { |
|
396 User::Leave(KErrNotFound); |
|
397 } |
|
398 } |
|
399 } |
|
400 |
|
401 // ----------------------------------------------------------------------------- |
|
402 // CSipCSSubSession::RemoveOutboundProxyL |
|
403 // ----------------------------------------------------------------------------- |
|
404 // |
|
405 void CSipCSSubSession::RemoveOutboundProxyL (TSIPIds& aIds) |
|
406 { |
|
407 TInt err = Server().RegistrationMgr().RemoveOutboundProxy( |
|
408 aIds.iRegistrationId, iReceiver); |
|
409 if (err != KErrNone) |
|
410 { |
|
411 User::Leave(err); |
|
412 } |
|
413 } |
|
414 |
|
415 // ----------------------------------------------------------------------------- |
|
416 // CSipCSSubSession::RegisterL |
|
417 // ----------------------------------------------------------------------------- |
|
418 // |
|
419 void CSipCSSubSession::RegisterL (TSIPIds& aIds, const RMessage2& aMessage) |
|
420 { |
|
421 CSIPRequest* request = |
|
422 CSIPRequest::NewLC(SIPStrings::StringF(SipStrConsts::ERegister)); |
|
423 CURIContainer* remoteTarget = FillRequestLC(aMessage,*request); |
|
424 CheckSigCompInNextHopL(KEmptyRegistrationId,*remoteTarget,*request); |
|
425 |
|
426 Server().RegistrationMgr().RegisterL(aIds.iRequestId,aIds.iRegistrationId, |
|
427 request,*remoteTarget,iReceiver, |
|
428 iSIPSecUser,0,aIds.iRefresh, |
|
429 aIds.iSendWithExpires, |
|
430 aIds.iCacheOutboundProxyIP); |
|
431 CleanupStack::PopAndDestroy(remoteTarget); |
|
432 CleanupStack::Pop(request); |
|
433 ITC().WriteL(aMessage,aIds); |
|
434 } |
|
435 |
|
436 // ----------------------------------------------------------------------------- |
|
437 // CSipCSSubSession::RegisterAndSetOutboundProxyL |
|
438 // ----------------------------------------------------------------------------- |
|
439 // |
|
440 void CSipCSSubSession::RegisterAndSetOutboundProxyL (TSIPIds& aIds, |
|
441 const RMessage2& aMessage) |
|
442 { |
|
443 CSIPRequest* request = |
|
444 CSIPRequest::NewLC(SIPStrings::StringF(SipStrConsts::ERegister)); |
|
445 TSIPRemoteTargetAndProxy remoteTargetAndProxy; |
|
446 FillRequestL(aMessage,*request,remoteTargetAndProxy,EFalse,ETrue); |
|
447 CleanupStack::PushL (remoteTargetAndProxy.iProxy); |
|
448 CleanupStack::PushL (remoteTargetAndProxy.iRemoteTarget); |
|
449 CURIContainer* remoteTarget = remoteTargetAndProxy.iRemoteTarget; |
|
450 CheckSigCompInNextHopL(KEmptyRegistrationId,*remoteTarget,*request); |
|
451 |
|
452 Server().RegistrationMgr().RegisterL(aIds.iRequestId,aIds.iRegistrationId, |
|
453 request,*remoteTarget, |
|
454 iReceiver,iSIPSecUser, |
|
455 remoteTargetAndProxy.iProxy, |
|
456 aIds.iRefresh, |
|
457 aIds.iSendWithExpires, |
|
458 aIds.iCacheOutboundProxyIP); |
|
459 CleanupStack::PopAndDestroy(remoteTargetAndProxy.iRemoteTarget); |
|
460 CleanupStack::Pop(remoteTargetAndProxy.iProxy); |
|
461 CleanupStack::Pop(request); |
|
462 ITC().WriteL (aMessage,aIds); |
|
463 } |
|
464 |
|
465 // ----------------------------------------------------------------------------- |
|
466 // CSipCSSubSession::UpdateRegistrationL |
|
467 // ----------------------------------------------------------------------------- |
|
468 // |
|
469 void CSipCSSubSession::UpdateRegistrationL (TSIPIds& aIds, |
|
470 const RMessage2& aMessage) |
|
471 { |
|
472 CSIPRequest* request = |
|
473 CSIPRequest::NewLC(SIPStrings::StringF(SipStrConsts::ERegister)); |
|
474 ITC().ReadRequestL (aMessage,*request); |
|
475 |
|
476 Server().RegistrationMgr().UpdateRegistrationL(aIds.iRegistrationId, |
|
477 aIds.iRequestId, request, |
|
478 iReceiver); |
|
479 CleanupStack::Pop(request); |
|
480 ITC().WriteL(aMessage,aIds); |
|
481 } |
|
482 |
|
483 // ----------------------------------------------------------------------------- |
|
484 // CSipCSSubSession::UnRegisterL |
|
485 // ----------------------------------------------------------------------------- |
|
486 // |
|
487 void CSipCSSubSession::UnRegisterL (TSIPIds& aIds, const RMessage2& aMessage) |
|
488 { |
|
489 CSIPRequest* request = |
|
490 CSIPRequest::NewLC(SIPStrings::StringF(SipStrConsts::ERegister)); |
|
491 ITC().ReadRequestL (aMessage,*request); |
|
492 |
|
493 Server().RegistrationMgr().UnRegisterL(aIds.iRegistrationId, |
|
494 aIds.iRequestId, request, |
|
495 iReceiver); |
|
496 CleanupStack::Pop(request); |
|
497 ITC().WriteL(aMessage,aIds); |
|
498 } |
|
499 |
|
500 // ----------------------------------------------------------------------------- |
|
501 // CSipCSSubSession::FetchRegistrationsL |
|
502 // ----------------------------------------------------------------------------- |
|
503 // |
|
504 void CSipCSSubSession::FetchRegistrationsL (const RMessage2& aMessage) |
|
505 { |
|
506 TSIPIds ids; |
|
507 CSIPRequest* request = |
|
508 CSIPRequest::NewLC(SIPStrings::StringF(SipStrConsts::ERegister)); |
|
509 CURIContainer* remoteTarget = FillRequestLC(aMessage,*request); |
|
510 CheckSigCompInNextHopL(KEmptyRegistrationId,*remoteTarget,*request); |
|
511 |
|
512 Server().RegistrationMgr().FetchRegistrationsL(iTransportParams, |
|
513 ids.iRequestId, request, |
|
514 *remoteTarget, iReceiver); |
|
515 CleanupStack::PopAndDestroy(remoteTarget); |
|
516 CleanupStack::Pop(request); |
|
517 ITC().WriteL(aMessage,ids); |
|
518 } |
|
519 |
|
520 // ----------------------------------------------------------------------------- |
|
521 // CSipCSSubSession::SendRequestL |
|
522 // ----------------------------------------------------------------------------- |
|
523 // |
|
524 void CSipCSSubSession::SendRequestL (TSIPIds& aIds, |
|
525 const RMessage2& aMessage) |
|
526 { |
|
527 CSIPRequest* request = CSIPRequest::NewLC(); |
|
528 CURIContainer* remoteTarget = FillRequestLC(aMessage,*request,ETrue); |
|
529 CheckSigCompInNextHopL(aIds.iRegistrationId,*remoteTarget,*request); |
|
530 AddFromL (aIds.iRegistrationId, *request); |
|
531 AddRouteL (aIds.iRegistrationId, *request); |
|
532 if (aIds.iRefresh) |
|
533 { |
|
534 Server().RefreshMgr().RefreshL (aIds.iRequestId, aIds.iRefreshId, |
|
535 aIds.iRegistrationId, request, |
|
536 iReceiver, iSIPSecUser, |
|
537 *remoteTarget, ETrue, EFalse); |
|
538 } |
|
539 else |
|
540 { |
|
541 Server().TU().SendL (aIds.iRequestId, aIds.iRegistrationId, request, |
|
542 iReceiver, *remoteTarget, |
|
543 TransportParams(aIds.iRegistrationId), ETrue); |
|
544 } |
|
545 CleanupStack::PopAndDestroy(remoteTarget); |
|
546 CleanupStack::Pop(request); |
|
547 ITC().WriteL(aMessage,aIds); |
|
548 } |
|
549 |
|
550 // ----------------------------------------------------------------------------- |
|
551 // CSipCSSubSession::SendRequestAndUpdateRefreshL |
|
552 // ----------------------------------------------------------------------------- |
|
553 // |
|
554 void |
|
555 CSipCSSubSession::SendRequestAndUpdateRefreshL (TSIPIds& aIds, |
|
556 const RMessage2& aMessage) |
|
557 { |
|
558 CSIPRequest* request = CSIPRequest::NewLC(); |
|
559 ITC().ReadRequestL(aMessage,*request); |
|
560 Server().RefreshMgr().UpdateRefreshL(aIds.iRequestId, aIds.iRefreshId, |
|
561 request, iReceiver, ETrue); |
|
562 CleanupStack::Pop(request); |
|
563 ITC().WriteL(aMessage,aIds); |
|
564 } |
|
565 |
|
566 // ----------------------------------------------------------------------------- |
|
567 // CSipCSSubSession::SendRequestAndTerminateRefreshL |
|
568 // ----------------------------------------------------------------------------- |
|
569 // |
|
570 void |
|
571 CSipCSSubSession::SendRequestAndTerminateRefreshL (TSIPIds& aIds, |
|
572 const RMessage2& aMessage) |
|
573 { |
|
574 CSIPRequest* request = CSIPRequest::NewLC(); |
|
575 ITC().ReadRequestL (aMessage,*request); |
|
576 Server().RefreshMgr().TerminateRefreshL(aIds.iRequestId, aIds.iRefreshId, |
|
577 request, iReceiver, ETrue); |
|
578 CleanupStack::Pop(request); |
|
579 ITC().WriteL(aMessage,aIds); |
|
580 } |
|
581 |
|
582 // ----------------------------------------------------------------------------- |
|
583 // CSipCSSubSession::SendResponseL |
|
584 // ----------------------------------------------------------------------------- |
|
585 // |
|
586 void CSipCSSubSession::SendResponseL (TSIPIds& aIds, const RMessage2& aMessage) |
|
587 { |
|
588 CSIPResponse* response = ITC().ReadResponseLC(aMessage); |
|
589 CheckSigCompInContactsL(*response); |
|
590 Server().TU().SendL(aIds.iRequestId,response,iTransportParams); |
|
591 CleanupStack::Pop(response); |
|
592 } |
|
593 |
|
594 // ----------------------------------------------------------------------------- |
|
595 // CSipCSSubSession::SendCancelL |
|
596 // ----------------------------------------------------------------------------- |
|
597 // |
|
598 void CSipCSSubSession::SendCancelL (TSIPIds& aIds, const RMessage2& aMessage) |
|
599 { |
|
600 TTransactionId cancelId; |
|
601 Server().TU().SendCancelL(aIds.iRequestId,cancelId,iReceiver); |
|
602 aIds.iRequestId = cancelId; |
|
603 ITC().WriteL(aMessage,aIds); |
|
604 } |
|
605 |
|
606 // ----------------------------------------------------------------------------- |
|
607 // CSipCSSubSession::SendResponseAndCreateDialogL |
|
608 // ----------------------------------------------------------------------------- |
|
609 // |
|
610 void CSipCSSubSession::SendResponseAndCreateDialogL (TSIPIds& aIds, |
|
611 const RMessage2& aMessage) |
|
612 { |
|
613 CSIPResponse* response = ITC().ReadResponseLC(aMessage); |
|
614 // Client must not add a sigcomp-parameter to Contact of a response |
|
615 CheckSigCompInContactsL(*response); |
|
616 AddContactL(aIds.iRegistrationId, *response); |
|
617 Server().DialogMgr().SendAndCreateDialogL(aIds.iRequestId, aIds.iRegistrationId, aIds.iDialogId, |
|
618 response, iReceiver, iSIPSecUser); |
|
619 CleanupStack::Pop(response); |
|
620 ITC().WriteL(aMessage,aIds); |
|
621 } |
|
622 |
|
623 // ----------------------------------------------------------------------------- |
|
624 // CSipCSSubSession::SendResponseInDialogL |
|
625 // ----------------------------------------------------------------------------- |
|
626 // |
|
627 void CSipCSSubSession::SendResponseInDialogL (TSIPIds& aIds, |
|
628 const RMessage2& aMessage) |
|
629 { |
|
630 CSIPResponse* response = ITC().ReadResponseLC(aMessage); |
|
631 // Client must not add a sigcomp-parameter to Contact of a response |
|
632 CheckSigCompInContactsL(*response); |
|
633 AddContactL(aIds.iRegistrationId, *response); |
|
634 Server().DialogMgr().SendWithinDialogL(aIds.iRequestId, aIds.iDialogId, |
|
635 response, iReceiver, |
|
636 aIds.iTargetRefresh); |
|
637 CleanupStack::Pop(response); |
|
638 } |
|
639 |
|
640 // ----------------------------------------------------------------------------- |
|
641 // CSipCSSubSession::SendRequestAndCreateDialogL |
|
642 // ----------------------------------------------------------------------------- |
|
643 // |
|
644 void CSipCSSubSession::SendRequestAndCreateDialogL (TSIPIds& aIds, |
|
645 const RMessage2& aMessage) |
|
646 { |
|
647 CSIPRequest* request = CSIPRequest::NewLC(); |
|
648 CURIContainer* remoteTarget = FillRequestLC(aMessage,*request,ETrue); |
|
649 AddFromL(aIds.iRegistrationId, *request); |
|
650 AddContactL(aIds.iRegistrationId, *request); |
|
651 AddRouteL(aIds.iRegistrationId, *request); |
|
652 |
|
653 Server().DialogMgr().SendAndCreateDialogL(aIds.iRequestId, aIds.iRefreshId, |
|
654 aIds.iRegistrationId, |
|
655 aIds.iDialogId, request, |
|
656 *remoteTarget, iReceiver, |
|
657 iSIPSecUser, aIds.iRefresh); |
|
658 CleanupStack::PopAndDestroy(remoteTarget); |
|
659 CleanupStack::Pop(request); |
|
660 ITC().WriteL(aMessage,aIds); |
|
661 } |
|
662 |
|
663 // ----------------------------------------------------------------------------- |
|
664 // CSipCSSubSession::SendRequestInDialogL |
|
665 // ----------------------------------------------------------------------------- |
|
666 // |
|
667 void CSipCSSubSession::SendRequestInDialogL (TSIPIds& aIds, |
|
668 const RMessage2& aMessage) |
|
669 { |
|
670 CSIPRequest* request = CSIPRequest::NewLC(); |
|
671 ITC().ReadRequestL(aMessage,*request,ETrue); |
|
672 TBool allowOverlapping = OverlappingInDialogAllowed(request->Method()); |
|
673 |
|
674 Server().DialogMgr().SendWithinDialogL(aIds.iRequestId, aIds.iRefreshId, |
|
675 aIds.iDialogId, request, |
|
676 iReceiver, aIds.iRefresh, |
|
677 allowOverlapping, |
|
678 aIds.iTargetRefresh); |
|
679 CleanupStack::Pop(request); |
|
680 ITC().WriteL(aMessage,aIds); |
|
681 } |
|
682 |
|
683 // ----------------------------------------------------------------------------- |
|
684 // CSipCSSubSession::SendRequestInDialogAndUpdateRefreshL |
|
685 // ----------------------------------------------------------------------------- |
|
686 // |
|
687 void CSipCSSubSession::SendRequestInDialogAndUpdateRefreshL ( |
|
688 TSIPIds& aIds, |
|
689 const RMessage2& aMessage) |
|
690 { |
|
691 CSIPRequest* request = CSIPRequest::NewLC(); |
|
692 ITC().ReadRequestL(aMessage,*request); |
|
693 |
|
694 Server().DialogMgr().SendAndUpdateRefreshL(aIds.iRequestId, aIds.iRefreshId, |
|
695 aIds.iDialogId, request, |
|
696 iReceiver); |
|
697 |
|
698 CleanupStack::Pop(request); |
|
699 ITC().WriteL(aMessage,aIds); |
|
700 } |
|
701 |
|
702 // ----------------------------------------------------------------------------- |
|
703 // CSipCSSubSession::TerminateDialogL |
|
704 // ----------------------------------------------------------------------------- |
|
705 // |
|
706 void CSipCSSubSession::TerminateDialogL (const TDialogId& aId) |
|
707 { |
|
708 TInt err = Server().DialogMgr().TerminateDialog(aId,iReceiver); |
|
709 if (err != KErrNone) |
|
710 { |
|
711 User::Leave (err); |
|
712 } |
|
713 } |
|
714 |
|
715 // ----------------------------------------------------------------------------- |
|
716 // CSipCSSubSession::TerminateRefreshL |
|
717 // ----------------------------------------------------------------------------- |
|
718 // |
|
719 void CSipCSSubSession::TerminateRefreshL (const TRefreshId& aId) |
|
720 { |
|
721 TInt err = Server().RefreshMgr().TerminateRefresh(aId,iReceiver); |
|
722 if (err != KErrNone) |
|
723 { |
|
724 User::Leave(err); |
|
725 } |
|
726 } |
|
727 |
|
728 // ----------------------------------------------------------------------------- |
|
729 // CSipCSSubSession::TerminateDialogRefreshL |
|
730 // ----------------------------------------------------------------------------- |
|
731 // |
|
732 void CSipCSSubSession::TerminateDialogRefreshL (const TDialogId& aDialogId, |
|
733 const TRefreshId& aRefreshId) |
|
734 { |
|
735 TInt err = Server().DialogMgr().TerminateDialogRefresh( |
|
736 aDialogId,aRefreshId,iReceiver); |
|
737 if (err != KErrNone) |
|
738 { |
|
739 User::Leave(err); |
|
740 } |
|
741 } |
|
742 |
|
743 // ----------------------------------------------------------------------------- |
|
744 // CSipCSSubSession::TerminateRegistrationL |
|
745 // ----------------------------------------------------------------------------- |
|
746 // |
|
747 void CSipCSSubSession::TerminateRegistrationL (const TRegistrationId& aId) |
|
748 { |
|
749 TInt err = Server().RegistrationMgr().TerminateRegistration(aId,iReceiver); |
|
750 if (err != KErrNone) |
|
751 { |
|
752 User::Leave(err); |
|
753 } |
|
754 } |
|
755 |
|
756 // ----------------------------------------------------------------------------- |
|
757 // CSipCSSubSession::ClientReadyToReceiveL |
|
758 // ----------------------------------------------------------------------------- |
|
759 // |
|
760 void CSipCSSubSession::ClientReadyToReceiveL (const RMessage2& aMessage) |
|
761 { |
|
762 iReceiver->ClientReadyToReceiveL(aMessage); |
|
763 } |
|
764 |
|
765 // ----------------------------------------------------------------------------- |
|
766 // CSipCSSubSession::ReceiveSipMessageL |
|
767 // ----------------------------------------------------------------------------- |
|
768 // |
|
769 void CSipCSSubSession::ReceiveSipMessageL (const RMessage2& aMessage) |
|
770 { |
|
771 iReceiver->WriteSipMessageToClientL(aMessage); |
|
772 } |
|
773 |
|
774 // ----------------------------------------------------------------------------- |
|
775 // CSipCSSubSession::CancelClientReceiveL |
|
776 // ----------------------------------------------------------------------------- |
|
777 // |
|
778 void CSipCSSubSession::CancelClientReceiveL () |
|
779 { |
|
780 iReceiver->CancelClientReceiveL(); |
|
781 } |
|
782 |
|
783 // ----------------------------------------------------------------------------- |
|
784 // CSipCSSubSession::GetFromHeaderL |
|
785 // ----------------------------------------------------------------------------- |
|
786 // |
|
787 void CSipCSSubSession::GetFromHeaderL (const TRegistrationId& aId, |
|
788 const RMessage2& aMessage) |
|
789 { |
|
790 CSIPFromHeader* from = Server().RegistrationMgr().CreateFromLC(aId); |
|
791 Server().ITC().WriteL(aMessage,*from); |
|
792 CleanupStack::PopAndDestroy(from); |
|
793 } |
|
794 |
|
795 // ----------------------------------------------------------------------------- |
|
796 // CSipCSSubSession::SetRefreshIntervalL |
|
797 // ----------------------------------------------------------------------------- |
|
798 // |
|
799 void CSipCSSubSession::SetRefreshIntervalL (const TRefreshId& aRefreshId, |
|
800 const RMessage2& aMessage) |
|
801 { |
|
802 TInt interval = 0; |
|
803 Server().ITC().ReadL(aMessage,interval,ESipItcArgRefreshInterval); |
|
804 Server().RefreshMgr().SetIntervalL(aRefreshId,interval); |
|
805 } |
|
806 |
|
807 // ----------------------------------------------------------------------------- |
|
808 // CSipCSSubSession::GetRefreshIntervalL |
|
809 // ----------------------------------------------------------------------------- |
|
810 // |
|
811 void CSipCSSubSession::GetRefreshIntervalL (const TRefreshId& aRefreshId, |
|
812 const RMessage2& aMessage) |
|
813 { |
|
814 TInt interval = Server().RefreshMgr().IntervalL(aRefreshId); |
|
815 Server().ITC().WriteL(aMessage,interval,ESipItcArgRefreshInterval); |
|
816 } |
|
817 |
|
818 // ----------------------------------------------------------------------------- |
|
819 // CSipCSSubSession::GetCallIDHeaderL |
|
820 // ----------------------------------------------------------------------------- |
|
821 // |
|
822 void CSipCSSubSession::GetCallIDHeaderL (const TDialogId& aId, |
|
823 const RMessage2& aMessage) |
|
824 { |
|
825 const CSIPCallIDHeader& callID = |
|
826 Server().DialogMgr().CallIDL(aId,iReceiver); |
|
827 Server().ITC().WriteL(aMessage,callID); |
|
828 } |
|
829 |
|
830 // ----------------------------------------------------------------------------- |
|
831 // CSipCSSubSession::GetLocalTagL |
|
832 // ----------------------------------------------------------------------------- |
|
833 // |
|
834 void CSipCSSubSession::GetLocalTagL (const TDialogId& aId, |
|
835 const RMessage2& aMessage) |
|
836 { |
|
837 const TDesC8& localTag = Server().DialogMgr().LocalTagL(aId,iReceiver); |
|
838 Server().ITC().WriteL(aMessage,localTag,ESipItcArgLocalTag); |
|
839 } |
|
840 |
|
841 // ----------------------------------------------------------------------------- |
|
842 // CSipCSSubSession::GetRegisteredContactL |
|
843 // ----------------------------------------------------------------------------- |
|
844 // |
|
845 void CSipCSSubSession::GetRegisteredContactL (const TRegistrationId& aId, |
|
846 const RMessage2& aMessage) |
|
847 { |
|
848 const CSIPContactHeader* contact = Server().RegistrationMgr().Contact(aId); |
|
849 if (!contact) |
|
850 { |
|
851 User::Leave(KErrNotFound); |
|
852 } |
|
853 Server().ITC().WriteL(aMessage,*contact); |
|
854 } |
|
855 |
|
856 // ----------------------------------------------------------------------------- |
|
857 // CSipCSSubSession::ResetDialogStateL |
|
858 // ----------------------------------------------------------------------------- |
|
859 // |
|
860 void CSipCSSubSession::ResetDialogStateL(const TDialogId& aId) |
|
861 { |
|
862 Server().DialogMgr().ResetStateL(aId,iReceiver); |
|
863 } |
|
864 |
|
865 // ----------------------------------------------------------------------------- |
|
866 // CSipCSSubSession::ITC |
|
867 // ----------------------------------------------------------------------------- |
|
868 // |
|
869 CSipCSServerITC& CSipCSSubSession::ITC () |
|
870 { |
|
871 return iSession.ITC(); |
|
872 } |
|
873 |
|
874 // ----------------------------------------------------------------------------- |
|
875 // CSipCSSubSession::Server |
|
876 // ----------------------------------------------------------------------------- |
|
877 // |
|
878 CSipServerCore& CSipCSSubSession::Server () |
|
879 { |
|
880 return iSession.ServerCore(); |
|
881 } |
|
882 |
|
883 // ----------------------------------------------------------------------------- |
|
884 // CSipCSSubSession::FillRequestLC |
|
885 // ----------------------------------------------------------------------------- |
|
886 // |
|
887 CURIContainer* CSipCSSubSession::FillRequestLC (const RMessage2& aMessage, |
|
888 CSIPRequest& aRequest, |
|
889 TBool aMethodExpected) |
|
890 { |
|
891 TSIPRemoteTargetAndProxy remoteTargetAndProxy; |
|
892 FillRequestL(aMessage,aRequest,remoteTargetAndProxy,aMethodExpected); |
|
893 __SIP_ASSERT_LEAVE(!remoteTargetAndProxy.iProxy, KErrGeneral); |
|
894 CleanupStack::PushL (remoteTargetAndProxy.iRemoteTarget); |
|
895 return remoteTargetAndProxy.iRemoteTarget; |
|
896 } |
|
897 |
|
898 // ----------------------------------------------------------------------------- |
|
899 // CSipCSSubSession::FillRequestL |
|
900 // ----------------------------------------------------------------------------- |
|
901 // |
|
902 void |
|
903 CSipCSSubSession::FillRequestL (const RMessage2& aMessage, |
|
904 CSIPRequest& aRequest, |
|
905 TSIPRemoteTargetAndProxy& aRemoteTargetAndProxy, |
|
906 TBool aMethodExpected, |
|
907 TBool aProxyExpected) |
|
908 { |
|
909 ITC().ReadRequestL (aMessage,aRequest,aRemoteTargetAndProxy, |
|
910 aMethodExpected,aProxyExpected); |
|
911 FillToAndRemoteTargetL (aRequest, aRemoteTargetAndProxy); |
|
912 } |
|
913 |
|
914 // ----------------------------------------------------------------------------- |
|
915 // CSipCSSubSession::OverlappingInDialogAllowed |
|
916 // ----------------------------------------------------------------------------- |
|
917 // |
|
918 TBool CSipCSSubSession::OverlappingInDialogAllowed(RStringF aMethod) |
|
919 { |
|
920 return (aMethod != SIPStrings::StringF(SipStrConsts::EInvite)); |
|
921 } |
|
922 |
|
923 // ----------------------------------------------------------------------------- |
|
924 // CSipCSSubSession::AddFromL |
|
925 // ----------------------------------------------------------------------------- |
|
926 // |
|
927 void CSipCSSubSession::AddFromL (const TRegistrationId& aRegistrationId, |
|
928 CSIPRequest& aRequest) |
|
929 { |
|
930 if (!aRequest.HasHeader(SIPStrings::StringF(SipStrConsts::EFromHeader))) |
|
931 { |
|
932 CSIPFromHeader* from = |
|
933 Server().RegistrationMgr().CreateFromLC(aRegistrationId); |
|
934 aRequest.AddHeaderL(from); |
|
935 CleanupStack::Pop(from); |
|
936 } |
|
937 } |
|
938 |
|
939 // ----------------------------------------------------------------------------- |
|
940 // CSipCSSubSession::AddContactL |
|
941 // ----------------------------------------------------------------------------- |
|
942 // |
|
943 void CSipCSSubSession::AddContactL (const TRegistrationId& aRegistrationId, |
|
944 CSIPMessage& aMessage) |
|
945 { |
|
946 if (!aMessage.HasHeader(SIPStrings::StringF(SipStrConsts::EContactHeader))) |
|
947 { |
|
948 const CSIPContactHeader* contact = |
|
949 Server().RegistrationMgr().Contact(aRegistrationId); |
|
950 if (contact) |
|
951 { |
|
952 CSIPContactHeader* clone = |
|
953 static_cast<CSIPContactHeader*>(contact->CloneL()); |
|
954 CleanupStack::PushL(clone); |
|
955 clone->DeleteParam(SIPStrings::StringF(SipStrConsts::EExpires)); |
|
956 aMessage.AddHeaderL(clone); |
|
957 CleanupStack::Pop(clone); |
|
958 } |
|
959 } |
|
960 } |
|
961 |
|
962 // ----------------------------------------------------------------------------- |
|
963 // CSipCSSubSession::AddRouteL |
|
964 // ----------------------------------------------------------------------------- |
|
965 // |
|
966 void CSipCSSubSession::AddRouteL (const TRegistrationId& aRegistrationId, |
|
967 CSIPRequest& aRequest) |
|
968 { |
|
969 RPointerArray<CSIPRouteHeader> routeSet; |
|
970 CleanupClosePushL(routeSet); |
|
971 // Ask Registrations to add the outbound proxy to the service route |
|
972 // if the application has NOT added a preloaded route |
|
973 TBool addProxy = |
|
974 !(aRequest.HasHeader(SIPStrings::StringF(SipStrConsts::ERouteHeader))); |
|
975 Server().RegistrationMgr().GetRouteL(aRegistrationId,routeSet,addProxy); |
|
976 // Append the route returned by Registrations |
|
977 for (TInt i=0; i < routeSet.Count(); i++) |
|
978 { |
|
979 aRequest.AddHeaderL(*(routeSet[i])); |
|
980 } |
|
981 CleanupStack::PopAndDestroy(); // routeSet |
|
982 } |
|
983 |
|
984 // ----------------------------------------------------------------------------- |
|
985 // CSipCSSubSession::CheckSigCompInNextHopL |
|
986 // ----------------------------------------------------------------------------- |
|
987 // |
|
988 void CSipCSSubSession::CheckSigCompInNextHopL (TRegistrationId aRegistrationId, |
|
989 CURIContainer& aRemoteTarget, |
|
990 CSIPRequest& aRequest) |
|
991 { |
|
992 CSIPHeaderBase* header = |
|
993 aRequest.Header(SIPStrings::StringF(SipStrConsts::ERouteHeader),0); |
|
994 if (header) |
|
995 { |
|
996 CSIPRouteHeader* route = static_cast<CSIPRouteHeader*>(header); |
|
997 if (HasSigCompParameter(route->SIPAddress().URI())) |
|
998 { |
|
999 // First preloaded route exists, is the next hop and |
|
1000 // has comp=sigcomp parameter |
|
1001 User::Leave(KErrArgument); |
|
1002 } |
|
1003 } |
|
1004 else |
|
1005 { |
|
1006 if ((aRegistrationId == KEmptyRegistrationId || |
|
1007 !(Server().Registrations().HasOutboundProxy(aRegistrationId))) && |
|
1008 HasSigCompParameter(aRemoteTarget)) |
|
1009 { |
|
1010 // No outbound proxy. Remote target is the next hop and |
|
1011 // has comp=sigcomp parameter |
|
1012 User::Leave(KErrArgument); |
|
1013 } |
|
1014 } |
|
1015 } |
|
1016 |
|
1017 // ----------------------------------------------------------------------------- |
|
1018 // CSipCSSubSession::FillToAndRemoteTargetL |
|
1019 // ----------------------------------------------------------------------------- |
|
1020 // |
|
1021 void CSipCSSubSession::FillToAndRemoteTargetL ( |
|
1022 CSIPRequest& aRequest, |
|
1023 TSIPRemoteTargetAndProxy& aRemoteTargetAndProxy) |
|
1024 { |
|
1025 if (!aRemoteTargetAndProxy.iRemoteTarget) |
|
1026 { |
|
1027 if (!aRequest.To()) |
|
1028 { |
|
1029 User::Leave(KErrArgument); |
|
1030 } |
|
1031 aRemoteTargetAndProxy.iRemoteTarget = |
|
1032 CURIContainer::NewL(aRequest.To()->SIPAddress().URI()); |
|
1033 } |
|
1034 else |
|
1035 { |
|
1036 if (!aRequest.To()) |
|
1037 { |
|
1038 CURIContainer* uri = |
|
1039 CURIContainer::NewLC(*(aRemoteTargetAndProxy.iRemoteTarget)); |
|
1040 CSIPAddress* sipAddress = SIPCodecUtils::CreateSIPAddressLC(uri); |
|
1041 CleanupStack::Pop(sipAddress); |
|
1042 CleanupStack::Pop(uri); |
|
1043 CleanupStack::PushL(sipAddress); |
|
1044 CSIPToHeader* to = CSIPToHeader::NewL(sipAddress); |
|
1045 CleanupStack::Pop(sipAddress); |
|
1046 CleanupStack::PushL(to); |
|
1047 aRequest.AddHeaderL(to); |
|
1048 CleanupStack::Pop(to); |
|
1049 } |
|
1050 } |
|
1051 } |
|
1052 |
|
1053 // ----------------------------------------------------------------------------- |
|
1054 // CSipCSSubSession::CheckSigCompInContactsL |
|
1055 // ----------------------------------------------------------------------------- |
|
1056 // |
|
1057 void CSipCSSubSession::CheckSigCompInContactsL (CSIPMessage& aMessage) |
|
1058 { |
|
1059 TSglQueIter<CSIPHeaderBase> iter = |
|
1060 aMessage.Headers(SIPStrings::StringF(SipStrConsts::EContactHeader)); |
|
1061 |
|
1062 while (iter) |
|
1063 { |
|
1064 CSIPHeaderBase* header = iter++; |
|
1065 CSIPContactHeader* contact = static_cast<CSIPContactHeader*>(header); |
|
1066 CSIPAddress* sipAddress = contact->SIPAddress(); |
|
1067 if (sipAddress && HasSigCompParameter(sipAddress->URI())) |
|
1068 { |
|
1069 User::Leave(KErrArgument); |
|
1070 } |
|
1071 } |
|
1072 } |
|
1073 |
|
1074 // ----------------------------------------------------------------------------- |
|
1075 // CSipCSSubSession::HasSigCompParameter |
|
1076 // ----------------------------------------------------------------------------- |
|
1077 // |
|
1078 TBool CSipCSSubSession::HasSigCompParameter (CURIContainer& aURI) const |
|
1079 { |
|
1080 |
|
1081 TBool hasSigCompParameter = EFalse; |
|
1082 if (aURI.IsSIPURI()) |
|
1083 { |
|
1084 CSIPURI* sipuri = aURI.SIPURI(); |
|
1085 RStringF comp = SIPStrings::StringF(SipStrConsts::EComp); |
|
1086 RStringF sigcomp = SIPStrings::StringF(SipStrConsts::ESigComp); |
|
1087 hasSigCompParameter = (sipuri->ParamValue(comp) == sigcomp); |
|
1088 } |
|
1089 return hasSigCompParameter; |
|
1090 } |
|
1091 |
|
1092 // ----------------------------------------------------------------------------- |
|
1093 // CSipCSSubSession::RefreshConnection |
|
1094 // ----------------------------------------------------------------------------- |
|
1095 // |
|
1096 void CSipCSSubSession::RefreshConnectionL(TUint32 aIapId) |
|
1097 { |
|
1098 Server().RefreshConnectionL(aIapId); |
|
1099 } |
|
1100 |
|
1101 // ----------------------------------------------------------------------------- |
|
1102 // CSipCSSubSession::GetConnectionErrorL |
|
1103 // ----------------------------------------------------------------------------- |
|
1104 // |
|
1105 void CSipCSSubSession::GetConnectionErrorL(TSIPIds& aIds, const RMessage2& aMessage) |
|
1106 { |
|
1107 Server().GetConnectionErrorL(aIds.iIapId,aIds.iConnectionError); |
|
1108 ITC().WriteL(aMessage,aIds); |
|
1109 } |