|
1 /* |
|
2 * Copyright (c) 2004 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: X.509 AttributeCertificateInfo type |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 // INCLUDE FILES |
|
20 #include "CCMSX509AttributeCertificateInfo.h" |
|
21 #include "CCMSX509IssuerSerial.h" |
|
22 #include "CCMSX509GeneralNames.h" |
|
23 #include "CCMSX509AlgorithmIdentifier.h" |
|
24 #include "CCMSAttribute.h" |
|
25 #include <asn1dec.h> |
|
26 #include <asn1enc.h> |
|
27 |
|
28 // CONSTANTS |
|
29 const TInt KMinNumberOfSubModules = 6; |
|
30 const TInt KMaxNumberOfSubModules = 9; |
|
31 const TInt KValidityPeriodModuleCount = 2; |
|
32 const TInt KValidityNotBeforeIndex = 0; |
|
33 const TInt KValidityNotAfterIndex = 1; |
|
34 const TInt KDefaultGranularity = 1; |
|
35 const TInt KDefaultVersion = 0; // v1 == 0 |
|
36 const TTagType KBaseCertificateIDTag = 0; |
|
37 const TTagType KSubjectNameTag = 1; |
|
38 |
|
39 // ============================ MEMBER FUNCTIONS =============================== |
|
40 |
|
41 // Destructor |
|
42 CCMSX509AttributeCertificateInfo::CAttributeCertificateData:: |
|
43 ~CAttributeCertificateData() |
|
44 { |
|
45 delete iBaseCertificateID; |
|
46 delete iSubjectName; |
|
47 delete iIssuer; |
|
48 delete iSignature; |
|
49 |
|
50 if( iAttributes ) |
|
51 { |
|
52 iAttributes->ResetAndDestroy(); |
|
53 delete iAttributes; |
|
54 } |
|
55 |
|
56 delete iIssuerUniqueID; |
|
57 } |
|
58 |
|
59 // ----------------------------------------------------------------------------- |
|
60 // CCMSX509AttributeCertificateInfo::CCMSX509AttributeCertificateInfo |
|
61 // C++ default constructor can NOT contain any code, that |
|
62 // might leave. |
|
63 // ----------------------------------------------------------------------------- |
|
64 // |
|
65 EXPORT_C CCMSX509AttributeCertificateInfo::CCMSX509AttributeCertificateInfo() |
|
66 { |
|
67 } |
|
68 |
|
69 // ----------------------------------------------------------------------------- |
|
70 // CCMSX509AttributeCertificateInfo::ConstructL |
|
71 // Symbian 2nd phase constructor can leave. |
|
72 // ----------------------------------------------------------------------------- |
|
73 // |
|
74 EXPORT_C void CCMSX509AttributeCertificateInfo::ConstructL( |
|
75 const CCMSX509IssuerSerial& aBaseCertificateID, |
|
76 const CCMSX509GeneralNames& aIssuer, |
|
77 const CCMSX509AlgorithmIdentifier& aSignature, |
|
78 const TInt aSerialNumber, |
|
79 const TTime& aNotBeforeTime, |
|
80 const TTime& aNotAfterTime, |
|
81 const CArrayPtr< CCMSAttribute >& aAttributes ) |
|
82 { |
|
83 iData = new( ELeave ) CAttributeCertificateData(); |
|
84 iData->iVersion = KDefaultVersion; |
|
85 SetBaseCertificateIDL( aBaseCertificateID ); |
|
86 SetIssuerL( aIssuer ); |
|
87 SetSignatureL( aSignature ); |
|
88 SetSerialNumber( aSerialNumber ); |
|
89 SetNotBeforeTimeL( aNotBeforeTime ); |
|
90 SetNotAfterTimeL( aNotAfterTime ); |
|
91 SetAttributesL( aAttributes ); |
|
92 } |
|
93 |
|
94 // ----------------------------------------------------------------------------- |
|
95 // CCMSX509AttributeCertificateInfo::ConstructL |
|
96 // Symbian 2nd phase constructor can leave. |
|
97 // ----------------------------------------------------------------------------- |
|
98 // |
|
99 EXPORT_C void CCMSX509AttributeCertificateInfo::ConstructL( |
|
100 const CCMSX509GeneralNames& aSubjectName, |
|
101 const CCMSX509GeneralNames& aIssuer, |
|
102 const CCMSX509AlgorithmIdentifier& aSignature, |
|
103 const TInt aSerialNumber, |
|
104 const TTime& aNotBeforeTime, |
|
105 const TTime& aNotAfterTime, |
|
106 const CArrayPtr< CCMSAttribute >& aAttributes ) |
|
107 { |
|
108 iData = new( ELeave ) CAttributeCertificateData(); |
|
109 iData->iVersion = KDefaultVersion; |
|
110 SetSubjectNameL( aSubjectName ); |
|
111 SetIssuerL( aIssuer ); |
|
112 SetSignatureL( aSignature ); |
|
113 SetSerialNumber( aSerialNumber ); |
|
114 SetNotBeforeTimeL( aNotBeforeTime ); |
|
115 SetNotAfterTimeL( aNotAfterTime ); |
|
116 SetAttributesL( aAttributes ); |
|
117 } |
|
118 |
|
119 // ----------------------------------------------------------------------------- |
|
120 // CCMSX509AttributeCertificateInfo::ConstructL |
|
121 // Symbian 2nd phase constructor can leave. |
|
122 // ----------------------------------------------------------------------------- |
|
123 // |
|
124 EXPORT_C void CCMSX509AttributeCertificateInfo::ConstructL( ) |
|
125 { |
|
126 // creating empty/default values |
|
127 CAttributeCertificateData* data = new( ELeave ) CAttributeCertificateData(); |
|
128 CleanupStack::PushL( data ); |
|
129 data->iVersion = KDefaultVersion; |
|
130 data->iBaseCertificateID = CCMSX509IssuerSerial::NewL(); |
|
131 data->iIssuer = CCMSX509GeneralNames::NewL(); |
|
132 data->iSignature = CCMSX509AlgorithmIdentifier::NewL(); |
|
133 data->iNotBeforeTime.UniversalTime(); |
|
134 data->iNotAfterTime.UniversalTime(); |
|
135 data->iNotAfterTime+=TTimeIntervalYears( 1 ); |
|
136 data->iAttributes = new( ELeave ) CArrayPtrFlat< CCMSAttribute >( 1 ); |
|
137 CleanupStack::Pop( data ); |
|
138 iData = data; |
|
139 } |
|
140 |
|
141 |
|
142 // ----------------------------------------------------------------------------- |
|
143 // CCMSX509AttributeCertificateInfo::NewL |
|
144 // Two-phased constructor. |
|
145 // ----------------------------------------------------------------------------- |
|
146 // |
|
147 EXPORT_C CCMSX509AttributeCertificateInfo* |
|
148 CCMSX509AttributeCertificateInfo::NewL() |
|
149 { |
|
150 // creating with empty values |
|
151 CCMSX509AttributeCertificateInfo* self = |
|
152 new( ELeave ) CCMSX509AttributeCertificateInfo(); |
|
153 CleanupStack::PushL( self ); |
|
154 self->ConstructL( ); |
|
155 CleanupStack::Pop( self ); |
|
156 return self; |
|
157 } |
|
158 |
|
159 // ----------------------------------------------------------------------------- |
|
160 // CCMSX509AttributeCertificateInfo::NewL |
|
161 // Two-phased constructor. |
|
162 // ----------------------------------------------------------------------------- |
|
163 // |
|
164 EXPORT_C CCMSX509AttributeCertificateInfo* |
|
165 CCMSX509AttributeCertificateInfo::NewL( |
|
166 const CCMSX509IssuerSerial& aBaseCertificateID, |
|
167 const CCMSX509GeneralNames& aIssuer, |
|
168 const CCMSX509AlgorithmIdentifier& aSignature, |
|
169 const TInt aSerialNumber, |
|
170 const TTime& aNotBeforeTime, |
|
171 const TTime& aNotAfterTime, |
|
172 const CArrayPtr< CCMSAttribute >& aAttributes ) |
|
173 { |
|
174 CCMSX509AttributeCertificateInfo* self = |
|
175 new( ELeave ) CCMSX509AttributeCertificateInfo(); |
|
176 CleanupStack::PushL( self ); |
|
177 self->ConstructL( aBaseCertificateID, aIssuer, aSignature, aSerialNumber, |
|
178 aNotBeforeTime, aNotAfterTime, |
|
179 aAttributes ); |
|
180 CleanupStack::Pop(); |
|
181 |
|
182 return self; |
|
183 } |
|
184 |
|
185 // ----------------------------------------------------------------------------- |
|
186 // CCMSX509AttributeCertificateInfo::NewL |
|
187 // Two-phased constructor. |
|
188 // ----------------------------------------------------------------------------- |
|
189 // |
|
190 EXPORT_C CCMSX509AttributeCertificateInfo* |
|
191 CCMSX509AttributeCertificateInfo::NewL( |
|
192 const CCMSX509GeneralNames& aSubjectName, |
|
193 const CCMSX509GeneralNames& aIssuer, |
|
194 const CCMSX509AlgorithmIdentifier& aSignature, |
|
195 const TInt aSerialNumber, |
|
196 const TTime& aNotBeforeTime, |
|
197 const TTime& aNotAfterTime, |
|
198 const CArrayPtr< CCMSAttribute >& aAttributes ) |
|
199 { |
|
200 CCMSX509AttributeCertificateInfo* self = |
|
201 new( ELeave ) CCMSX509AttributeCertificateInfo(); |
|
202 CleanupStack::PushL( self ); |
|
203 self->ConstructL( aSubjectName, aIssuer, aSignature, aSerialNumber, |
|
204 aNotBeforeTime, aNotAfterTime, |
|
205 aAttributes ); |
|
206 CleanupStack::Pop(); |
|
207 |
|
208 return self; |
|
209 } |
|
210 |
|
211 // Destructor |
|
212 CCMSX509AttributeCertificateInfo::~CCMSX509AttributeCertificateInfo() |
|
213 { |
|
214 delete iData; |
|
215 } |
|
216 |
|
217 // ----------------------------------------------------------------------------- |
|
218 // CCMSX509AttributeCertificateInfo::DecodeL |
|
219 // Decrypts raw data to this instance |
|
220 // ----------------------------------------------------------------------------- |
|
221 void CCMSX509AttributeCertificateInfo::DecodeL( const TDesC8& aRawData ) |
|
222 { |
|
223 CAttributeCertificateData* data = new( ELeave ) CAttributeCertificateData(); |
|
224 CleanupStack::PushL( data ); |
|
225 |
|
226 CArrayPtr< TASN1DecGeneric >* itemList = DecodeSequenceLC( |
|
227 aRawData, KMinNumberOfSubModules, KMaxNumberOfSubModules ); |
|
228 |
|
229 TInt sequenceCounter = 0; |
|
230 |
|
231 // decode version |
|
232 TASN1DecGeneric* version = itemList->At( sequenceCounter ); |
|
233 TASN1DecInteger intDecoder; |
|
234 if( ( version->Tag() == EASN1Integer ) && |
|
235 ( version->Class() == EUniversal ) ) |
|
236 { |
|
237 data->iVersion = |
|
238 intDecoder.DecodeDERShortL( *version ); |
|
239 sequenceCounter++; |
|
240 } |
|
241 else |
|
242 { |
|
243 data->iVersion = KDefaultVersion; |
|
244 } |
|
245 |
|
246 // decode subject |
|
247 TASN1DecGeneric* subject = itemList->At( sequenceCounter++ ); |
|
248 subject->InitL( ); |
|
249 TTagType subjectTag( subject->Tag() ); |
|
250 switch( subjectTag ) |
|
251 { |
|
252 case KBaseCertificateIDTag: |
|
253 { |
|
254 data->iBaseCertificateID = CCMSX509IssuerSerial::NewL(); |
|
255 data->iBaseCertificateID->DecodeL( subject->GetContentDER() ); |
|
256 break; |
|
257 } |
|
258 case KSubjectNameTag: |
|
259 { |
|
260 data->iSubjectName = CCMSX509GeneralNames::NewL(); |
|
261 data->iSubjectName->DecodeL( subject->GetContentDER() ); |
|
262 break; |
|
263 } |
|
264 default: |
|
265 { |
|
266 User::Leave( KErrArgument ); |
|
267 } |
|
268 } |
|
269 |
|
270 // decode issuer |
|
271 TASN1DecGeneric* issuer = itemList->At( sequenceCounter++ ); |
|
272 issuer->InitL(); |
|
273 data->iIssuer = CCMSX509GeneralNames::NewL(); |
|
274 data->iIssuer->DecodeL( issuer->Encoding() ); |
|
275 |
|
276 // decode signature |
|
277 TASN1DecGeneric* signature = itemList->At( sequenceCounter++ ); |
|
278 signature->InitL(); |
|
279 data->iSignature = CCMSX509AlgorithmIdentifier::NewL(); |
|
280 data->iSignature->DecodeL( signature->Encoding() ); |
|
281 |
|
282 // decode serialNumber |
|
283 data->iSerialNumber = |
|
284 intDecoder.DecodeDERShortL( *( itemList->At( sequenceCounter++ ) ) ); |
|
285 |
|
286 // decode attCertValidityPeriod |
|
287 TASN1DecGeneric* validityPeriodDecoder = itemList->At( sequenceCounter++ ); |
|
288 validityPeriodDecoder->InitL(); |
|
289 CArrayPtr< TASN1DecGeneric >* validityPeriod = DecodeSequenceLC( |
|
290 validityPeriodDecoder->Encoding(), KValidityPeriodModuleCount, |
|
291 KValidityPeriodModuleCount ); |
|
292 TASN1DecGeneralizedTime timeDecoder; |
|
293 data->iNotBeforeTime = timeDecoder.DecodeDERL( |
|
294 *( validityPeriod->At( KValidityNotBeforeIndex ) ) ); |
|
295 data->iNotAfterTime = timeDecoder.DecodeDERL( |
|
296 *( validityPeriod->At( KValidityNotAfterIndex ) ) ); |
|
297 CleanupStack::PopAndDestroy( validityPeriod ); |
|
298 |
|
299 // decode attributes |
|
300 TASN1DecGeneric* attributesDecoder = itemList->At( sequenceCounter++ ); |
|
301 attributesDecoder->InitL(); |
|
302 CArrayPtr< TASN1DecGeneric >* attributes = DecodeSequenceLC( |
|
303 attributesDecoder->Encoding() ); |
|
304 TInt attributeCount = attributes->Count(); |
|
305 data->iAttributes = new( ELeave ) CArrayPtrFlat< CCMSAttribute >( |
|
306 attributeCount ? attributeCount : KDefaultGranularity ); |
|
307 for( TInt i = 0; i < attributeCount; i++ ) |
|
308 { |
|
309 TASN1DecGeneric* attributeDecoder = attributes->At( i ); |
|
310 attributeDecoder->InitL(); |
|
311 CCMSAttribute* attribute = CCMSAttribute::NewLC(); |
|
312 attribute->DecodeL( attributeDecoder->Encoding() ); |
|
313 data->iAttributes->AppendL( attribute ); |
|
314 CleanupStack::Pop( attribute ); |
|
315 } |
|
316 CleanupStack::PopAndDestroy( attributes ); |
|
317 |
|
318 // decode issuerUniqueID |
|
319 if( itemList->Count() > sequenceCounter ) |
|
320 { |
|
321 TASN1DecBitString bsDecoder; |
|
322 data->iIssuerUniqueID = bsDecoder.ExtractOctetStringL( |
|
323 *( itemList->At( sequenceCounter ) ) ); |
|
324 } |
|
325 |
|
326 // all decoded, change state |
|
327 CleanupStack::PopAndDestroy( itemList ); |
|
328 |
|
329 delete iData; |
|
330 iData = data; |
|
331 |
|
332 CleanupStack::Pop( data ); |
|
333 } |
|
334 |
|
335 // ----------------------------------------------------------------------------- |
|
336 // CCMSX509AttributeCertificateInfo::EncoderLC |
|
337 // Returns ASN1 encoder for this instance |
|
338 // ----------------------------------------------------------------------------- |
|
339 |
|
340 CASN1EncBase* CCMSX509AttributeCertificateInfo::EncoderLC() const |
|
341 { |
|
342 CASN1EncSequence* root = CASN1EncSequence::NewLC(); |
|
343 |
|
344 // encode version |
|
345 CASN1EncInt* version = CASN1EncInt::NewLC( iData->iVersion ); |
|
346 root->AddAndPopChildL( version ); |
|
347 |
|
348 // encode subject |
|
349 CASN1EncBase* subject = NULL; |
|
350 if( iData->iBaseCertificateID ) |
|
351 { |
|
352 // encode baseCertificateID [0] IssuerSerial |
|
353 CASN1EncBase* baseCertificateID = |
|
354 iData->iBaseCertificateID->EncoderLC( ); |
|
355 CleanupStack::Pop( baseCertificateID ); |
|
356 subject = CASN1EncExplicitTag::NewLC( |
|
357 baseCertificateID, KBaseCertificateIDTag ); |
|
358 } |
|
359 else |
|
360 { |
|
361 // encode subjectName [1] GeneralNames |
|
362 CASN1EncBase* subjectName = iData->iSubjectName->EncoderLC( ); |
|
363 CleanupStack::Pop( subjectName ); |
|
364 subject = CASN1EncExplicitTag::NewLC( subjectName, KSubjectNameTag ); |
|
365 } |
|
366 root->AddAndPopChildL( subject ); |
|
367 |
|
368 // encode issuer |
|
369 CASN1EncBase* issuer = iData->iIssuer->EncoderLC(); |
|
370 root->AddAndPopChildL( issuer ); |
|
371 |
|
372 // encode signature |
|
373 CASN1EncBase* signature = iData->iSignature->EncoderLC(); |
|
374 root->AddAndPopChildL( signature ); |
|
375 |
|
376 // encode serialNumber |
|
377 CASN1EncInt* serialNumber = CASN1EncInt::NewLC( iData->iSerialNumber ); |
|
378 root->AddAndPopChildL( serialNumber ); |
|
379 |
|
380 // encode attCertValidityPeriod |
|
381 CASN1EncSequence* validityPeriod = CASN1EncSequence::NewLC( ); |
|
382 // encode notBeforeTime |
|
383 CASN1EncGeneralizedTime* notBeforeTime = |
|
384 CASN1EncGeneralizedTime::NewLC( iData->iNotBeforeTime ); |
|
385 validityPeriod->AddAndPopChildL( notBeforeTime ); |
|
386 //encode notAfterTime |
|
387 CASN1EncGeneralizedTime* notAfterTime = |
|
388 CASN1EncGeneralizedTime::NewLC( iData->iNotAfterTime ); |
|
389 validityPeriod->AddAndPopChildL( notAfterTime ); |
|
390 root->AddAndPopChildL( validityPeriod ); |
|
391 |
|
392 // encode attributes SEQUENCE OF Attribute |
|
393 CASN1EncSequence* attributes = CASN1EncSequence::NewLC(); |
|
394 TInt attributeCount = iData->iAttributes->Count(); |
|
395 for( TInt i = 0; i < attributeCount; i++ ) |
|
396 { |
|
397 CCMSAttribute* attribute = iData->iAttributes->At( i ); |
|
398 CASN1EncBase* attributeEncoder = attribute->EncoderLC( ); |
|
399 attributes->AddAndPopChildL( attributeEncoder ); |
|
400 } |
|
401 root->AddAndPopChildL( attributes ); |
|
402 |
|
403 // encode issuerUniqueID UniqueIdentifier OPTIONAL |
|
404 if( iData->iIssuerUniqueID ) |
|
405 { |
|
406 CASN1EncBitString* uniqueID = |
|
407 CASN1EncBitString::NewLC( *( iData->iIssuerUniqueID ) ); |
|
408 root->AddAndPopChildL( uniqueID ); |
|
409 } |
|
410 |
|
411 return root; |
|
412 } |
|
413 |
|
414 // ----------------------------------------------------------------------------- |
|
415 // CCMSX509AttributeCertificateInfo::Version() |
|
416 // Getter for Version |
|
417 // ----------------------------------------------------------------------------- |
|
418 EXPORT_C TInt CCMSX509AttributeCertificateInfo::Version() const |
|
419 { |
|
420 return iData->iVersion; |
|
421 } |
|
422 |
|
423 // ----------------------------------------------------------------------------- |
|
424 // CCMSX509AttributeCertificateInfo::BaseCertificateID() |
|
425 // Getter for baseCertificateID |
|
426 // ----------------------------------------------------------------------------- |
|
427 EXPORT_C const CCMSX509IssuerSerial* |
|
428 CCMSX509AttributeCertificateInfo::BaseCertificateID() const |
|
429 { |
|
430 return iData->iBaseCertificateID; |
|
431 } |
|
432 |
|
433 // ----------------------------------------------------------------------------- |
|
434 // CCMSX509AttributeCertificateInfo::SubjectName() |
|
435 // Getter for subjectName |
|
436 // ----------------------------------------------------------------------------- |
|
437 EXPORT_C const CCMSX509GeneralNames* |
|
438 CCMSX509AttributeCertificateInfo::SubjectName() const |
|
439 { |
|
440 return iData->iSubjectName; |
|
441 } |
|
442 |
|
443 // ----------------------------------------------------------------------------- |
|
444 // CCMSX509AttributeCertificateInfo::Issuer() |
|
445 // Getter for Issuer |
|
446 // ----------------------------------------------------------------------------- |
|
447 EXPORT_C const CCMSX509GeneralNames& |
|
448 CCMSX509AttributeCertificateInfo::Issuer() const |
|
449 { |
|
450 return *iData->iIssuer; |
|
451 } |
|
452 |
|
453 // ----------------------------------------------------------------------------- |
|
454 // CCMSX509AttributeCertificateInfo::Signature() |
|
455 // Getter for signature |
|
456 // ----------------------------------------------------------------------------- |
|
457 EXPORT_C const CCMSX509AlgorithmIdentifier& |
|
458 CCMSX509AttributeCertificateInfo::Signature() const |
|
459 { |
|
460 return *iData->iSignature; |
|
461 } |
|
462 |
|
463 // ----------------------------------------------------------------------------- |
|
464 // CCMSX509AttributeCertificateInfo::SerialNumber() |
|
465 // Getter for serialNumber |
|
466 // ----------------------------------------------------------------------------- |
|
467 EXPORT_C TInt |
|
468 CCMSX509AttributeCertificateInfo::SerialNumber() const |
|
469 { |
|
470 return iData->iSerialNumber; |
|
471 } |
|
472 |
|
473 // ----------------------------------------------------------------------------- |
|
474 // CCMSX509AttributeCertificateInfo::NotBeforeTime() |
|
475 // Getter for notBeforeTime |
|
476 // ----------------------------------------------------------------------------- |
|
477 EXPORT_C const TTime& CCMSX509AttributeCertificateInfo::NotBeforeTime() const |
|
478 { |
|
479 return iData->iNotBeforeTime; |
|
480 } |
|
481 |
|
482 // ----------------------------------------------------------------------------- |
|
483 // CCMSX509AttributeCertificateInfo::NotAfterTime() |
|
484 // Getter for notAfterTime |
|
485 // ----------------------------------------------------------------------------- |
|
486 EXPORT_C const TTime& CCMSX509AttributeCertificateInfo::NotAfterTime() const |
|
487 { |
|
488 return iData->iNotAfterTime; |
|
489 } |
|
490 |
|
491 // ----------------------------------------------------------------------------- |
|
492 // CCMSX509AttributeCertificateInfo::Attributes() |
|
493 // Getter for Attributes |
|
494 // ----------------------------------------------------------------------------- |
|
495 EXPORT_C const CArrayPtr<CCMSAttribute>& |
|
496 CCMSX509AttributeCertificateInfo::Attributes() const |
|
497 { |
|
498 return *iData->iAttributes; |
|
499 } |
|
500 |
|
501 // ----------------------------------------------------------------------------- |
|
502 // CCMSX509AttributeCertificateInfo::IssuerUniqueID() |
|
503 // Getter for subjectName |
|
504 // ----------------------------------------------------------------------------- |
|
505 EXPORT_C const TDesC8* |
|
506 CCMSX509AttributeCertificateInfo::IssuerUniqueID() const |
|
507 { |
|
508 return iData->iIssuerUniqueID; |
|
509 } |
|
510 |
|
511 |
|
512 // ----------------------------------------------------------------------------- |
|
513 // CCMSX509AttributeCertificateInfo::SetVersion() |
|
514 // Setter for version |
|
515 // ----------------------------------------------------------------------------- |
|
516 EXPORT_C void CCMSX509AttributeCertificateInfo::SetVersion( |
|
517 const TInt aVersion ) |
|
518 { |
|
519 iData->iVersion = aVersion; |
|
520 } |
|
521 |
|
522 // ----------------------------------------------------------------------------- |
|
523 // CCMSX509AttributeCertificateInfo::SetBaseCertificateIDL() |
|
524 // Setter for baseCertificateID, deletes also subjectName |
|
525 // ----------------------------------------------------------------------------- |
|
526 EXPORT_C void CCMSX509AttributeCertificateInfo::SetBaseCertificateIDL( |
|
527 const CCMSX509IssuerSerial& aBaseCertificateID ) |
|
528 { |
|
529 CCMSX509IssuerSerial* id = CCMSX509IssuerSerial::NewL( |
|
530 aBaseCertificateID.Issuer(), aBaseCertificateID.Serial() ); |
|
531 CleanupStack::PushL( id ); |
|
532 const TDesC8* uid = aBaseCertificateID.IssuerUID(); |
|
533 if( uid ) |
|
534 { |
|
535 id->SetIssuerUIDL( *uid ); |
|
536 } |
|
537 CleanupStack::Pop( id ); |
|
538 delete iData->iBaseCertificateID; |
|
539 iData->iBaseCertificateID = id; |
|
540 delete iData->iSubjectName; |
|
541 iData->iSubjectName = NULL; |
|
542 } |
|
543 |
|
544 // ----------------------------------------------------------------------------- |
|
545 // CCMSX509AttributeCertificateInfo::SetSubjectNameL() |
|
546 // Setter for subjectName, deletes also baseCertificateID |
|
547 // ----------------------------------------------------------------------------- |
|
548 EXPORT_C void CCMSX509AttributeCertificateInfo::SetSubjectNameL( |
|
549 const CCMSX509GeneralNames& aSubjectName ) |
|
550 { |
|
551 CCMSX509GeneralNames* subjectName = |
|
552 CCMSX509GeneralNames::NewL( aSubjectName ); |
|
553 delete iData->iSubjectName; |
|
554 iData->iSubjectName = subjectName; |
|
555 delete iData->iBaseCertificateID; |
|
556 iData->iBaseCertificateID = NULL; |
|
557 } |
|
558 |
|
559 // ----------------------------------------------------------------------------- |
|
560 // CCMSX509AttributeCertificateInfo::SetIssuerL() |
|
561 // Setter for Issuer |
|
562 // ----------------------------------------------------------------------------- |
|
563 EXPORT_C void CCMSX509AttributeCertificateInfo::SetIssuerL( |
|
564 const CCMSX509GeneralNames& aIssuer ) |
|
565 { |
|
566 CCMSX509GeneralNames* issuer = CCMSX509GeneralNames::NewL( aIssuer ); |
|
567 delete iData->iIssuer; |
|
568 iData->iIssuer = issuer; |
|
569 } |
|
570 |
|
571 // ----------------------------------------------------------------------------- |
|
572 // CCMSX509AttributeCertificateInfo::SetSignatureL() |
|
573 // Setter for Signature |
|
574 // ----------------------------------------------------------------------------- |
|
575 EXPORT_C void CCMSX509AttributeCertificateInfo::SetSignatureL( |
|
576 const CCMSX509AlgorithmIdentifier& aSignature ) |
|
577 { |
|
578 CCMSX509AlgorithmIdentifier* signature = |
|
579 CCMSX509AlgorithmIdentifier::NewL( aSignature.AlgorithmIdentifier() ); |
|
580 CleanupStack::PushL( signature ); |
|
581 const CAlgorithmIdentifier* digestIdentifier = |
|
582 aSignature.DigestAlgorithm(); |
|
583 if( digestIdentifier ) |
|
584 { |
|
585 signature->SetDigestAlgorithmL( digestIdentifier ); |
|
586 } |
|
587 CleanupStack::Pop( signature ); |
|
588 delete iData->iSignature; |
|
589 iData->iSignature = signature; |
|
590 } |
|
591 |
|
592 // ----------------------------------------------------------------------------- |
|
593 // CCMSX509AttributeCertificateInfo::SetSerialNumber() |
|
594 // Setter for serialNumber |
|
595 // ----------------------------------------------------------------------------- |
|
596 EXPORT_C void CCMSX509AttributeCertificateInfo::SetSerialNumber( |
|
597 const TInt aSerialNumber ) |
|
598 { |
|
599 iData->iSerialNumber = aSerialNumber; |
|
600 } |
|
601 |
|
602 // ----------------------------------------------------------------------------- |
|
603 // CCMSX509AttributeCertificateInfo::SetNotBeforeTimeL() |
|
604 // Setter for notBeforeTime |
|
605 // ----------------------------------------------------------------------------- |
|
606 EXPORT_C void CCMSX509AttributeCertificateInfo::SetNotBeforeTimeL( |
|
607 const TTime& aNotBeforeTime ) |
|
608 { |
|
609 iData->iNotBeforeTime = aNotBeforeTime; |
|
610 } |
|
611 |
|
612 // ----------------------------------------------------------------------------- |
|
613 // CCMSX509AttributeCertificateInfo::SetNotAfterTimeL() |
|
614 // Setter for notAfterTime |
|
615 // ----------------------------------------------------------------------------- |
|
616 EXPORT_C void CCMSX509AttributeCertificateInfo::SetNotAfterTimeL( |
|
617 const TTime& aNotAfterTime ) |
|
618 { |
|
619 iData->iNotAfterTime = aNotAfterTime; |
|
620 } |
|
621 |
|
622 // ----------------------------------------------------------------------------- |
|
623 // CCMSX509AttributeCertificateInfo::SetAttributesL() |
|
624 // Setter for attributes |
|
625 // ----------------------------------------------------------------------------- |
|
626 EXPORT_C void CCMSX509AttributeCertificateInfo::SetAttributesL( |
|
627 const CArrayPtr< CCMSAttribute >& aAttributes ) |
|
628 { |
|
629 TInt attributeCount = aAttributes.Count(); |
|
630 CArrayPtr< CCMSAttribute >* attributes = NULL; |
|
631 if( attributeCount > 0 ) |
|
632 { |
|
633 attributes = |
|
634 new( ELeave ) CArrayPtrFlat< CCMSAttribute >( attributeCount ); |
|
635 CleanupStack::PushL( attributes ); |
|
636 for( TInt i = 0; i < attributeCount; i++ ) |
|
637 { |
|
638 const CCMSAttribute* origAttribute = aAttributes[ i ]; |
|
639 CCMSAttribute* attribute = |
|
640 CCMSAttribute::NewLC( origAttribute->AttributeType(), |
|
641 origAttribute->AttributeValues() ); |
|
642 attributes->AppendL( attribute ); |
|
643 } |
|
644 |
|
645 CleanupStack::Pop( attributeCount ); // all attributes |
|
646 CleanupStack::Pop( attributes ); |
|
647 } |
|
648 else |
|
649 { |
|
650 attributes = |
|
651 new( ELeave ) CArrayPtrFlat< CCMSAttribute >( KDefaultGranularity ); |
|
652 } |
|
653 |
|
654 |
|
655 if( iData->iAttributes ) |
|
656 { |
|
657 iData->iAttributes->ResetAndDestroy(); |
|
658 delete iData->iAttributes; |
|
659 } |
|
660 iData->iAttributes = attributes; |
|
661 |
|
662 } |
|
663 |
|
664 // ----------------------------------------------------------------------------- |
|
665 // CCMSX509AttributeCertificateInfo::SetIssuerUniqueIDL() |
|
666 // Setter for issuerUniqueID |
|
667 // ----------------------------------------------------------------------------- |
|
668 EXPORT_C void CCMSX509AttributeCertificateInfo::SetIssuerUniqueIDL( |
|
669 const TDesC8& aIssuerUniqueID ) |
|
670 { |
|
671 HBufC8* uniqueId = aIssuerUniqueID.AllocL(); |
|
672 delete iData->iIssuerUniqueID; |
|
673 iData->iIssuerUniqueID = uniqueId; |
|
674 } |
|
675 |
|
676 // End of File |