|
1 // Copyright (c) 2004-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 : CSIPAllowEventsHeader.cpp |
|
15 // Part of : SIP Codec |
|
16 // Version : SIP/4.0 |
|
17 // |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 #include "sipalloweventsheader.h" |
|
23 #include "CSIPTokenizer.h" |
|
24 #include "sipcodecerr.h" |
|
25 #include "SIPSyntaxCheck.h" |
|
26 #include "sipstrings.h" |
|
27 #include "sipstrconsts.h" |
|
28 #include "sipcodecutils.h" |
|
29 #include "_sipcodecdefs.h" |
|
30 |
|
31 _LIT8(KDot, "."); |
|
32 |
|
33 |
|
34 // ---------------------------------------------------------------------------- |
|
35 // CSIPAllowEventsHeader::DecodeL |
|
36 // ---------------------------------------------------------------------------- |
|
37 // |
|
38 EXPORT_C RPointerArray<CSIPAllowEventsHeader> |
|
39 CSIPAllowEventsHeader::DecodeL (const TDesC8& aValue) |
|
40 { |
|
41 RPointerArray<CSIPHeaderBase> baseheaders = BaseDecodeL(aValue); |
|
42 CSIPHeaderBase::PushLC(&baseheaders); |
|
43 RPointerArray<CSIPAllowEventsHeader> allowHeaders; |
|
44 CleanupClosePushL(allowHeaders); |
|
45 TInt count = baseheaders.Count(); |
|
46 for (TInt i=0; i < count; i++) |
|
47 { |
|
48 CSIPAllowEventsHeader* header = |
|
49 static_cast<CSIPAllowEventsHeader*>(baseheaders[i]); |
|
50 User::LeaveIfError (allowHeaders.Append(header)); |
|
51 } |
|
52 CleanupStack::Pop(2); //allowHeaders, baseheaders |
|
53 baseheaders.Close(); |
|
54 return allowHeaders; |
|
55 } |
|
56 |
|
57 // ---------------------------------------------------------------------------- |
|
58 // CSIPAllowEventsHeader::NewL |
|
59 // ---------------------------------------------------------------------------- |
|
60 // |
|
61 EXPORT_C CSIPAllowEventsHeader* CSIPAllowEventsHeader::NewL( |
|
62 const TDesC8& aEventPackage) |
|
63 { |
|
64 CSIPAllowEventsHeader* self = CSIPAllowEventsHeader::NewLC(aEventPackage); |
|
65 CleanupStack::Pop(self); |
|
66 return self; |
|
67 } |
|
68 |
|
69 // ---------------------------------------------------------------------------- |
|
70 // CSIPEventHeader::NewLC |
|
71 // ---------------------------------------------------------------------------- |
|
72 // |
|
73 EXPORT_C CSIPAllowEventsHeader* CSIPAllowEventsHeader::NewLC( |
|
74 const TDesC8& aEventPackage) |
|
75 { |
|
76 CSIPAllowEventsHeader* self=new(ELeave) CSIPAllowEventsHeader(); |
|
77 CleanupStack::PushL(self); |
|
78 self->ConstructL(aEventPackage); |
|
79 return self; |
|
80 } |
|
81 |
|
82 // ---------------------------------------------------------------------------- |
|
83 // CSIPAllowEventsHeader::CSIPAllowEventsHeader |
|
84 // ---------------------------------------------------------------------------- |
|
85 // |
|
86 CSIPAllowEventsHeader::CSIPAllowEventsHeader() |
|
87 { |
|
88 } |
|
89 |
|
90 // ---------------------------------------------------------------------------- |
|
91 // CSIPAllowEventsHeader::ConstructL |
|
92 // ---------------------------------------------------------------------------- |
|
93 // |
|
94 void CSIPAllowEventsHeader::ConstructL() |
|
95 { |
|
96 iEventTemplates = new(ELeave) CDesC8ArraySeg(1); |
|
97 } |
|
98 |
|
99 // ---------------------------------------------------------------------------- |
|
100 // CSIPAllowEventsHeader::ConstructL |
|
101 // ---------------------------------------------------------------------------- |
|
102 // |
|
103 void CSIPAllowEventsHeader::ConstructL (const TDesC8& aEventPackage) |
|
104 { |
|
105 ConstructL(); |
|
106 SetEventPackageL (aEventPackage); |
|
107 } |
|
108 |
|
109 // ---------------------------------------------------------------------------- |
|
110 // CSIPAllowEventsHeader::ConstructL |
|
111 // ---------------------------------------------------------------------------- |
|
112 // |
|
113 void |
|
114 CSIPAllowEventsHeader::ConstructL (const CSIPAllowEventsHeader& |
|
115 aSIPAllowEventsHeader) |
|
116 { |
|
117 SetEventTemplatesL(*aSIPAllowEventsHeader.iEventTemplates); |
|
118 SetEventPackageL(aSIPAllowEventsHeader.EventPackage()); |
|
119 } |
|
120 |
|
121 // ---------------------------------------------------------------------------- |
|
122 // CSIPAllowEventsHeader::~CSIPAllowEventsHeader |
|
123 // ---------------------------------------------------------------------------- |
|
124 // |
|
125 EXPORT_C CSIPAllowEventsHeader::~CSIPAllowEventsHeader() |
|
126 { |
|
127 delete iEventTemplates; |
|
128 delete iEventPackage; |
|
129 } |
|
130 |
|
131 // ---------------------------------------------------------------------------- |
|
132 // CSIPAllowEventsHeader::CloneL |
|
133 // From CSIPHeaderBase: |
|
134 // ---------------------------------------------------------------------------- |
|
135 // |
|
136 EXPORT_C CSIPHeaderBase* CSIPAllowEventsHeader::CloneL () const |
|
137 { |
|
138 CSIPAllowEventsHeader* clone = new (ELeave) CSIPAllowEventsHeader; |
|
139 CleanupStack::PushL(clone); |
|
140 clone->ConstructL(*this); |
|
141 CleanupStack::Pop(clone); |
|
142 return clone; |
|
143 } |
|
144 |
|
145 // ---------------------------------------------------------------------------- |
|
146 // CSIPAllowEventsHeader::Name |
|
147 // From CSIPHeaderBase: |
|
148 // ---------------------------------------------------------------------------- |
|
149 // |
|
150 EXPORT_C RStringF CSIPAllowEventsHeader::Name () const |
|
151 { |
|
152 return SIPStrings::StringF(SipStrConsts::EAllowEventsHeader); |
|
153 } |
|
154 |
|
155 // ---------------------------------------------------------------------------- |
|
156 // CSIPAllowEventsHeader::HasCompactName |
|
157 // From CSIPHeaderBase: |
|
158 // ---------------------------------------------------------------------------- |
|
159 // |
|
160 TBool CSIPAllowEventsHeader::HasCompactName () const |
|
161 { |
|
162 return ETrue; |
|
163 } |
|
164 |
|
165 // ---------------------------------------------------------------------------- |
|
166 // CSIPAllowEventsHeader::CompactName |
|
167 // From CSIPHeaderBase: |
|
168 // ---------------------------------------------------------------------------- |
|
169 // |
|
170 RStringF CSIPAllowEventsHeader::CompactName () const |
|
171 { |
|
172 return SIPStrings::StringF(SipStrConsts::EAllowEventsHeaderCompact); |
|
173 } |
|
174 |
|
175 // ---------------------------------------------------------------------------- |
|
176 // CSIPAllowEventsHeader::SetEventPackageL |
|
177 // ---------------------------------------------------------------------------- |
|
178 // |
|
179 EXPORT_C void |
|
180 CSIPAllowEventsHeader::SetEventPackageL (const TDesC8& aEventPackage) |
|
181 { |
|
182 HBufC8* tmp = aEventPackage.AllocLC(); |
|
183 tmp->Des().Trim(); |
|
184 if (!SIPSyntaxCheck::Token(*tmp) || (tmp->Find(KDot) != KErrNotFound)) |
|
185 { |
|
186 User::Leave(KErrSipCodecAllowEventsHeader); |
|
187 } |
|
188 CleanupStack::Pop(tmp); |
|
189 delete iEventPackage; |
|
190 iEventPackage = tmp; |
|
191 } |
|
192 |
|
193 // ---------------------------------------------------------------------------- |
|
194 // CSIPAllowEventsHeader::EventPackage |
|
195 // ---------------------------------------------------------------------------- |
|
196 // |
|
197 EXPORT_C const TDesC8& CSIPAllowEventsHeader::EventPackage() const |
|
198 { |
|
199 return *iEventPackage; |
|
200 } |
|
201 |
|
202 // ---------------------------------------------------------------------------- |
|
203 // CSIPAllowEventsHeader::SetEventTemplatesL |
|
204 // ---------------------------------------------------------------------------- |
|
205 // |
|
206 EXPORT_C void CSIPAllowEventsHeader::SetEventTemplatesL( |
|
207 const MDesC8Array& aEventTemplates) |
|
208 { |
|
209 CDesC8ArraySeg* eventTemplates = new(ELeave) CDesC8ArraySeg(1); |
|
210 CleanupStack::PushL(eventTemplates); |
|
211 for (TInt i=0; i < aEventTemplates.MdcaCount(); i++) |
|
212 { |
|
213 CheckTemplateL(aEventTemplates.MdcaPoint(i)); |
|
214 eventTemplates->AppendL(aEventTemplates.MdcaPoint(i)); |
|
215 } |
|
216 CleanupStack::Pop(eventTemplates); |
|
217 delete iEventTemplates; |
|
218 iEventTemplates = eventTemplates; |
|
219 } |
|
220 |
|
221 // ---------------------------------------------------------------------------- |
|
222 // CSIPAllowEventsHeader::EventTemplates |
|
223 // ---------------------------------------------------------------------------- |
|
224 // |
|
225 EXPORT_C const MDesC8Array& CSIPAllowEventsHeader::EventTemplates () const |
|
226 { |
|
227 return *iEventTemplates; |
|
228 } |
|
229 |
|
230 // ---------------------------------------------------------------------------- |
|
231 // CSIPAllowEventsHeader::MoreThanOneAllowed |
|
232 // From CSIPHeaderBase: |
|
233 // ---------------------------------------------------------------------------- |
|
234 // |
|
235 TBool CSIPAllowEventsHeader::MoreThanOneAllowed () const |
|
236 { |
|
237 return ETrue; |
|
238 } |
|
239 |
|
240 // ---------------------------------------------------------------------------- |
|
241 // CSIPAllowEventsHeader::CheckTemplateL |
|
242 // ---------------------------------------------------------------------------- |
|
243 // |
|
244 void CSIPAllowEventsHeader::CheckTemplateL (const TDesC8& aParam) const |
|
245 { |
|
246 // event-template Param |
|
247 if (!SIPSyntaxCheck::Token(aParam) || |
|
248 ((aParam).Find(KDot) != KErrNotFound)) |
|
249 { |
|
250 User::Leave(KErrSipCodecAllowEventsHeader); |
|
251 } |
|
252 } |
|
253 |
|
254 // ---------------------------------------------------------------------------- |
|
255 // CSIPAllowEventsHeader::ToTextValueL |
|
256 // From CSIPHeaderBase: |
|
257 // ---------------------------------------------------------------------------- |
|
258 // |
|
259 EXPORT_C HBufC8* CSIPAllowEventsHeader::ToTextValueL () const |
|
260 { |
|
261 TUint encodedLength = 0; |
|
262 RPointerArray<HBufC8> templatesAsText; |
|
263 CleanupStack::PushL (TCleanupItem(ResetAndDestroy,&templatesAsText)); |
|
264 |
|
265 encodedLength += iEventPackage->Length(); |
|
266 for (TInt i=0; i < iEventTemplates->MdcaCount(); i++) |
|
267 { |
|
268 HBufC8* templateAsText = (iEventTemplates->MdcaPoint(i)).AllocLC(); |
|
269 encodedLength += templateAsText->Length() + 1;// param separator length |
|
270 User::LeaveIfError (templatesAsText.Append(templateAsText)); |
|
271 CleanupStack::Pop(templateAsText); |
|
272 } |
|
273 |
|
274 HBufC8* encodedHeader = HBufC8::NewL (encodedLength); |
|
275 TPtr8 encodedHeaderPtr = encodedHeader->Des(); |
|
276 |
|
277 encodedHeaderPtr.Append(*iEventPackage); |
|
278 |
|
279 for (TInt j=0; j < templatesAsText.Count(); j++) |
|
280 { |
|
281 encodedHeaderPtr.Append('.'); // dot |
|
282 encodedHeaderPtr.Append (*templatesAsText[j]); |
|
283 } |
|
284 |
|
285 CleanupStack::PopAndDestroy(); // templatesAsText |
|
286 return encodedHeader; |
|
287 } |
|
288 |
|
289 // ---------------------------------------------------------------------------- |
|
290 // CSIPAllowEventsHeader::InternalizeValueL |
|
291 // ---------------------------------------------------------------------------- |
|
292 // |
|
293 EXPORT_C CSIPHeaderBase* CSIPAllowEventsHeader::InternalizeValueL ( |
|
294 RReadStream& aReadStream) |
|
295 { |
|
296 CSIPAllowEventsHeader* self = new(ELeave)CSIPAllowEventsHeader; |
|
297 CleanupStack::PushL(self); |
|
298 self->ConstructL(); |
|
299 self->DoInternalizeValueL(aReadStream); |
|
300 CleanupStack::Pop(self); |
|
301 return self; |
|
302 } |
|
303 |
|
304 // ---------------------------------------------------------------------------- |
|
305 // CSIPAllowEventsHeader::DoInternalizeValueL |
|
306 // ---------------------------------------------------------------------------- |
|
307 // |
|
308 void CSIPAllowEventsHeader::DoInternalizeValueL (RReadStream& aReadStream) |
|
309 { |
|
310 iEventPackage = SIPCodecUtils::ReadDescFromStreamL(aReadStream); |
|
311 |
|
312 TUint32 templateCount = aReadStream.ReadUint32L(); |
|
313 |
|
314 for (TUint32 i=0; i < templateCount; i++) |
|
315 { |
|
316 HBufC8* value = SIPCodecUtils::ReadDescFromStreamL(aReadStream); |
|
317 CleanupStack::PushL(value); |
|
318 iEventTemplates->AppendL(*value); |
|
319 CleanupStack::PopAndDestroy(value); |
|
320 } |
|
321 } |
|
322 |
|
323 // ---------------------------------------------------------------------------- |
|
324 // CSIPAllowEventsHeader::ExternalizeValueL |
|
325 // From CSIPHeaderBase: |
|
326 // ---------------------------------------------------------------------------- |
|
327 // |
|
328 void |
|
329 CSIPAllowEventsHeader::ExternalizeValueL (RWriteStream& aWriteStream) const |
|
330 { |
|
331 aWriteStream.WriteUint32L (iEventPackage->Length()); |
|
332 if (iEventPackage->Length() > 0) |
|
333 { |
|
334 aWriteStream.WriteL (this->EventPackage()); |
|
335 } |
|
336 aWriteStream.WriteUint32L (iEventTemplates->MdcaCount()); |
|
337 for (TInt i=0; i < iEventTemplates->MdcaCount(); i++) |
|
338 { |
|
339 aWriteStream.WriteUint32L (iEventTemplates->MdcaPoint(i).Length()); |
|
340 aWriteStream.WriteL (iEventTemplates->MdcaPoint(i)); |
|
341 } |
|
342 } |
|
343 |
|
344 // ---------------------------------------------------------------------------- |
|
345 // CSIPAllowEventsHeader::PreferredPlaceInMessage |
|
346 // From CSIPHeaderBase: |
|
347 // ---------------------------------------------------------------------------- |
|
348 // |
|
349 CSIPHeaderBase::TPreferredPlace |
|
350 CSIPAllowEventsHeader::PreferredPlaceInMessage () const |
|
351 { |
|
352 return CSIPHeaderBase::EBottom; |
|
353 } |
|
354 |
|
355 // ---------------------------------------------------------------------------- |
|
356 // CSIPAllowEventsHeader::BaseDecodeL |
|
357 // ---------------------------------------------------------------------------- |
|
358 // |
|
359 RPointerArray<CSIPHeaderBase> CSIPAllowEventsHeader::BaseDecodeL ( |
|
360 const TDesC8& aValue) |
|
361 { |
|
362 __ASSERT_ALWAYS (aValue.Length() > 0, |
|
363 User::Leave(KErrSipCodecAllowEventsHeader)); |
|
364 |
|
365 RPointerArray<CSIPHeaderBase> headers; |
|
366 CSIPHeaderBase::PushLC(&headers); |
|
367 CSIPTokenizer* tokenizer = CSIPTokenizer::NewLC(aValue, ','); |
|
368 for (TInt i=0; i < tokenizer->Tokens().Count(); i++) |
|
369 { |
|
370 CSIPAllowEventsHeader* allowEventsHeader = |
|
371 new (ELeave) CSIPAllowEventsHeader; |
|
372 CleanupStack::PushL(allowEventsHeader); |
|
373 allowEventsHeader->ConstructL(); |
|
374 allowEventsHeader->ParseL (tokenizer->Tokens()[i]); |
|
375 User::LeaveIfError (headers.Append(allowEventsHeader)); |
|
376 CleanupStack::Pop(); // allowEventsHeader |
|
377 } |
|
378 CleanupStack::PopAndDestroy(tokenizer); |
|
379 CleanupStack::Pop(); // headers |
|
380 return headers; |
|
381 } |
|
382 |
|
383 // ---------------------------------------------------------------------------- |
|
384 // CSIPAllowEventsHeader::ParseL |
|
385 // ---------------------------------------------------------------------------- |
|
386 // |
|
387 void CSIPAllowEventsHeader::ParseL (const TDesC8& aValue) |
|
388 { |
|
389 __ASSERT_ALWAYS (aValue.Length() > 0, |
|
390 User::Leave (KErrSipCodecAllowEventsHeader)); |
|
391 HBufC8* tmp = aValue.AllocLC(); |
|
392 tmp->Des().Trim(); |
|
393 |
|
394 CSIPTokenizer* tokenizer = CSIPTokenizer::NewLC(*tmp, '.'); |
|
395 TLex8 lex(tokenizer->Tokens()[0]); |
|
396 lex.SkipSpace(); |
|
397 this->SetEventPackageL(lex.Remainder()); |
|
398 |
|
399 for (TInt j=1; j < tokenizer->Tokens().Count(); j++) |
|
400 { |
|
401 CheckTemplateL((tokenizer->Tokens()[j])); |
|
402 iEventTemplates->AppendL((tokenizer->Tokens()[j])); |
|
403 } |
|
404 |
|
405 CleanupStack::PopAndDestroy(tokenizer); |
|
406 CleanupStack::PopAndDestroy(tmp); |
|
407 } |
|
408 |
|
409 // ---------------------------------------------------------------------------- |
|
410 // CSIPAllowEventsHeader::ResetAndDestroy |
|
411 // ---------------------------------------------------------------------------- |
|
412 // |
|
413 void CSIPAllowEventsHeader::ResetAndDestroy (TAny* anArray) |
|
414 { |
|
415 (reinterpret_cast<RPointerArray<HBufC8>*> (anArray))->ResetAndDestroy(); |
|
416 } |