|
1 /* |
|
2 * Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 |
|
23 |
|
24 |
|
25 |
|
26 |
|
27 |
|
28 // INCLUDE FILES |
|
29 #include "seninternalcredential.h" |
|
30 #include "SenFacet.h" |
|
31 #include <SenXmlElement.h> // check if this include is needed(?) |
|
32 #include "senwsdescription.h" |
|
33 #include "SenDateUtils.h" |
|
34 #include <SenIdentityProvider.h> |
|
35 #include "senlogger.h" |
|
36 |
|
37 |
|
38 #ifdef SYMBIAN_SECURE_ECOM |
|
39 // for S60 FP3 (2.8) platform or newer (3.0 and above) |
|
40 #include <xml/attribute.h> // needed for RAttributeArray |
|
41 //#else // for S60 FP2 platform (2.6) or older |
|
42 //#include "Attribute.h" |
|
43 #endif |
|
44 |
|
45 #include <xmlengnodelist.h> |
|
46 using namespace Xml; |
|
47 |
|
48 namespace |
|
49 { |
|
50 _LIT8(KProviderIdLocalName, "ProviderID"); |
|
51 _LIT8(KUserName, "AuthzID"); |
|
52 _LIT8(KPassword, "Password"); |
|
53 const TInt KCredIdBufSize = 128; |
|
54 } |
|
55 |
|
56 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewL() |
|
57 { |
|
58 CSenInternalCredential* pNew = NewLC(); |
|
59 CleanupStack::Pop(); // pNew; |
|
60 return pNew; |
|
61 } |
|
62 |
|
63 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewLC() |
|
64 { |
|
65 CSenInternalCredential* pNew = new (ELeave) CSenInternalCredential; |
|
66 CleanupStack::PushL(pNew); |
|
67 pNew->ConstructL(KNullDesC8); |
|
68 return pNew; |
|
69 } |
|
70 |
|
71 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewL( |
|
72 const TDesC8& aNsUri, |
|
73 const TDesC8& aLocalName, |
|
74 const TDesC8& aQName, |
|
75 const RAttributeArray& aAttributes) |
|
76 { |
|
77 CSenInternalCredential* pNew = NewLC(aNsUri, aLocalName, aQName, aAttributes); |
|
78 CleanupStack::Pop(); // pNew; |
|
79 return pNew; |
|
80 } |
|
81 |
|
82 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewLC( |
|
83 const TDesC8& aNsUri, |
|
84 const TDesC8& aLocalName, |
|
85 const TDesC8& aQName, |
|
86 const RAttributeArray& aAttributes) |
|
87 { |
|
88 CSenInternalCredential* pNew = new (ELeave) CSenInternalCredential; |
|
89 CleanupStack::PushL(pNew); |
|
90 pNew->ConstructL(aNsUri, aLocalName, aQName, aAttributes); |
|
91 return pNew; |
|
92 } |
|
93 |
|
94 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewL( |
|
95 const TDesC8& aNsUri, |
|
96 const TDesC8& aLocalName, |
|
97 const TDesC8& aQName, |
|
98 const RAttributeArray& aAttributes, |
|
99 TXmlEngElement& aParent) |
|
100 { |
|
101 CSenInternalCredential* pNew = NewLC(aNsUri, aLocalName, |
|
102 aQName, aAttributes, aParent); |
|
103 CleanupStack::Pop(); // pNew; |
|
104 return pNew; |
|
105 } |
|
106 |
|
107 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewLC( |
|
108 const TDesC8& aNsUri, |
|
109 const TDesC8& aLocalName, |
|
110 const TDesC8& aQName, |
|
111 const RAttributeArray& aAttributes, |
|
112 TXmlEngElement& aParent) |
|
113 { |
|
114 CSenInternalCredential* pNew = new (ELeave) CSenInternalCredential; |
|
115 CleanupStack::PushL(pNew); |
|
116 pNew->ConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent); |
|
117 return pNew; |
|
118 } |
|
119 |
|
120 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewL( |
|
121 const TDesC8& aNsUri, |
|
122 const TDesC8& aLocalName, |
|
123 const TDesC8& aQName, |
|
124 const RAttributeArray& aAttributes, |
|
125 TXmlEngElement& aParent, |
|
126 RSenDocument& aOwnerDocument) |
|
127 { |
|
128 CSenInternalCredential* pNew = NewLC(aNsUri, aLocalName, |
|
129 aQName, aAttributes, |
|
130 aParent, aOwnerDocument); |
|
131 CleanupStack::Pop(); // pNew; |
|
132 return pNew; |
|
133 } |
|
134 |
|
135 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewLC( |
|
136 const TDesC8& aNsUri, |
|
137 const TDesC8& aLocalName, |
|
138 const TDesC8& aQName, |
|
139 const RAttributeArray& aAttributes, |
|
140 TXmlEngElement& aParent, |
|
141 RSenDocument& aOwnerDocument) |
|
142 { |
|
143 CSenInternalCredential* pNew = new (ELeave) CSenInternalCredential; |
|
144 CleanupStack::PushL(pNew); |
|
145 pNew->ConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent, |
|
146 aOwnerDocument); |
|
147 return pNew; |
|
148 } |
|
149 |
|
150 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewL( |
|
151 const CSenInternalCredential& aCredential) |
|
152 { |
|
153 CSenInternalCredential* pNew = NewLC(aCredential); |
|
154 CleanupStack::Pop(); // pNew; |
|
155 return pNew; |
|
156 } |
|
157 |
|
158 EXPORT_C CSenInternalCredential* CSenInternalCredential::NewLC( |
|
159 const CSenInternalCredential& aCredential) |
|
160 { |
|
161 CSenInternalCredential* pNew = new (ELeave) CSenInternalCredential; |
|
162 CleanupStack::PushL(pNew); |
|
163 pNew->ConstructL((CSenInternalCredential&)aCredential); |
|
164 return pNew; |
|
165 } |
|
166 |
|
167 |
|
168 EXPORT_C void CSenInternalCredential::ConstructL(CSenInternalCredential& aCredential) |
|
169 { |
|
170 CSenCredential2::BaseConstructL(aCredential); |
|
171 } |
|
172 |
|
173 EXPORT_C void CSenInternalCredential::ConstructL(const TDesC8& aNsUri, |
|
174 const TDesC8& aLocalName, |
|
175 const TDesC8& aQName, |
|
176 const RAttributeArray& aAttributes, |
|
177 TXmlEngElement& aParent) |
|
178 { |
|
179 CSenCredential2::BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent); |
|
180 } |
|
181 |
|
182 EXPORT_C void CSenInternalCredential::ConstructL(const TDesC8& aNsUri, |
|
183 const TDesC8& aLocalName, |
|
184 const TDesC8& aQName, |
|
185 const RAttributeArray& aAttributes, |
|
186 TXmlEngElement& aParent, |
|
187 RSenDocument& aOwnerDocument) |
|
188 { |
|
189 CSenCredential2::BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent, aOwnerDocument); |
|
190 |
|
191 } |
|
192 |
|
193 EXPORT_C void CSenInternalCredential::ConstructL(const TDesC8& aNsUri, |
|
194 const TDesC8& aLocalName, |
|
195 const TDesC8& aQName, |
|
196 const RAttributeArray& aAttributes) |
|
197 { |
|
198 CSenCredential2::BaseConstructL(aNsUri, aLocalName, aQName, aAttributes); |
|
199 } |
|
200 |
|
201 EXPORT_C void CSenInternalCredential::ConstructL(const TDesC8& aLocalName) |
|
202 { |
|
203 CSenFragmentBase::BaseConstructL(aLocalName); |
|
204 } |
|
205 |
|
206 EXPORT_C CSenInternalCredential::CSenInternalCredential() |
|
207 { |
|
208 } |
|
209 |
|
210 EXPORT_C CSenInternalCredential::~CSenInternalCredential() |
|
211 { |
|
212 delete ipIdentifier; |
|
213 delete ipProperties; |
|
214 } |
|
215 |
|
216 EXPORT_C TBool CSenInternalCredential::IsApplicableL(const CSenWSDescription& aPattern) //codescannerwarings |
|
217 { |
|
218 TPtrC8 value; |
|
219 CSenElement* valueElement; |
|
220 CSenElement& patternElement = ((CSenWSDescription&)aPattern).AsElement(); |
|
221 CSenCredentialIdentifier& identifier = IdentifierL(); //codescannerwarings |
|
222 |
|
223 RXmlEngNodeList<TXmlEngAttr> attrList; |
|
224 |
|
225 RXmlEngNodeList<TXmlEngElement> list; |
|
226 CleanupClosePushL(list); |
|
227 TXmlEngElement element = identifier.AsElementL(); |
|
228 element.GetChildElements(list); |
|
229 while ( list.HasNext() ) |
|
230 { |
|
231 TXmlEngElement element = list.Next(); |
|
232 if ( (element.Name() != KSenCredentialId) && |
|
233 (element.Name() != KProviderIdLocalName) && |
|
234 (element.Name() != KSenIdpAuthzIDLocalname) && |
|
235 (element.Name() != KSenIdpPasswordLocalname) ) |
|
236 { |
|
237 HBufC8* pTag = element.Name().AllocLC(); |
|
238 CleanupStack::PopAndDestroy(pTag); |
|
239 |
|
240 valueElement = patternElement.Element(element.Name()); |
|
241 if ( valueElement ) |
|
242 { |
|
243 HBufC8* pElement1 = valueElement->Content().AllocLC(); |
|
244 HBufC8* pElement2 = element.Text().AllocLC(); |
|
245 CleanupStack::PopAndDestroy(pElement2); |
|
246 CleanupStack::PopAndDestroy(pElement1); |
|
247 |
|
248 if ( valueElement->Content() != element.Text() ) |
|
249 { |
|
250 CleanupStack::PopAndDestroy(&list); // Close() |
|
251 return EFalse; |
|
252 } |
|
253 else |
|
254 { |
|
255 element.GetAttributes(attrList); |
|
256 CleanupClosePushL(attrList); |
|
257 while ( attrList.HasNext() ) |
|
258 { |
|
259 TXmlEngAttr attr = attrList.Next(); |
|
260 if ( *valueElement->AttrValue(attr.Name()) != attr.Value() ) |
|
261 { |
|
262 CleanupStack::PopAndDestroy(&attrList); // Close() |
|
263 CleanupStack::PopAndDestroy(&list); // Close() |
|
264 return EFalse; |
|
265 } |
|
266 } |
|
267 CleanupStack::PopAndDestroy(&attrList); // Close() |
|
268 } |
|
269 } |
|
270 else |
|
271 { |
|
272 CleanupStack::PopAndDestroy(&list); // Close() |
|
273 return EFalse; |
|
274 } |
|
275 } |
|
276 } |
|
277 |
|
278 CleanupStack::PopAndDestroy(&list); // Close() |
|
279 return ETrue; |
|
280 } |
|
281 |
|
282 EXPORT_C void CSenInternalCredential::SetIdentifier(CSenCredentialIdentifier* aIdentifier) |
|
283 { |
|
284 if ( ipIdentifier ) |
|
285 { |
|
286 delete ipIdentifier; |
|
287 } |
|
288 |
|
289 ipIdentifier = aIdentifier; |
|
290 } |
|
291 |
|
292 EXPORT_C CSenCredentialIdentifier& CSenInternalCredential::IdentifierL() //codescannerwarings |
|
293 { |
|
294 if ( !ipIdentifier ) |
|
295 { |
|
296 ipIdentifier = CSenCredentialIdentifier::NewL(); |
|
297 } |
|
298 |
|
299 return *ipIdentifier; |
|
300 } |
|
301 |
|
302 EXPORT_C void CSenInternalCredential::SetProperties(CSenCredentialProperties* aProperties) |
|
303 { |
|
304 if ( ipProperties ) |
|
305 { |
|
306 delete ipProperties; |
|
307 } |
|
308 |
|
309 ipProperties = aProperties; |
|
310 } |
|
311 |
|
312 EXPORT_C CSenCredentialProperties& CSenInternalCredential::PropertiesL() //codescannerwarings |
|
313 { |
|
314 if ( !ipProperties ) |
|
315 { |
|
316 ipProperties = CSenCredentialProperties::NewL(); |
|
317 } |
|
318 |
|
319 return *ipProperties; |
|
320 } |
|
321 |
|
322 EXPORT_C TBool CSenInternalCredential::HasProperties() |
|
323 { |
|
324 if ( !ipProperties ) |
|
325 { |
|
326 return EFalse; |
|
327 } |
|
328 else |
|
329 { |
|
330 return ETrue; |
|
331 } |
|
332 } |
|
333 |
|
334 EXPORT_C void CSenInternalCredential::SetIdentityProviderIdL(TDesC8& aIdentityProviderId) |
|
335 { |
|
336 IdentifierL().SetPropertyL(KProviderIdLocalName, aIdentityProviderId); //codescannerwarings |
|
337 } |
|
338 EXPORT_C void CSenInternalCredential::SetAuthInfo(TDesC8& aUserId, TDesC8& aPassword) |
|
339 { |
|
340 TRAPD(retVal, |
|
341 IdentifierL().SetPropertyL(KUserName, aUserId); |
|
342 IdentifierL().SetPropertyL(KPassword, aPassword); |
|
343 ); |
|
344 } |
|
345 |
|
346 EXPORT_C TInt CSenInternalCredential::IdentityProviderIdL(TPtrC8& aIdTo) |
|
347 { |
|
348 return IdentifierL().PropertyL(KProviderIdLocalName, aIdTo); //codescannerwarings |
|
349 } |
|
350 |
|
351 EXPORT_C void CSenInternalCredential::SetSession(CSenServiceSession& aSession) |
|
352 { |
|
353 ipSession = &aSession; |
|
354 } |
|
355 |
|
356 EXPORT_C CSenServiceSession* CSenInternalCredential::Session() |
|
357 { |
|
358 return ipSession; |
|
359 } |
|
360 |
|
361 |
|
362 |
|
363 |
|
364 EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewL() |
|
365 { |
|
366 CSenCredentialProperties* pNew = NewLC(); |
|
367 CleanupStack::Pop(pNew); |
|
368 return pNew; |
|
369 } |
|
370 |
|
371 EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewLC() |
|
372 { |
|
373 CSenCredentialProperties* pNew = new (ELeave) CSenCredentialProperties; |
|
374 CleanupStack::PushL(pNew); |
|
375 pNew->BaseConstructL(KSenCredentialProperteisLocalname); |
|
376 return pNew; |
|
377 } |
|
378 |
|
379 EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewL( |
|
380 const TDesC8& aNsUri, |
|
381 const TDesC8& aLocalName, |
|
382 const TDesC8& aQName, |
|
383 const RAttributeArray& aAttributes) |
|
384 { |
|
385 CSenCredentialProperties* pNew = NewLC(aNsUri, aLocalName, aQName, aAttributes); |
|
386 CleanupStack::Pop(); // pNew; |
|
387 return pNew; |
|
388 } |
|
389 |
|
390 EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewLC( |
|
391 const TDesC8& aNsUri, |
|
392 const TDesC8& aLocalName, |
|
393 const TDesC8& aQName, |
|
394 const RAttributeArray& aAttributes) |
|
395 { |
|
396 CSenCredentialProperties* pNew = new (ELeave) CSenCredentialProperties; |
|
397 CleanupStack::PushL(pNew); |
|
398 pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes); |
|
399 return pNew; |
|
400 } |
|
401 |
|
402 EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewL( |
|
403 const TDesC8& aNsUri, |
|
404 const TDesC8& aLocalName, |
|
405 const TDesC8& aQName, |
|
406 const RAttributeArray& aAttributes, |
|
407 TXmlEngElement& aParent) |
|
408 { |
|
409 CSenCredentialProperties* pNew = NewLC(aNsUri, aLocalName, |
|
410 aQName, aAttributes, aParent); |
|
411 CleanupStack::Pop(); // pNew; |
|
412 return pNew; |
|
413 } |
|
414 |
|
415 EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewLC( |
|
416 const TDesC8& aNsUri, |
|
417 const TDesC8& aLocalName, |
|
418 const TDesC8& aQName, |
|
419 const RAttributeArray& aAttributes, |
|
420 TXmlEngElement& aParent) |
|
421 { |
|
422 CSenCredentialProperties* pNew = new (ELeave) CSenCredentialProperties; |
|
423 CleanupStack::PushL(pNew); |
|
424 pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent); |
|
425 return pNew; |
|
426 } |
|
427 |
|
428 EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewL( |
|
429 const TDesC8& aNsUri, |
|
430 const TDesC8& aLocalName, |
|
431 const TDesC8& aQName, |
|
432 const RAttributeArray& aAttributes, |
|
433 TXmlEngElement& aParent, |
|
434 RSenDocument& aOwnerDocument) |
|
435 { |
|
436 CSenCredentialProperties* pNew = NewLC(aNsUri, aLocalName, |
|
437 aQName, aAttributes, |
|
438 aParent, aOwnerDocument); |
|
439 CleanupStack::Pop(); // pNew; |
|
440 return pNew; |
|
441 } |
|
442 |
|
443 EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewLC( |
|
444 const TDesC8& aNsUri, |
|
445 const TDesC8& aLocalName, |
|
446 const TDesC8& aQName, |
|
447 const RAttributeArray& aAttributes, |
|
448 TXmlEngElement& aParent, |
|
449 RSenDocument& aOwnerDocument) |
|
450 { |
|
451 CSenCredentialProperties* pNew = new (ELeave) CSenCredentialProperties; |
|
452 CleanupStack::PushL(pNew); |
|
453 pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent, |
|
454 aOwnerDocument); |
|
455 return pNew; |
|
456 } |
|
457 |
|
458 EXPORT_C CSenCredentialProperties::~CSenCredentialProperties() |
|
459 { |
|
460 } |
|
461 |
|
462 CSenCredentialProperties::CSenCredentialProperties() |
|
463 { |
|
464 } |
|
465 |
|
466 EXPORT_C TInt CSenCredentialProperties::SetPropertyL(const TDesC8& aName, |
|
467 const TDesC8& aValue) |
|
468 { |
|
469 TXmlEngElement element = AsElementL(); |
|
470 RXmlEngNodeList<TXmlEngElement> list; |
|
471 CleanupClosePushL(list); |
|
472 |
|
473 element.GetElementsByTagNameL(list, aName); |
|
474 |
|
475 if ( list.Count() > 0 ) |
|
476 { |
|
477 TXmlEngElement firstElement = list.Next(); |
|
478 firstElement.SetTextNoEncL(aValue); |
|
479 CleanupStack::PopAndDestroy(&list); // Close(); |
|
480 |
|
481 return KErrNone; |
|
482 } |
|
483 CleanupStack::PopAndDestroy(&list); |
|
484 |
|
485 TXmlEngElement newElement = element.AddNewElementL(aName); |
|
486 newElement.SetTextNoEncL(aValue); |
|
487 return KErrNone; |
|
488 } |
|
489 |
|
490 EXPORT_C TInt CSenCredentialProperties::PropertyL(const TDesC8& aName, TPtrC8& aValue) |
|
491 { |
|
492 TInt retVal(KErrNone); |
|
493 |
|
494 TXmlEngElement element = AsElementL(); |
|
495 RXmlEngNodeList<TXmlEngElement> list; |
|
496 CleanupClosePushL(list); |
|
497 |
|
498 element.GetElementsByTagNameL(list, aName); |
|
499 |
|
500 if ( list.Count() > 0 ) |
|
501 { |
|
502 TXmlEngElement firstElement = list.Next(); |
|
503 aValue.Set(firstElement.Text()); |
|
504 } |
|
505 else |
|
506 { |
|
507 retVal = KErrNotFound; |
|
508 } |
|
509 |
|
510 CleanupStack::PopAndDestroy(&list); |
|
511 return retVal; |
|
512 } |
|
513 |
|
514 EXPORT_C TInt CSenCredentialProperties::FacetValueL(TDesC8& aURI, |
|
515 HBufC8*& aValueTo) |
|
516 { |
|
517 TInt retVal(KErrNotFound); |
|
518 |
|
519 TXmlEngElement element = AsElementL(); |
|
520 RXmlEngNodeList<TXmlEngElement> list; |
|
521 CleanupClosePushL(list); |
|
522 |
|
523 element.GetElementsByTagNameL(list, KSenFacet); |
|
524 |
|
525 if ( list.Count() > 0 ) |
|
526 { |
|
527 TXmlEngElement element; |
|
528 TPtrC8 value; |
|
529 |
|
530 while ( list.HasNext() ) |
|
531 { |
|
532 element = list.Next(); |
|
533 value.Set(element.AttributeValueL(KFacetAttrName)); |
|
534 if ( value == aURI ) |
|
535 { |
|
536 if ( element.Text().Length() < 1 ) |
|
537 { |
|
538 aValueTo = KSenFacetValTrue().Alloc(); |
|
539 } |
|
540 else |
|
541 { |
|
542 aValueTo = element.Text().Alloc(); |
|
543 } |
|
544 |
|
545 if(!aValueTo) // OOM |
|
546 { |
|
547 retVal = KErrNoMemory; |
|
548 } |
|
549 else |
|
550 { |
|
551 retVal = KErrNone; |
|
552 } |
|
553 } |
|
554 } |
|
555 } |
|
556 |
|
557 CleanupStack::PopAndDestroy(&list); |
|
558 |
|
559 return retVal; |
|
560 } |
|
561 |
|
562 EXPORT_C TInt CSenCredentialProperties::RemoveFacetL(const TDesC8& aURI) |
|
563 { |
|
564 TInt retVal(KErrNotFound); |
|
565 |
|
566 TXmlEngElement element = AsElementL(); |
|
567 RXmlEngNodeList<TXmlEngElement> list; |
|
568 CleanupClosePushL(list); |
|
569 |
|
570 element.GetElementsByTagNameL(list, KSenFacet); |
|
571 |
|
572 if ( list.Count() > 0 ) |
|
573 { |
|
574 TXmlEngElement element; |
|
575 TPtrC8 value; |
|
576 |
|
577 while ( list.HasNext() ) |
|
578 { |
|
579 element = list.Next(); |
|
580 value.Set(element.AttributeValueL(KFacetAttrName)); |
|
581 if ( value == aURI ) |
|
582 { |
|
583 element.Remove(); |
|
584 retVal = KErrNone; |
|
585 } |
|
586 } |
|
587 } |
|
588 |
|
589 CleanupStack::PopAndDestroy(&list); |
|
590 return retVal; |
|
591 } |
|
592 |
|
593 |
|
594 EXPORT_C TInt CSenCredentialProperties::AddFacetL(const CSenFacet& aFacet) |
|
595 { |
|
596 TInt retVal(KErrNotFound); |
|
597 |
|
598 TXmlEngElement element = AsElementL(); |
|
599 RXmlEngNodeList<TXmlEngElement> list; |
|
600 CleanupClosePushL(list); |
|
601 |
|
602 element.GetElementsByTagNameL(list, KSenFacet); |
|
603 |
|
604 if ( list.Count() > 0 ) |
|
605 { |
|
606 TXmlEngElement element; |
|
607 TPtrC8 value; |
|
608 |
|
609 while ( list.HasNext() ) |
|
610 { |
|
611 element = list.Next(); |
|
612 value.Set(element.AttributeValueL(KFacetAttrName)); |
|
613 if ( value == ((CSenFacet&)aFacet).Name() ) |
|
614 { |
|
615 retVal = KErrAlreadyExists; |
|
616 } |
|
617 } |
|
618 } |
|
619 |
|
620 CleanupStack::PopAndDestroy(&list); // Close() |
|
621 |
|
622 if ( retVal != KErrAlreadyExists) |
|
623 { |
|
624 TXmlEngElement newElement = element.AddNewElementL(KSenFacet); |
|
625 newElement.SetAttributeL(KFacetAttrName, ((CSenFacet&)aFacet).Name()); |
|
626 if(((CSenFacet&)aFacet).Type() != KNullDesC8) |
|
627 { |
|
628 newElement.SetAttributeL(KFacetAttrType,((CSenFacet&)aFacet).Type()); |
|
629 } |
|
630 newElement.SetTextNoEncL(((CSenFacet&)aFacet).Value()); |
|
631 retVal = KErrNone; |
|
632 } |
|
633 |
|
634 return retVal; |
|
635 } |
|
636 |
|
637 EXPORT_C TInt CSenCredentialProperties::SetFacetL(const CSenFacet& aFacet) |
|
638 { |
|
639 TInt retVal(KErrNotFound); |
|
640 |
|
641 TXmlEngElement element = AsElementL(); |
|
642 RXmlEngNodeList<TXmlEngElement> list; |
|
643 CleanupClosePushL(list); |
|
644 |
|
645 element.GetElementsByTagNameL(list, KSenFacet); |
|
646 |
|
647 if ( list.Count() > 0 ) |
|
648 { |
|
649 TXmlEngElement element; |
|
650 TPtrC8 value; |
|
651 |
|
652 while ( list.HasNext() && retVal == KErrNotFound ) |
|
653 { |
|
654 element = list.Next(); |
|
655 value.Set(element.AttributeValueL(KFacetAttrName)); |
|
656 if ( value == ((CSenFacet&)aFacet).Name() ) |
|
657 { |
|
658 if(((CSenFacet&)aFacet).Type() != KNullDesC8) |
|
659 { |
|
660 element.SetAttributeL(KFacetAttrType,((CSenFacet&)aFacet).Type()); |
|
661 } |
|
662 element.SetTextNoEncL(((CSenFacet&)aFacet).Value()); |
|
663 retVal = KErrNone; |
|
664 } |
|
665 } |
|
666 } |
|
667 |
|
668 CleanupStack::PopAndDestroy(&list); // Close() |
|
669 |
|
670 if ( retVal == KErrNotFound ) |
|
671 { |
|
672 TXmlEngElement newElement = element.AddNewElementL(KSenFacet); |
|
673 newElement.SetAttributeL(KFacetAttrName, ((CSenFacet&)aFacet).Name()); |
|
674 if(((CSenFacet&)aFacet).Type() != KNullDesC8) |
|
675 { |
|
676 newElement.SetAttributeL(KFacetAttrType,((CSenFacet&)aFacet).Type()); |
|
677 } |
|
678 newElement.SetTextNoEncL(((CSenFacet&)aFacet).Value()); |
|
679 retVal = KErrNone; |
|
680 } |
|
681 |
|
682 return retVal; |
|
683 } |
|
684 |
|
685 EXPORT_C void CSenCredentialProperties::SetValidUntilL(TTime aValidUntil) |
|
686 { |
|
687 TXmlEngElement element = AsElementL(); |
|
688 RXmlEngNodeList<TXmlEngElement> list; |
|
689 CleanupClosePushL(list); |
|
690 |
|
691 element.GetElementsByTagNameL(list, KSenCredentialValidUntil); |
|
692 |
|
693 TXmlEngElement validUntilElement; |
|
694 if ( list.Count() > 0 ) |
|
695 { |
|
696 validUntilElement = list.Next(); |
|
697 } |
|
698 else |
|
699 { |
|
700 validUntilElement = element.AddNewElementL(KSenCredentialValidUntil); |
|
701 } |
|
702 |
|
703 HBufC8* pDateDes = HBufC8::NewLC(KCredIdBufSize); |
|
704 TPtr8 datePtr = pDateDes->Des(); |
|
705 SenDateUtils::ToXmlDateTimeUtf82L(datePtr, aValidUntil); |
|
706 validUntilElement.SetTextL(*pDateDes); |
|
707 CleanupStack::PopAndDestroy(pDateDes); |
|
708 |
|
709 CleanupStack::PopAndDestroy(&list); // Close() |
|
710 } |
|
711 |
|
712 EXPORT_C TTime CSenCredentialProperties::ValidUntilL() |
|
713 { |
|
714 TTime retTime = Time::NullTTime(); |
|
715 |
|
716 TXmlEngElement element = AsElementL(); |
|
717 RXmlEngNodeList<TXmlEngElement> list; |
|
718 CleanupClosePushL(list); |
|
719 |
|
720 element.GetElementsByTagNameL(list, KSenCredentialValidUntil); |
|
721 |
|
722 if ( list.Count() > 0 ) |
|
723 { |
|
724 TXmlEngElement validUntilElement = list.Next(); |
|
725 retTime = SenDateUtils::FromXmlDateTimeL(validUntilElement.Text()); |
|
726 } |
|
727 |
|
728 CleanupStack::PopAndDestroy(&list); // Close() |
|
729 |
|
730 return retTime; |
|
731 } |
|
732 |
|
733 EXPORT_C CSenCredentialIdentifier* CSenCredentialIdentifier::NewL() |
|
734 { |
|
735 CSenCredentialIdentifier* pNew = NewLC(); |
|
736 CleanupStack::Pop(pNew); |
|
737 return pNew; |
|
738 } |
|
739 |
|
740 EXPORT_C CSenCredentialIdentifier* CSenCredentialIdentifier::NewLC() |
|
741 { |
|
742 CSenCredentialIdentifier* pNew = new (ELeave) CSenCredentialIdentifier; |
|
743 CleanupStack::PushL(pNew); |
|
744 pNew->BaseConstructL(KSenCredentialIdentifierLocalname); |
|
745 return pNew; |
|
746 } |
|
747 |
|
748 EXPORT_C CSenCredentialIdentifier* CSenCredentialIdentifier::NewL( |
|
749 const TDesC8& aNsUri, |
|
750 const TDesC8& aLocalName, |
|
751 const TDesC8& aQName, |
|
752 const RAttributeArray& aAttributes) |
|
753 { |
|
754 CSenCredentialIdentifier* pNew = NewLC(aNsUri, aLocalName, aQName, aAttributes); |
|
755 CleanupStack::Pop(); // pNew; |
|
756 return pNew; |
|
757 } |
|
758 |
|
759 EXPORT_C CSenCredentialIdentifier* CSenCredentialIdentifier::NewLC( |
|
760 const TDesC8& aNsUri, |
|
761 const TDesC8& aLocalName, |
|
762 const TDesC8& aQName, |
|
763 const RAttributeArray& aAttributes) |
|
764 { |
|
765 CSenCredentialIdentifier* pNew = new (ELeave) CSenCredentialIdentifier; |
|
766 CleanupStack::PushL(pNew); |
|
767 pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes); |
|
768 return pNew; |
|
769 } |
|
770 |
|
771 EXPORT_C CSenCredentialIdentifier* CSenCredentialIdentifier::NewL( |
|
772 const TDesC8& aNsUri, |
|
773 const TDesC8& aLocalName, |
|
774 const TDesC8& aQName, |
|
775 const RAttributeArray& aAttributes, |
|
776 TXmlEngElement& aParent) |
|
777 { |
|
778 CSenCredentialIdentifier* pNew = NewLC(aNsUri, aLocalName, |
|
779 aQName, aAttributes, aParent); |
|
780 CleanupStack::Pop(); // pNew; |
|
781 return pNew; |
|
782 } |
|
783 |
|
784 EXPORT_C CSenCredentialIdentifier* CSenCredentialIdentifier::NewLC( |
|
785 const TDesC8& aNsUri, |
|
786 const TDesC8& aLocalName, |
|
787 const TDesC8& aQName, |
|
788 const RAttributeArray& aAttributes, |
|
789 TXmlEngElement& aParent) |
|
790 { |
|
791 CSenCredentialIdentifier* pNew = new (ELeave) CSenCredentialIdentifier; |
|
792 CleanupStack::PushL(pNew); |
|
793 pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent); |
|
794 return pNew; |
|
795 } |
|
796 |
|
797 EXPORT_C CSenCredentialIdentifier* CSenCredentialIdentifier::NewL( |
|
798 const TDesC8& aNsUri, |
|
799 const TDesC8& aLocalName, |
|
800 const TDesC8& aQName, |
|
801 const RAttributeArray& aAttributes, |
|
802 TXmlEngElement& aParent, |
|
803 RSenDocument& aOwnerDocument) |
|
804 { |
|
805 CSenCredentialIdentifier* pNew = NewLC(aNsUri, aLocalName, |
|
806 aQName, aAttributes, |
|
807 aParent, aOwnerDocument); |
|
808 CleanupStack::Pop(); // pNew; |
|
809 return pNew; |
|
810 } |
|
811 |
|
812 EXPORT_C CSenCredentialIdentifier* CSenCredentialIdentifier::NewLC( |
|
813 const TDesC8& aNsUri, |
|
814 const TDesC8& aLocalName, |
|
815 const TDesC8& aQName, |
|
816 const RAttributeArray& aAttributes, |
|
817 TXmlEngElement& aParent, |
|
818 RSenDocument& aOwnerDocument) |
|
819 { |
|
820 CSenCredentialIdentifier* pNew = new (ELeave) CSenCredentialIdentifier; |
|
821 CleanupStack::PushL(pNew); |
|
822 pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent, |
|
823 aOwnerDocument); |
|
824 return pNew; |
|
825 } |
|
826 |
|
827 EXPORT_C CSenCredentialIdentifier::~CSenCredentialIdentifier() |
|
828 { |
|
829 } |
|
830 |
|
831 CSenCredentialIdentifier::CSenCredentialIdentifier() |
|
832 { |
|
833 } |
|
834 |
|
835 EXPORT_C void CSenCredentialIdentifier::SetIdL(TInt aId) |
|
836 { |
|
837 TXmlEngElement element = AsElementL(); |
|
838 RXmlEngNodeList<TXmlEngElement> list; |
|
839 CleanupClosePushL(list); |
|
840 |
|
841 element.GetElementsByTagNameL(list, KSenCredentialId); |
|
842 |
|
843 TXmlEngElement idElement; |
|
844 if ( list.Count() > 0 ) |
|
845 { |
|
846 idElement = list.Next(); |
|
847 } |
|
848 else |
|
849 { |
|
850 idElement = element.AddNewElementL(KSenCredentialId); |
|
851 } |
|
852 |
|
853 TBuf8<KCredIdBufSize> buffer; |
|
854 buffer.Num(aId); |
|
855 idElement.SetTextL(buffer); |
|
856 |
|
857 CleanupStack::PopAndDestroy(&list); // Close() |
|
858 } |
|
859 |
|
860 EXPORT_C TInt CSenCredentialIdentifier::IdL() |
|
861 { |
|
862 TInt retVal(KErrNotFound); |
|
863 |
|
864 TXmlEngElement element = AsElementL(); |
|
865 RXmlEngNodeList<TXmlEngElement> list; |
|
866 CleanupClosePushL(list); |
|
867 |
|
868 element.GetElementsByTagNameL(list, KSenCredentialId); |
|
869 |
|
870 if ( list.Count() > 0 ) |
|
871 { |
|
872 TXmlEngElement idElement = list.Next(); |
|
873 TLex8 lex; |
|
874 lex.Assign(idElement.Text()); |
|
875 lex.Val( retVal ); |
|
876 } |
|
877 |
|
878 CleanupStack::PopAndDestroy(&list); // Close() |
|
879 |
|
880 return retVal; |
|
881 } |
|
882 |
|
883 CSenCredentialData* CSenCredentialData::NewL() |
|
884 { |
|
885 CSenCredentialData* pNew = CSenCredentialData::NewLC(); |
|
886 CleanupStack::Pop(); // pNew; |
|
887 return pNew; |
|
888 } |
|
889 |
|
890 CSenCredentialData* CSenCredentialData::NewLC() |
|
891 { |
|
892 CSenCredentialData* pNew = new (ELeave) CSenCredentialData; |
|
893 CleanupStack::PushL(pNew); |
|
894 return pNew; |
|
895 } |
|
896 |
|
897 CSenCredentialData::~CSenCredentialData() |
|
898 { |
|
899 iObserverArray.Close(); |
|
900 } |
|
901 |
|
902 CSenCredentialData::CSenCredentialData() |
|
903 { |
|
904 } |
|
905 |
|
906 EXPORT_C void RSenCredentialPtr::OpenL(CSenInternalCredential* apCredential) |
|
907 { |
|
908 CREDLOG_L(KSenCredsLogLevelMax,"CredentialPtr OPEN"); |
|
909 |
|
910 ipCredentialData = CSenCredentialData::NewL(); |
|
911 ipCredentialData->iCounter = 1; |
|
912 ipCredentialData->ipCredential = apCredential; |
|
913 CREDLOG_L(KSenCredsLogLevelMax,".....END"); |
|
914 } |
|
915 |
|
916 EXPORT_C CSenInternalCredential* RSenCredentialPtr::Credential() |
|
917 { |
|
918 if ( ipCredentialData ) |
|
919 { |
|
920 return ipCredentialData->ipCredential; |
|
921 } |
|
922 else |
|
923 { |
|
924 return NULL; |
|
925 } |
|
926 } |
|
927 |
|
928 EXPORT_C void RSenCredentialPtr::SetCredential(CSenInternalCredential* apCredential) |
|
929 { |
|
930 CREDLOG_L(KSenCredsLogLevelMax,"CredentialPtr SET"); |
|
931 if ( ipCredentialData ) |
|
932 { |
|
933 delete ipCredentialData->ipCredential; |
|
934 ipCredentialData->ipCredential = apCredential; |
|
935 |
|
936 TInt count = ipCredentialData->iObserverArray.Count(); |
|
937 for (TInt i=0; i < count; i++) |
|
938 { |
|
939 ipCredentialData->iObserverArray[i]->CredentialChanged(MSenCredentialObserver::EReplaced); |
|
940 } |
|
941 } |
|
942 CREDLOG_L(KSenCredsLogLevelMax,".....END"); |
|
943 } |
|
944 |
|
945 EXPORT_C RSenCredentialPtr RSenCredentialPtr::Clone() |
|
946 { |
|
947 if ( ipCredentialData ) |
|
948 { |
|
949 CREDLOG_L(KSenCredsLogLevelMax,"CredentialPtr CLONE"); |
|
950 (ipCredentialData->iCounter)++; |
|
951 #ifdef _SENDEBUG |
|
952 TRAP_IGNORE |
|
953 ( |
|
954 _LIT8(KCredsLogLine, "....counter = %d"); |
|
955 CREDLOG_FORMAT((KSenCredsLogChannel, KSenCredsLogLevelMax, KCredsLogLine, ipCredentialData->iCounter)); |
|
956 CREDLOG_L(KSenCredsLogLevelMax,"....ticket "); |
|
957 if (ipCredentialData->ipCredential) |
|
958 { |
|
959 HBufC8* ptr = ipCredentialData->ipCredential->AsXmlL(); |
|
960 CleanupStack::PushL(ptr); |
|
961 CREDLOG_ALL(KSenCredsLogLevelMax, *ptr); |
|
962 CleanupStack::PopAndDestroy(ptr); |
|
963 } |
|
964 else |
|
965 { |
|
966 CREDLOG_L(KSenCredsLogLevelMax,"....NULL"); |
|
967 } |
|
968 CREDLOG_L(KSenCredsLogLevelMax,"....END"); |
|
969 ) |
|
970 #endif // _SENDEBUG |
|
971 } |
|
972 return *this; |
|
973 } |
|
974 |
|
975 EXPORT_C void RSenCredentialPtr::Close() |
|
976 { |
|
977 if ( ipCredentialData ) |
|
978 { |
|
979 CREDLOG_L(KSenCredsLogLevelMax,"CredentialPtr CLOSE"); |
|
980 (ipCredentialData->iCounter)--; |
|
981 #ifdef _SENDEBUG |
|
982 TRAP_IGNORE |
|
983 ( |
|
984 _LIT8(KCredsLogLine, "....counter = %d"); |
|
985 CREDLOG_FORMAT((KSenCredsLogChannel, KSenCredsLogLevelMax, KCredsLogLine, ipCredentialData->iCounter)); |
|
986 CREDLOG_L(KSenCredsLogLevelMax,"....ticket "); |
|
987 if (ipCredentialData->ipCredential) |
|
988 { |
|
989 HBufC8* ptr = ipCredentialData->ipCredential->AsXmlL(); |
|
990 CleanupStack::PushL(ptr); |
|
991 CREDLOG_ALL(KSenCredsLogLevelMax, *ptr); |
|
992 CleanupStack::PopAndDestroy(ptr); |
|
993 } |
|
994 else |
|
995 { |
|
996 CREDLOG_L(KSenCredsLogLevelMax,"....NULL"); |
|
997 } |
|
998 ) |
|
999 #endif // _SENDEBUG |
|
1000 if ( ipCredentialData->iCounter == 0 ) |
|
1001 { |
|
1002 CREDLOG_L(KSenCredsLogLevelMax,"....deleting Credential"); |
|
1003 delete ipCredentialData->ipCredential; |
|
1004 ipCredentialData->ipCredential = NULL; |
|
1005 TInt count = ipCredentialData->iObserverArray.Count(); |
|
1006 for (TInt i=0; i < count; i++) |
|
1007 { |
|
1008 ipCredentialData->iObserverArray[i]->CredentialChanged(MSenCredentialObserver::EDestroyed); |
|
1009 } |
|
1010 |
|
1011 delete ipCredentialData; |
|
1012 } |
|
1013 ipCredentialData = NULL; |
|
1014 CREDLOG_L(KSenCredsLogLevelMax,"....END"); |
|
1015 } |
|
1016 } |
|
1017 |
|
1018 EXPORT_C void RSenCredentialPtr::CloseAndDestroyCredential() |
|
1019 { |
|
1020 if ( ipCredentialData ) |
|
1021 { |
|
1022 delete ipCredentialData->ipCredential; |
|
1023 ipCredentialData->ipCredential = NULL; |
|
1024 |
|
1025 TInt count = ipCredentialData->iObserverArray.Count(); |
|
1026 for (TInt i=0; i < count; i++) |
|
1027 { |
|
1028 ipCredentialData->iObserverArray[i]->CredentialChanged(MSenCredentialObserver::EDestroyed); |
|
1029 } |
|
1030 CREDLOG_L(KSenCredsLogLevelMax,"CredentialPtr CLOSEANDDESTROY"); |
|
1031 |
|
1032 (ipCredentialData->iCounter)--; |
|
1033 if ( ipCredentialData->iCounter == 0 ) |
|
1034 { |
|
1035 CREDLOG_L(KSenCredsLogLevelMax,".....deleting"); |
|
1036 delete ipCredentialData; |
|
1037 ipCredentialData = NULL; |
|
1038 } |
|
1039 CREDLOG_L(KSenCredsLogLevelMax,".....END"); |
|
1040 } |
|
1041 } |
|
1042 |
|
1043 EXPORT_C void RSenCredentialPtr::AddCredentialObserverL(MSenCredentialObserver& aObserver) //codescannerwarnings |
|
1044 { |
|
1045 if ( ipCredentialData ) |
|
1046 { |
|
1047 TInt leaveCode( KErrNone ); |
|
1048 TRAP( leaveCode, ipCredentialData->iObserverArray.AppendL(&aObserver); ) |
|
1049 #ifdef _SENDEBUG |
|
1050 if( leaveCode ) |
|
1051 { |
|
1052 CREDLOG_L(KSenCredsLogLevelMin, "RSenCredentialPtr::AddCredentialObserverL:"); |
|
1053 _LIT8(KCredsLogLine, "- ipCredentialData->iObserverArray.AppendL leaved (%d)!"); |
|
1054 CREDLOG_FORMAT(( KSenCredsLogChannel, KSenCredsLogLevelMax, KCredsLogLine, leaveCode )); |
|
1055 } |
|
1056 #endif // _SENDEBUG |
|
1057 leaveCode = 0; // ignored in release builds |
|
1058 } |
|
1059 } |
|
1060 |
|
1061 EXPORT_C TInt RSenCredentialPtr::RemoveCredentialObserver(MSenCredentialObserver& aObserver) |
|
1062 { |
|
1063 if ( ipCredentialData ) |
|
1064 { |
|
1065 TInt pos = ipCredentialData->iObserverArray.Find(&aObserver); |
|
1066 if ( pos != KErrNotFound ) |
|
1067 { |
|
1068 ipCredentialData->iObserverArray.Remove(pos); |
|
1069 } |
|
1070 else |
|
1071 { |
|
1072 return pos; |
|
1073 } |
|
1074 } |
|
1075 |
|
1076 return KErrNone; |
|
1077 } |
|
1078 |
|
1079 EXPORT_C RSenCredentialPtr::RSenCredentialPtr() |
|
1080 : ipCredentialData(NULL) |
|
1081 { |
|
1082 } |
|
1083 |
|
1084 // END OF FILE |