|
1 // Copyright (c) 2005-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 : CSIPITCSender.cpp |
|
15 // Part of : SIPClient |
|
16 // Version : SIP/4.0 |
|
17 // |
|
18 |
|
19 |
|
20 |
|
21 #include "CSIPITCSender.h" |
|
22 #include "MSIPITC.h" |
|
23 #include "sipmessageelements.h" |
|
24 #include "siprequestelements.h" |
|
25 #include "sipresponseelements.h" |
|
26 #include "siptoheader.h" |
|
27 #include "sipfromheader.h" |
|
28 #include "uricontainer.h" |
|
29 #include "siprouteheader.h" |
|
30 #include "sipcallidheader.h" |
|
31 #include "SIPHeaderLookup.h" |
|
32 #include "sipstrings.h" |
|
33 #include "sipstrconsts.h" |
|
34 |
|
35 const TInt KMaxHeaderSizeInReadStream = 300; |
|
36 const TInt KMaxTagLength = 100; |
|
37 const TInt KExternalizeBufferExpandSize = 100; |
|
38 |
|
39 |
|
40 // ----------------------------------------------------------------------------- |
|
41 // CSIPITCSender::NewL |
|
42 // ----------------------------------------------------------------------------- |
|
43 // |
|
44 CSIPITCSender* CSIPITCSender::NewL (MSIPITC& aITC) |
|
45 { |
|
46 CSIPITCSender* self = CSIPITCSender::NewLC(aITC); |
|
47 CleanupStack::Pop (self); |
|
48 return self; |
|
49 } |
|
50 |
|
51 // ----------------------------------------------------------------------------- |
|
52 // CSIPITCSender::NewLC |
|
53 // ----------------------------------------------------------------------------- |
|
54 // |
|
55 CSIPITCSender* CSIPITCSender::NewLC (MSIPITC& aITC) |
|
56 { |
|
57 CSIPITCSender* self = new(ELeave)CSIPITCSender(aITC); |
|
58 CleanupStack::PushL (self); |
|
59 self->ConstructL (); |
|
60 return self; |
|
61 } |
|
62 |
|
63 // ----------------------------------------------------------------------------- |
|
64 // CSIPITCSender::CSIPITCSender |
|
65 // ----------------------------------------------------------------------------- |
|
66 // |
|
67 CSIPITCSender::CSIPITCSender (MSIPITC& aITC) |
|
68 : iITC (aITC), |
|
69 iLookupOpened (EFalse) |
|
70 { |
|
71 } |
|
72 |
|
73 // ----------------------------------------------------------------------------- |
|
74 // CSIPITCSender::ConstructL |
|
75 // ----------------------------------------------------------------------------- |
|
76 // |
|
77 void CSIPITCSender::ConstructL () |
|
78 { |
|
79 SIPHeaderLookup::OpenL(); |
|
80 iLookupOpened = ETrue; |
|
81 } |
|
82 |
|
83 // ----------------------------------------------------------------------------- |
|
84 // CSIPITCSender::~CSIPITCSender |
|
85 // ----------------------------------------------------------------------------- |
|
86 // |
|
87 CSIPITCSender::~CSIPITCSender () |
|
88 { |
|
89 if (iLookupOpened) |
|
90 { |
|
91 SIPHeaderLookup::Close(); |
|
92 } |
|
93 } |
|
94 |
|
95 // ----------------------------------------------------------------------------- |
|
96 // CSIPITCSender::Send |
|
97 // ----------------------------------------------------------------------------- |
|
98 // |
|
99 TInt CSIPITCSender::Send (TSIPIds& aIds, TSipItcFunctions aITCFunction) |
|
100 { |
|
101 TPckgBuf<TSIPIds> sipIdsPckg(aIds); |
|
102 iITCMsgArgs.Set (ESipItcArgIds, &sipIdsPckg); |
|
103 |
|
104 TInt err = iITC.Send(aITCFunction,iITCMsgArgs); |
|
105 aIds = sipIdsPckg(); |
|
106 return err; |
|
107 } |
|
108 |
|
109 // ----------------------------------------------------------------------------- |
|
110 // CSIPITCSender::SendL |
|
111 // ----------------------------------------------------------------------------- |
|
112 // |
|
113 void CSIPITCSender::SendL (TSIPIds& aIds, TSipItcFunctions aITCFunction) |
|
114 { |
|
115 TInt err = Send(aIds,aITCFunction); |
|
116 if (err != KErrNone) |
|
117 { |
|
118 User::Leave(err); |
|
119 } |
|
120 } |
|
121 |
|
122 // ----------------------------------------------------------------------------- |
|
123 // CSIPITCSender::SendL |
|
124 // ----------------------------------------------------------------------------- |
|
125 // |
|
126 void CSIPITCSender::SendL (TSIPIds& aIds, |
|
127 TSipItcFunctions aITCFunction, |
|
128 const CSIPRequestElements& aElements) |
|
129 { |
|
130 Mem::FillZ(&iITCMsgArgs, sizeof(iITCMsgArgs)); |
|
131 CBufFlat* buf = ExternalizeLC (aElements); |
|
132 TPtr8 externalizedHeaders = buf->Ptr(0); |
|
133 iITCMsgArgs.Set (ESipItcArgMessageHeaders, &externalizedHeaders); |
|
134 |
|
135 SetContentToSend (aElements.MessageElements()); |
|
136 SendL (aIds,aITCFunction); |
|
137 CleanupStack::PopAndDestroy(buf); |
|
138 } |
|
139 |
|
140 // ----------------------------------------------------------------------------- |
|
141 // CSIPITCSender::SendL |
|
142 // ----------------------------------------------------------------------------- |
|
143 // |
|
144 void CSIPITCSender::SendL (TSIPIds& aIds, |
|
145 TSipItcFunctions aITCFunction, |
|
146 RStringF aMethod, |
|
147 const CUri8* aRemoteUri, |
|
148 const CSIPFromHeader* aFrom, |
|
149 const CSIPToHeader* aTo, |
|
150 const CSIPMessageElements* aElements, |
|
151 const CSIPRouteHeader* aOutboundProxy) |
|
152 { |
|
153 Mem::FillZ(&iITCMsgArgs, sizeof(iITCMsgArgs)); |
|
154 CBufFlat* buf = CBufFlat::NewL(KExternalizeBufferExpandSize); |
|
155 CleanupStack::PushL(buf); |
|
156 RBufWriteStream writeStream(*buf,0); |
|
157 writeStream.PushL(); |
|
158 ExternalizeL(aMethod,writeStream); |
|
159 if (aRemoteUri) |
|
160 { |
|
161 writeStream.WriteUint8L(1); // remote uri present |
|
162 TPtrC8 uri(aRemoteUri->Uri().UriDes()); |
|
163 writeStream.WriteUint32L(uri.Length()); |
|
164 writeStream.WriteL(uri); |
|
165 } |
|
166 else |
|
167 { |
|
168 writeStream.WriteUint8L(0); // remote not uri present |
|
169 } |
|
170 if (aOutboundProxy) |
|
171 { |
|
172 aOutboundProxy->ExternalizeL(writeStream,EFalse); |
|
173 } |
|
174 if (aFrom) |
|
175 { |
|
176 ExternalizeL(aFrom,writeStream); |
|
177 } |
|
178 if (aTo) |
|
179 { |
|
180 ExternalizeL(aTo,writeStream); |
|
181 } |
|
182 ExternalizeL(aElements,writeStream,EFalse); |
|
183 writeStream.Pop(); |
|
184 writeStream.Close(); |
|
185 TPtr8 externalizedHeaders = buf->Ptr(0); |
|
186 iITCMsgArgs.Set(ESipItcArgMessageHeaders,&externalizedHeaders); |
|
187 |
|
188 SetContentToSend (aElements); |
|
189 SendL (aIds,aITCFunction); |
|
190 CleanupStack::PopAndDestroy(buf); |
|
191 } |
|
192 |
|
193 // ----------------------------------------------------------------------------- |
|
194 // CSIPITCSender::SendL |
|
195 // ----------------------------------------------------------------------------- |
|
196 // |
|
197 void CSIPITCSender::SendL (TSIPIds& aIds, |
|
198 TSipItcFunctions aITCFunction, |
|
199 const CSIPMessageElements* aElements) |
|
200 { |
|
201 Mem::FillZ(&iITCMsgArgs, sizeof(iITCMsgArgs)); |
|
202 SetContentToSend (aElements); |
|
203 if (aElements != 0) |
|
204 { |
|
205 CBufFlat* buf = ExternalizeLC (*aElements); |
|
206 TPtr8 externalizedHeaders = buf->Ptr(0); |
|
207 iITCMsgArgs.Set (ESipItcArgMessageHeaders, &externalizedHeaders); |
|
208 SendL(aIds,aITCFunction); |
|
209 CleanupStack::PopAndDestroy(buf); |
|
210 } |
|
211 else |
|
212 { |
|
213 TBuf8<1> emptyBuf; |
|
214 iITCMsgArgs.Set (ESipItcArgMessageHeaders, &emptyBuf); |
|
215 SendL(aIds,aITCFunction); |
|
216 } |
|
217 } |
|
218 |
|
219 // ----------------------------------------------------------------------------- |
|
220 // CSIPITCSender::SendL |
|
221 // ----------------------------------------------------------------------------- |
|
222 // |
|
223 void CSIPITCSender::SendL (TSIPIds& aIds, |
|
224 TSipItcFunctions aITCFunction, |
|
225 RStringF aMethod, |
|
226 const CSIPMessageElements* aElements) |
|
227 { |
|
228 Mem::FillZ(&iITCMsgArgs, sizeof(iITCMsgArgs)); |
|
229 SetContentToSend (aElements); |
|
230 CBufFlat* buf = CBufFlat::NewL(KExternalizeBufferExpandSize); |
|
231 CleanupStack::PushL(buf); |
|
232 RBufWriteStream writeStream(*buf,0); |
|
233 writeStream.PushL(); |
|
234 ExternalizeL(aMethod,writeStream); |
|
235 ExternalizeL (aElements,writeStream,EFalse); |
|
236 TPtr8 bufPtr = buf->Ptr(0); |
|
237 iITCMsgArgs.Set (ESipItcArgMessageHeaders, &bufPtr); |
|
238 SendL(aIds,aITCFunction); |
|
239 writeStream.Pop(); |
|
240 writeStream.Close(); |
|
241 CleanupStack::PopAndDestroy(buf); |
|
242 } |
|
243 |
|
244 // ----------------------------------------------------------------------------- |
|
245 // CSIPITCSender::SendL |
|
246 // ----------------------------------------------------------------------------- |
|
247 // |
|
248 void CSIPITCSender::SendL (TSIPIds& aIds, |
|
249 TSipItcFunctions aITCFunction, |
|
250 const CSIPResponseElements& aElements) |
|
251 { |
|
252 Mem::FillZ(&iITCMsgArgs, sizeof(iITCMsgArgs)); |
|
253 CBufFlat* buf = ExternalizeLC (aElements); |
|
254 TPtr8 externalizedHeaders = buf->Ptr(0); |
|
255 iITCMsgArgs.Set (ESipItcArgMessageHeaders, &externalizedHeaders); |
|
256 |
|
257 SetContentToSend (aElements.MessageElements()); |
|
258 SendL (aIds,aITCFunction); |
|
259 CleanupStack::PopAndDestroy(buf); |
|
260 } |
|
261 |
|
262 // ----------------------------------------------------------------------------- |
|
263 // CSIPITCSender::OutboundProxyL |
|
264 // ----------------------------------------------------------------------------- |
|
265 // |
|
266 void CSIPITCSender::SetOutboundProxyL (TSIPIds& aIds, |
|
267 const CSIPRouteHeader& aOutboundProxy) |
|
268 { |
|
269 CBufFlat* buf = CBufFlat::NewL(KExternalizeBufferExpandSize); |
|
270 CleanupStack::PushL(buf); |
|
271 RBufWriteStream writeStream(*buf,0); |
|
272 writeStream.PushL(); |
|
273 aOutboundProxy.ExternalizeL(writeStream,EFalse); |
|
274 writeStream.Pop(); |
|
275 writeStream.Close(); |
|
276 TPtr8 externalizedProxy = buf->Ptr(0); |
|
277 iITCMsgArgs.Set (ESipItcArgMessageHeaders, &externalizedProxy); |
|
278 SendL (aIds,ESipItcSetOutboundProxy); |
|
279 CleanupStack::PopAndDestroy(buf); |
|
280 } |
|
281 |
|
282 // ----------------------------------------------------------------------------- |
|
283 // CSIPITCSender::ReadSIPHeaderL |
|
284 // ----------------------------------------------------------------------------- |
|
285 // |
|
286 CSIPHeaderBase* CSIPITCSender::ReadSIPHeaderL (TSIPIds& aIds, |
|
287 TSipItcFunctions aITCFunction, |
|
288 RStringF aHeaderName) |
|
289 { |
|
290 Mem::FillZ(&iITCMsgArgs, sizeof(iITCMsgArgs)); |
|
291 HBufC8* headerBuf = HBufC8::NewLC(KMaxHeaderSizeInReadStream); |
|
292 TPtr8 headerBufPtr = headerBuf->Des(); |
|
293 iITCMsgArgs.Set (ESipItcArgMessageHeaders, &headerBufPtr); |
|
294 SendL (aIds,aITCFunction); |
|
295 CSIPHeaderBase* header = InternalizeL(aHeaderName, headerBufPtr); |
|
296 CleanupStack::PopAndDestroy(headerBuf); |
|
297 return header; |
|
298 } |
|
299 |
|
300 // ----------------------------------------------------------------------------- |
|
301 // CSIPITCSender::ReadCallIDHeaderL |
|
302 // ----------------------------------------------------------------------------- |
|
303 // |
|
304 CSIPCallIDHeader* CSIPITCSender::ReadCallIDHeaderL(TSIPIds& aIds) |
|
305 { |
|
306 Mem::FillZ(&iITCMsgArgs, sizeof(iITCMsgArgs)); |
|
307 HBufC8* headerBuf = HBufC8::NewLC(KMaxHeaderSizeInReadStream); |
|
308 TPtr8 headerBufPtr = headerBuf->Des(); |
|
309 iITCMsgArgs.Set (ESipItcArgMessageHeaders, &headerBufPtr); |
|
310 SendL (aIds,ESipItcGetCallIDHeader); |
|
311 RDesReadStream readStream(headerBufPtr); |
|
312 readStream.PushL(); |
|
313 CSIPCallIDHeader* callID = NULL; |
|
314 if (headerBufPtr.Length() > 0) |
|
315 { |
|
316 callID = static_cast<CSIPCallIDHeader*>( |
|
317 CSIPCallIDHeader::InternalizeValueL(readStream)); |
|
318 } |
|
319 readStream.Pop(); |
|
320 readStream.Close(); |
|
321 CleanupStack::PopAndDestroy(headerBuf); |
|
322 return callID; |
|
323 } |
|
324 |
|
325 // ----------------------------------------------------------------------------- |
|
326 // CSIPITCSender::ReadLocalTagL |
|
327 // ----------------------------------------------------------------------------- |
|
328 // |
|
329 RStringF CSIPITCSender::ReadLocalTagL(TSIPIds& aIds) |
|
330 { |
|
331 Mem::FillZ(&iITCMsgArgs, sizeof(iITCMsgArgs)); |
|
332 HBufC8* localTagBuf = HBufC8::NewLC(KMaxTagLength); |
|
333 TPtr8 localTagBufPtr = localTagBuf->Des(); |
|
334 iITCMsgArgs.Set(ESipItcArgLocalTag, &localTagBufPtr); |
|
335 SendL(aIds,ESipItcGetLocalTag); |
|
336 RStringF localTag = SIPStrings::Pool().OpenFStringL(localTagBufPtr); |
|
337 CleanupStack::PopAndDestroy(localTagBuf); |
|
338 return localTag; |
|
339 } |
|
340 |
|
341 // ----------------------------------------------------------------------------- |
|
342 // CSIPITCSender::SetRefreshIntervalL |
|
343 // ----------------------------------------------------------------------------- |
|
344 // |
|
345 void CSIPITCSender::SetRefreshIntervalL (TSIPIds& aIds, TInt aInterval) |
|
346 { |
|
347 iITCMsgArgs.Set(ESipItcArgRefreshInterval, aInterval); |
|
348 SendL(aIds,ESipItcSetRefreshInterval); |
|
349 } |
|
350 |
|
351 // ----------------------------------------------------------------------------- |
|
352 // CSIPITCSender::GetRefreshIntervalL |
|
353 // ----------------------------------------------------------------------------- |
|
354 // |
|
355 void CSIPITCSender::GetRefreshIntervalL (TSIPIds& aIds, TInt& aInterval) |
|
356 { |
|
357 TPckgBuf<TInt> intervalPckg(0); |
|
358 iITCMsgArgs.Set(ESipItcArgRefreshInterval, &intervalPckg); |
|
359 SendL (aIds,ESipItcGetRefreshInterval); |
|
360 aInterval = intervalPckg(); |
|
361 } |
|
362 |
|
363 // ----------------------------------------------------------------------------- |
|
364 // CSIPITCSender::SetContentToSend |
|
365 // ----------------------------------------------------------------------------- |
|
366 // |
|
367 void CSIPITCSender::SetContentToSend (const CSIPMessageElements* aElements) |
|
368 { |
|
369 if (aElements != 0) |
|
370 { |
|
371 SetContentToSend(*aElements); |
|
372 } |
|
373 else |
|
374 { |
|
375 iITCMsgArgs.Set (ESipItcArgMessageContent, &iEmptyContent); |
|
376 } |
|
377 } |
|
378 |
|
379 // ----------------------------------------------------------------------------- |
|
380 // CSIPITCSender::SetContentToSend |
|
381 // ----------------------------------------------------------------------------- |
|
382 // |
|
383 void CSIPITCSender::SetContentToSend (const CSIPMessageElements& aElements) |
|
384 { |
|
385 iITCMsgArgs.Set (ESipItcArgMessageContent, &(aElements.Content())); |
|
386 } |
|
387 |
|
388 // ----------------------------------------------------------------------------- |
|
389 // CSIPITCSender::ExternalizeLC |
|
390 // ----------------------------------------------------------------------------- |
|
391 // |
|
392 template<class T> CBufFlat* CSIPITCSender::ExternalizeLC (const T& aElements) |
|
393 { |
|
394 CBufFlat* buf = CBufFlat::NewL(KExternalizeBufferExpandSize); |
|
395 CleanupStack::PushL(buf); |
|
396 RBufWriteStream writeStream(*buf,0); |
|
397 writeStream.PushL(); |
|
398 aElements.ExternalizeL(writeStream); |
|
399 writeStream.Pop(); |
|
400 writeStream.Close(); |
|
401 return buf; |
|
402 } |
|
403 |
|
404 // ----------------------------------------------------------------------------- |
|
405 // CSIPITCSender::ExternalizeL |
|
406 // ----------------------------------------------------------------------------- |
|
407 // |
|
408 template<class T> void CSIPITCSender::ExternalizeL (const T* aElement, |
|
409 RWriteStream& aWriteStream, |
|
410 TBool aAddExpectedFlag) |
|
411 { |
|
412 if (aElement) |
|
413 { |
|
414 if (aAddExpectedFlag) |
|
415 { |
|
416 aWriteStream.WriteUint8L(1); // element expected flag |
|
417 } |
|
418 aElement->ExternalizeL(aWriteStream); |
|
419 } |
|
420 else |
|
421 { |
|
422 aWriteStream.WriteUint8L(0); // element not expected flag |
|
423 } |
|
424 } |
|
425 |
|
426 // ----------------------------------------------------------------------------- |
|
427 // CSIPITCSender::ExternalizeL |
|
428 // ----------------------------------------------------------------------------- |
|
429 // |
|
430 void CSIPITCSender::ExternalizeL (RStringF aStr, RWriteStream& aWriteStream) |
|
431 { |
|
432 TPtrC8 des(aStr.DesC()); |
|
433 if (des.Length() > 0) |
|
434 { |
|
435 aWriteStream.WriteUint32L(des.Length()); |
|
436 aWriteStream.WriteL(des); |
|
437 } |
|
438 } |
|
439 |
|
440 // ----------------------------------------------------------------------------- |
|
441 // CSIPITCSender::InternalizeL |
|
442 // ----------------------------------------------------------------------------- |
|
443 // |
|
444 CSIPHeaderBase* CSIPITCSender::InternalizeL (RStringF aName, TDes8& aDes) |
|
445 { |
|
446 CSIPHeaderBase* header = NULL; |
|
447 if (aDes.Length() > 0) |
|
448 { |
|
449 RDesReadStream readStream(aDes); |
|
450 readStream.PushL(); |
|
451 header = SIPHeaderLookup::InternalizeL(aName,readStream); |
|
452 readStream.Pop(); |
|
453 readStream.Close(); |
|
454 } |
|
455 return header; |
|
456 } |