OLD | NEW |
1 /* This Source Code Form is subject to the terms of the Mozilla Public | 1 /* This Source Code Form is subject to the terms of the Mozilla Public |
2 * License, v. 2.0. If a copy of the MPL was not distributed with this | 2 * License, v. 2.0. If a copy of the MPL was not distributed with this |
3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | 3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ |
4 | 4 |
5 #include "cert.h" | 5 #include "cert.h" |
6 #include "secoid.h" | 6 #include "secoid.h" |
7 #include "secder.h"» /* XXX remove this when remove the DERTemplates */ | 7 #include "secder.h" /* XXX remove this when remove the DERTemplates */ |
8 #include "secasn1.h" | 8 #include "secasn1.h" |
9 #include "secitem.h" | 9 #include "secitem.h" |
10 #include <stdarg.h> | 10 #include <stdarg.h> |
11 #include "secerr.h" | 11 #include "secerr.h" |
12 #include "certi.h" | 12 #include "certi.h" |
13 | 13 |
14 static const SEC_ASN1Template cert_AVATemplate[] = { | 14 static const SEC_ASN1Template cert_AVATemplate[] = { |
15 { SEC_ASN1_SEQUENCE, | 15 { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(CERTAVA) }, |
16 » 0, NULL, sizeof(CERTAVA) }, | 16 { SEC_ASN1_OBJECT_ID, offsetof(CERTAVA, type) }, |
17 { SEC_ASN1_OBJECT_ID, | 17 { SEC_ASN1_ANY, offsetof(CERTAVA, value) }, |
18 » offsetof(CERTAVA,type) }, | |
19 { SEC_ASN1_ANY, | |
20 » offsetof(CERTAVA,value) }, | |
21 { 0 } | 18 { 0 } |
22 }; | 19 }; |
23 | 20 |
24 const SEC_ASN1Template CERT_RDNTemplate[] = { | 21 const SEC_ASN1Template CERT_RDNTemplate[] = { |
25 { SEC_ASN1_SET_OF, | 22 { SEC_ASN1_SET_OF, offsetof(CERTRDN, avas), cert_AVATemplate, |
26 » offsetof(CERTRDN,avas), cert_AVATemplate, sizeof(CERTRDN) } | 23 sizeof(CERTRDN) } |
27 }; | 24 }; |
28 | 25 |
29 | |
30 static int | 26 static int |
31 CountArray(void **array) | 27 CountArray(void **array) |
32 { | 28 { |
33 int count = 0; | 29 int count = 0; |
34 if (array) { | 30 if (array) { |
35 » while (*array++) { | 31 while (*array++) { |
36 » count++; | 32 count++; |
37 » } | 33 } |
38 } | 34 } |
39 return count; | 35 return count; |
40 } | 36 } |
41 | 37 |
42 static void ** | 38 static void ** |
43 AddToArray(PLArenaPool *arena, void **array, void *element) | 39 AddToArray(PLArenaPool *arena, void **array, void *element) |
44 { | 40 { |
45 unsigned count; | 41 unsigned count; |
46 void **ap; | 42 void **ap; |
47 | 43 |
48 /* Count up number of slots already in use in the array */ | 44 /* Count up number of slots already in use in the array */ |
49 count = 0; | 45 count = 0; |
50 ap = array; | 46 ap = array; |
51 if (ap) { | 47 if (ap) { |
52 » while (*ap++) { | 48 while (*ap++) { |
53 » count++; | 49 count++; |
54 » } | 50 } |
55 } | 51 } |
56 | 52 |
57 if (array) { | 53 if (array) { |
58 » array = (void**) PORT_ArenaGrow(arena, array, | 54 array = |
59 » » » » » (count + 1) * sizeof(void *), | 55 (void **)PORT_ArenaGrow(arena, array, (count + 1) * sizeof(void *), |
60 » » » » » (count + 2) * sizeof(void *)); | 56 (count + 2) * sizeof(void *)); |
61 } else { | 57 } |
62 » array = (void**) PORT_ArenaAlloc(arena, (count + 2) * sizeof(void *)); | 58 else { |
| 59 array = (void **)PORT_ArenaAlloc(arena, (count + 2) * sizeof(void *)); |
63 } | 60 } |
64 if (array) { | 61 if (array) { |
65 » array[count] = element; | 62 array[count] = element; |
66 » array[count+1] = 0; | 63 array[count + 1] = 0; |
67 } | 64 } |
68 return array; | 65 return array; |
69 } | 66 } |
70 | 67 |
71 | |
72 SECOidTag | 68 SECOidTag |
73 CERT_GetAVATag(CERTAVA *ava) | 69 CERT_GetAVATag(CERTAVA *ava) |
74 { | 70 { |
75 SECOidData *oid; | 71 SECOidData *oid; |
76 if (!ava->type.data) return (SECOidTag)-1; | 72 if (!ava->type.data) |
| 73 return (SECOidTag)-1; |
77 | 74 |
78 oid = SECOID_FindOID(&ava->type); | 75 oid = SECOID_FindOID(&ava->type); |
79 | 76 |
80 if ( oid ) { | 77 if (oid) { |
81 » return(oid->offset); | 78 return (oid->offset); |
82 } | 79 } |
83 return (SECOidTag)-1; | 80 return (SECOidTag)-1; |
84 } | 81 } |
85 | 82 |
86 static SECStatus | 83 static SECStatus |
87 SetupAVAType(PLArenaPool *arena, SECOidTag type, SECItem *it, unsigned *maxLenp) | 84 SetupAVAType(PLArenaPool *arena, SECOidTag type, SECItem *it, unsigned *maxLenp) |
88 { | 85 { |
89 unsigned char *oid; | 86 unsigned char *oid; |
90 unsigned oidLen; | 87 unsigned oidLen; |
91 unsigned char *cp; | 88 unsigned char *cp; |
92 int maxLen; | 89 int maxLen; |
93 SECOidData *oidrec; | 90 SECOidData *oidrec; |
94 | 91 |
95 oidrec = SECOID_FindOIDByTag(type); | 92 oidrec = SECOID_FindOIDByTag(type); |
96 if (oidrec == NULL) | 93 if (oidrec == NULL) |
97 » return SECFailure; | 94 return SECFailure; |
98 | 95 |
99 oid = oidrec->oid.data; | 96 oid = oidrec->oid.data; |
100 oidLen = oidrec->oid.len; | 97 oidLen = oidrec->oid.len; |
101 | 98 |
102 maxLen = cert_AVAOidTagToMaxLen(type); | 99 maxLen = cert_AVAOidTagToMaxLen(type); |
103 if (maxLen < 0) { | 100 if (maxLen < 0) { |
104 » PORT_SetError(SEC_ERROR_INVALID_ARGS); | 101 PORT_SetError(SEC_ERROR_INVALID_ARGS); |
105 » return SECFailure; | 102 return SECFailure; |
106 } | 103 } |
107 | 104 |
108 it->data = cp = (unsigned char*) PORT_ArenaAlloc(arena, oidLen); | 105 it->data = cp = (unsigned char *)PORT_ArenaAlloc(arena, oidLen); |
109 if (cp == NULL) { | 106 if (cp == NULL) { |
110 » return SECFailure; | 107 return SECFailure; |
111 } | 108 } |
112 it->len = oidLen; | 109 it->len = oidLen; |
113 PORT_Memcpy(cp, oid, oidLen); | 110 PORT_Memcpy(cp, oid, oidLen); |
114 *maxLenp = (unsigned)maxLen; | 111 *maxLenp = (unsigned)maxLen; |
115 return SECSuccess; | 112 return SECSuccess; |
116 } | 113 } |
117 | 114 |
118 static SECStatus | 115 static SECStatus |
119 SetupAVAValue(PLArenaPool *arena, int valueType, const SECItem *in, | 116 SetupAVAValue(PLArenaPool *arena, int valueType, const SECItem *in, |
120 SECItem *out, unsigned maxLen) | 117 SECItem *out, unsigned maxLen) |
121 { | 118 { |
122 PRUint8 *value, *cp, *ucs4Val; | 119 PRUint8 *value, *cp, *ucs4Val; |
123 unsigned valueLen, valueLenLen, total; | 120 unsigned valueLen, valueLenLen, total; |
124 unsigned ucs4Len = 0, ucs4MaxLen; | 121 unsigned ucs4Len = 0, ucs4MaxLen; |
125 | 122 |
126 value = in->data; | 123 value = in->data; |
127 valueLen = in->len; | 124 valueLen = in->len; |
128 switch (valueType) { | 125 switch (valueType) { |
129 case SEC_ASN1_PRINTABLE_STRING: | 126 case SEC_ASN1_PRINTABLE_STRING: |
130 case SEC_ASN1_IA5_STRING: | 127 case SEC_ASN1_IA5_STRING: |
131 case SEC_ASN1_T61_STRING: | 128 case SEC_ASN1_T61_STRING: |
132 case SEC_ASN1_UTF8_STRING: /* no conversion required */ | 129 case SEC_ASN1_UTF8_STRING: /* no conversion required */ |
133 » break; | 130 break; |
134 case SEC_ASN1_UNIVERSAL_STRING: | 131 case SEC_ASN1_UNIVERSAL_STRING: |
135 » ucs4MaxLen = valueLen * 6; | 132 ucs4MaxLen = valueLen * 6; |
136 » ucs4Val = (PRUint8 *)PORT_ArenaZAlloc(arena, ucs4MaxLen); | 133 ucs4Val = (PRUint8 *)PORT_ArenaZAlloc(arena, ucs4MaxLen); |
137 » if(!ucs4Val || !PORT_UCS4_UTF8Conversion(PR_TRUE, value, valueLen, | 134 if (!ucs4Val || |
138 » » » » » ucs4Val, ucs4MaxLen, &ucs4Len)) { | 135 !PORT_UCS4_UTF8Conversion(PR_TRUE, value, valueLen, ucs4Val, |
139 » PORT_SetError(SEC_ERROR_INVALID_ARGS); | 136 ucs4MaxLen, &ucs4Len)) { |
140 » return SECFailure; | 137 PORT_SetError(SEC_ERROR_INVALID_ARGS); |
141 » } | 138 return SECFailure; |
142 » value = ucs4Val; | 139 } |
143 » valueLen = ucs4Len; | 140 value = ucs4Val; |
144 » maxLen *= 4; | 141 valueLen = ucs4Len; |
145 » break; | 142 maxLen *= 4; |
146 default: | 143 break; |
147 » PORT_SetError(SEC_ERROR_INVALID_ARGS); | 144 default: |
148 » return SECFailure; | 145 PORT_SetError(SEC_ERROR_INVALID_ARGS); |
| 146 return SECFailure; |
149 } | 147 } |
150 | 148 |
151 if (valueLen > maxLen) { | 149 if (valueLen > maxLen) { |
152 » PORT_SetError(SEC_ERROR_INVALID_ARGS); | 150 PORT_SetError(SEC_ERROR_INVALID_ARGS); |
153 » return SECFailure; | 151 return SECFailure; |
154 } | 152 } |
155 | 153 |
156 valueLenLen = DER_LengthLength(valueLen); | 154 valueLenLen = DER_LengthLength(valueLen); |
157 total = 1 + valueLenLen + valueLen; | 155 total = 1 + valueLenLen + valueLen; |
158 cp = (PRUint8*)PORT_ArenaAlloc(arena, total); | 156 cp = (PRUint8 *)PORT_ArenaAlloc(arena, total); |
159 if (!cp) { | 157 if (!cp) { |
160 » return SECFailure; | 158 return SECFailure; |
161 } | 159 } |
162 out->data = cp; | 160 out->data = cp; |
163 out->len = total; | 161 out->len = total; |
164 cp = (PRUint8 *)DER_StoreHeader(cp, valueType, valueLen); | 162 cp = (PRUint8 *)DER_StoreHeader(cp, valueType, valueLen); |
165 PORT_Memcpy(cp, value, valueLen); | 163 PORT_Memcpy(cp, value, valueLen); |
166 return SECSuccess; | 164 return SECSuccess; |
167 } | 165 } |
168 | 166 |
169 CERTAVA * | 167 CERTAVA * |
170 CERT_CreateAVAFromRaw(PLArenaPool *pool, const SECItem * OID, | 168 CERT_CreateAVAFromRaw(PLArenaPool *pool, const SECItem *OID, |
171 const SECItem * value) | 169 const SECItem *value) |
172 { | 170 { |
173 CERTAVA *ava; | 171 CERTAVA *ava; |
174 int rv; | 172 int rv; |
175 | 173 |
176 ava = PORT_ArenaZNew(pool, CERTAVA); | 174 ava = PORT_ArenaZNew(pool, CERTAVA); |
177 if (ava) { | 175 if (ava) { |
178 » rv = SECITEM_CopyItem(pool, &ava->type, OID); | 176 rv = SECITEM_CopyItem(pool, &ava->type, OID); |
179 » if (rv)· | 177 if (rv) |
180 » return NULL; | 178 return NULL; |
181 | 179 |
182 » rv = SECITEM_CopyItem(pool, &ava->value, value); | 180 rv = SECITEM_CopyItem(pool, &ava->value, value); |
183 » if (rv)· | 181 if (rv) |
184 » return NULL; | 182 return NULL; |
185 } | 183 } |
186 return ava; | 184 return ava; |
187 } | 185 } |
188 | 186 |
189 CERTAVA * | 187 CERTAVA * |
190 CERT_CreateAVAFromSECItem(PLArenaPool *arena, SECOidTag kind, int valueType, | 188 CERT_CreateAVAFromSECItem(PLArenaPool *arena, SECOidTag kind, int valueType, |
191 SECItem *value) | 189 SECItem *value) |
192 { | 190 { |
193 CERTAVA *ava; | 191 CERTAVA *ava; |
194 int rv; | 192 int rv; |
195 unsigned maxLen; | 193 unsigned maxLen; |
196 | 194 |
197 ava = (CERTAVA*) PORT_ArenaZAlloc(arena, sizeof(CERTAVA)); | 195 ava = (CERTAVA *)PORT_ArenaZAlloc(arena, sizeof(CERTAVA)); |
198 if (ava) { | 196 if (ava) { |
199 » rv = SetupAVAType(arena, kind, &ava->type, &maxLen); | 197 rv = SetupAVAType(arena, kind, &ava->type, &maxLen); |
200 » if (rv) { | 198 if (rv) { |
201 » /* Illegal AVA type */ | 199 /* Illegal AVA type */ |
202 » return NULL; | 200 return NULL; |
203 » } | 201 } |
204 » rv = SetupAVAValue(arena, valueType, value, &ava->value, maxLen); | 202 rv = SetupAVAValue(arena, valueType, value, &ava->value, maxLen); |
205 » if (rv) { | 203 if (rv) { |
206 » /* Illegal value type */ | 204 /* Illegal value type */ |
207 » return NULL; | 205 return NULL; |
208 » } | 206 } |
209 } | 207 } |
210 return ava; | 208 return ava; |
211 } | 209 } |
212 | 210 |
213 CERTAVA * | 211 CERTAVA * |
214 CERT_CreateAVA(PLArenaPool *arena, SECOidTag kind, int valueType, char *value) | 212 CERT_CreateAVA(PLArenaPool *arena, SECOidTag kind, int valueType, char *value) |
215 { | 213 { |
216 SECItem item = { siBuffer, NULL, 0 }; | 214 SECItem item = { siBuffer, NULL, 0 }; |
217 | 215 |
218 item.data = (PRUint8 *)value; | 216 item.data = (PRUint8 *)value; |
219 item.len = PORT_Strlen(value); | 217 item.len = PORT_Strlen(value); |
220 | 218 |
221 return CERT_CreateAVAFromSECItem(arena, kind, valueType, &item); | 219 return CERT_CreateAVAFromSECItem(arena, kind, valueType, &item); |
222 } | 220 } |
223 | 221 |
224 CERTAVA * | 222 CERTAVA * |
225 CERT_CopyAVA(PLArenaPool *arena, CERTAVA *from) | 223 CERT_CopyAVA(PLArenaPool *arena, CERTAVA *from) |
226 { | 224 { |
227 CERTAVA *ava; | 225 CERTAVA *ava; |
228 int rv; | 226 int rv; |
229 | 227 |
230 ava = (CERTAVA*) PORT_ArenaZAlloc(arena, sizeof(CERTAVA)); | 228 ava = (CERTAVA *)PORT_ArenaZAlloc(arena, sizeof(CERTAVA)); |
231 if (ava) { | 229 if (ava) { |
232 » rv = SECITEM_CopyItem(arena, &ava->type, &from->type); | 230 rv = SECITEM_CopyItem(arena, &ava->type, &from->type); |
233 » if (rv) goto loser; | 231 if (rv) |
234 » rv = SECITEM_CopyItem(arena, &ava->value, &from->value); | 232 goto loser; |
235 » if (rv) goto loser; | 233 rv = SECITEM_CopyItem(arena, &ava->value, &from->value); |
| 234 if (rv) |
| 235 goto loser; |
236 } | 236 } |
237 return ava; | 237 return ava; |
238 | 238 |
239 loser: | 239 loser: |
240 return 0; | 240 return 0; |
241 } | 241 } |
242 | 242 |
243 CERTRDN * | 243 CERTRDN * |
244 CERT_CreateRDN(PLArenaPool *arena, CERTAVA *ava0, ...) | 244 CERT_CreateRDN(PLArenaPool *arena, CERTAVA *ava0, ...) |
245 { | 245 { |
246 CERTAVA *ava; | 246 CERTAVA *ava; |
247 CERTRDN *rdn; | 247 CERTRDN *rdn; |
248 va_list ap; | 248 va_list ap; |
249 unsigned count; | 249 unsigned count; |
250 CERTAVA **avap; | 250 CERTAVA **avap; |
251 | 251 |
252 rdn = (CERTRDN*) PORT_ArenaAlloc(arena, sizeof(CERTRDN)); | 252 rdn = (CERTRDN *)PORT_ArenaAlloc(arena, sizeof(CERTRDN)); |
253 if (rdn) { | 253 if (rdn) { |
254 » /* Count number of avas going into the rdn */ | 254 /* Count number of avas going into the rdn */ |
255 » count = 0; | 255 count = 0; |
256 » if (ava0) { | 256 if (ava0) { |
257 » count++; | 257 count++; |
258 » va_start(ap, ava0); | 258 va_start(ap, ava0); |
259 » while ((ava = va_arg(ap, CERTAVA*)) != 0) { | 259 while ((ava = va_arg(ap, CERTAVA *)) != 0) { |
260 » » count++; | 260 count++; |
261 » } | 261 } |
262 » va_end(ap); | 262 va_end(ap); |
263 » } | 263 } |
264 | 264 |
265 » /* Now fill in the pointers */ | 265 /* Now fill in the pointers */ |
266 » rdn->avas = avap = | 266 rdn->avas = avap = |
267 » (CERTAVA**) PORT_ArenaAlloc( arena, (count + 1)*sizeof(CERTAVA*)); | 267 (CERTAVA **)PORT_ArenaAlloc(arena, (count + 1) * sizeof(CERTAVA *)); |
268 » if (!avap) { | 268 if (!avap) { |
269 » return 0; | 269 return 0; |
270 » } | 270 } |
271 » if (ava0) { | 271 if (ava0) { |
272 » *avap++ = ava0; | 272 *avap++ = ava0; |
273 » va_start(ap, ava0); | 273 va_start(ap, ava0); |
274 » while ((ava = va_arg(ap, CERTAVA*)) != 0) { | 274 while ((ava = va_arg(ap, CERTAVA *)) != 0) { |
275 » » *avap++ = ava; | 275 *avap++ = ava; |
276 » } | 276 } |
277 » va_end(ap); | 277 va_end(ap); |
278 » } | 278 } |
279 » *avap++ = 0; | 279 *avap++ = 0; |
280 } | 280 } |
281 return rdn; | 281 return rdn; |
282 } | 282 } |
283 | 283 |
284 SECStatus | 284 SECStatus |
285 CERT_AddAVA(PLArenaPool *arena, CERTRDN *rdn, CERTAVA *ava) | 285 CERT_AddAVA(PLArenaPool *arena, CERTRDN *rdn, CERTAVA *ava) |
286 { | 286 { |
287 rdn->avas = (CERTAVA**) AddToArray(arena, (void**) rdn->avas, ava); | 287 rdn->avas = (CERTAVA **)AddToArray(arena, (void **)rdn->avas, ava); |
288 return rdn->avas ? SECSuccess : SECFailure; | 288 return rdn->avas ? SECSuccess : SECFailure; |
289 } | 289 } |
290 | 290 |
291 SECStatus | 291 SECStatus |
292 CERT_CopyRDN(PLArenaPool *arena, CERTRDN *to, CERTRDN *from) | 292 CERT_CopyRDN(PLArenaPool *arena, CERTRDN *to, CERTRDN *from) |
293 { | 293 { |
294 CERTAVA **avas, *fava, *tava; | 294 CERTAVA **avas, *fava, *tava; |
295 SECStatus rv = SECSuccess; | 295 SECStatus rv = SECSuccess; |
296 | 296 |
297 /* Copy each ava from from */ | 297 /* Copy each ava from from */ |
298 avas = from->avas; | 298 avas = from->avas; |
299 if (avas) { | 299 if (avas) { |
300 » if (avas[0] == NULL) { | 300 if (avas[0] == NULL) { |
301 » rv = CERT_AddAVA(arena, to, NULL); | 301 rv = CERT_AddAVA(arena, to, NULL); |
302 » return rv; | 302 return rv; |
303 » } | 303 } |
304 » while ((fava = *avas++) != 0) { | 304 while ((fava = *avas++) != 0) { |
305 » tava = CERT_CopyAVA(arena, fava); | 305 tava = CERT_CopyAVA(arena, fava); |
306 » if (!tava) { | 306 if (!tava) { |
307 » » rv = SECFailure; | 307 rv = SECFailure; |
308 » » break; | 308 break; |
309 » } | 309 } |
310 » rv = CERT_AddAVA(arena, to, tava); | 310 rv = CERT_AddAVA(arena, to, tava); |
311 » if (rv != SECSuccess)· | 311 if (rv != SECSuccess) |
312 » » break; | 312 break; |
313 » } | 313 } |
314 } | 314 } |
315 return rv; | 315 return rv; |
316 } | 316 } |
317 | 317 |
318 /************************************************************************/ | 318 /************************************************************************/ |
319 | 319 |
320 const SEC_ASN1Template CERT_NameTemplate[] = { | 320 const SEC_ASN1Template CERT_NameTemplate[] = { |
321 { SEC_ASN1_SEQUENCE_OF, | 321 { SEC_ASN1_SEQUENCE_OF, offsetof(CERTName, rdns), CERT_RDNTemplate, |
322 » offsetof(CERTName,rdns), CERT_RDNTemplate, sizeof(CERTName) } | 322 sizeof(CERTName) } |
323 }; | 323 }; |
324 | 324 |
325 SEC_ASN1_CHOOSER_IMPLEMENT(CERT_NameTemplate) | 325 SEC_ASN1_CHOOSER_IMPLEMENT(CERT_NameTemplate) |
326 | 326 |
327 CERTName * | 327 CERTName * |
328 CERT_CreateName(CERTRDN *rdn0, ...) | 328 CERT_CreateName(CERTRDN *rdn0, ...) |
329 { | 329 { |
330 CERTRDN *rdn; | 330 CERTRDN *rdn; |
331 CERTName *name; | 331 CERTName *name; |
332 va_list ap; | 332 va_list ap; |
333 unsigned count; | 333 unsigned count; |
334 CERTRDN **rdnp; | 334 CERTRDN **rdnp; |
335 PLArenaPool *arena; | 335 PLArenaPool *arena; |
336 | 336 |
337 arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE); | 337 arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE); |
338 if ( !arena ) { | 338 if (!arena) { |
339 » return(0); | 339 return (0); |
340 } | 340 } |
341 | 341 |
342 name = (CERTName*) PORT_ArenaAlloc(arena, sizeof(CERTName)); | 342 name = (CERTName *)PORT_ArenaAlloc(arena, sizeof(CERTName)); |
343 if (name) { | 343 if (name) { |
344 » name->arena = arena; | 344 name->arena = arena; |
345 »······· | 345 |
346 » /* Count number of RDNs going into the Name */ | 346 /* Count number of RDNs going into the Name */ |
347 » if (!rdn0) { | 347 if (!rdn0) { |
348 » count = 0; | 348 count = 0; |
349 » } else { | 349 } |
350 » count = 1; | 350 else { |
351 » va_start(ap, rdn0); | 351 count = 1; |
352 » while ((rdn = va_arg(ap, CERTRDN*)) != 0) { | 352 va_start(ap, rdn0); |
353 » » count++; | 353 while ((rdn = va_arg(ap, CERTRDN *)) != 0) { |
354 » } | 354 count++; |
355 » va_end(ap); | 355 } |
356 » } | 356 va_end(ap); |
357 | 357 } |
358 » /* Allocate space (including space for terminal null ptr) */ | 358 |
359 » name->rdns = rdnp = | 359 /* Allocate space (including space for terminal null ptr) */ |
360 » (CERTRDN**) PORT_ArenaAlloc(arena, (count + 1) * sizeof(CERTRDN*)); | 360 name->rdns = rdnp = |
361 » if (!name->rdns) { | 361 (CERTRDN **)PORT_ArenaAlloc(arena, (count + 1) * sizeof(CERTRDN *)); |
362 » goto loser; | 362 if (!name->rdns) { |
363 » } | 363 goto loser; |
364 | 364 } |
365 » /* Now fill in the pointers */ | 365 |
366 » if (count > 0) { | 366 /* Now fill in the pointers */ |
367 » *rdnp++ = rdn0; | 367 if (count > 0) { |
368 » va_start(ap, rdn0); | 368 *rdnp++ = rdn0; |
369 » while ((rdn = va_arg(ap, CERTRDN*)) != 0) { | 369 va_start(ap, rdn0); |
370 » » *rdnp++ = rdn; | 370 while ((rdn = va_arg(ap, CERTRDN *)) != 0) { |
371 » } | 371 *rdnp++ = rdn; |
372 » va_end(ap); | 372 } |
373 » } | 373 va_end(ap); |
374 | 374 } |
375 » /* null terminate the list */ | 375 |
376 » *rdnp++ = 0; | 376 /* null terminate the list */ |
| 377 *rdnp++ = 0; |
377 } | 378 } |
378 return name; | 379 return name; |
379 | 380 |
380 loser: | 381 loser: |
381 PORT_FreeArena(arena, PR_FALSE); | 382 PORT_FreeArena(arena, PR_FALSE); |
382 return(0); | 383 return (0); |
383 } | 384 } |
384 | 385 |
385 void | 386 void |
386 CERT_DestroyName(CERTName *name) | 387 CERT_DestroyName(CERTName *name) |
387 { | 388 { |
388 if (name) | 389 if (name) { |
389 { | |
390 PLArenaPool *arena = name->arena; | 390 PLArenaPool *arena = name->arena; |
391 name->rdns = NULL; | 391 name->rdns = NULL; |
392 » name->arena = NULL; | 392 name->arena = NULL; |
393 » if (arena) PORT_FreeArena(arena, PR_FALSE); | 393 if (arena) |
| 394 PORT_FreeArena(arena, PR_FALSE); |
394 } | 395 } |
395 } | 396 } |
396 | 397 |
397 SECStatus | 398 SECStatus |
398 CERT_AddRDN(CERTName *name, CERTRDN *rdn) | 399 CERT_AddRDN(CERTName *name, CERTRDN *rdn) |
399 { | 400 { |
400 name->rdns = (CERTRDN**) AddToArray(name->arena, (void**) name->rdns, rdn); | 401 name->rdns = (CERTRDN **)AddToArray(name->arena, (void **)name->rdns, rdn); |
401 return name->rdns ? SECSuccess : SECFailure; | 402 return name->rdns ? SECSuccess : SECFailure; |
402 } | 403 } |
403 | 404 |
404 SECStatus | 405 SECStatus |
405 CERT_CopyName(PLArenaPool *arena, CERTName *to, const CERTName *from) | 406 CERT_CopyName(PLArenaPool *arena, CERTName *to, const CERTName *from) |
406 { | 407 { |
407 CERTRDN **rdns, *frdn, *trdn; | 408 CERTRDN **rdns, *frdn, *trdn; |
408 SECStatus rv = SECSuccess; | 409 SECStatus rv = SECSuccess; |
409 | 410 |
410 if (!to || !from) { | 411 if (!to || !from) { |
411 » PORT_SetError(SEC_ERROR_INVALID_ARGS); | 412 PORT_SetError(SEC_ERROR_INVALID_ARGS); |
412 » return SECFailure; | 413 return SECFailure; |
413 } | 414 } |
414 | 415 |
415 CERT_DestroyName(to); | 416 CERT_DestroyName(to); |
416 to->arena = arena; | 417 to->arena = arena; |
417 | 418 |
418 /* Copy each rdn from from */ | 419 /* Copy each rdn from from */ |
419 rdns = from->rdns; | 420 rdns = from->rdns; |
420 if (rdns) { | 421 if (rdns) { |
421 » if (rdns[0] == NULL) { | 422 if (rdns[0] == NULL) { |
422 » rv = CERT_AddRDN(to, NULL); | 423 rv = CERT_AddRDN(to, NULL); |
423 » return rv; | 424 return rv; |
424 » } | 425 } |
425 » while ((frdn = *rdns++) != NULL) { | 426 while ((frdn = *rdns++) != NULL) { |
426 » trdn = CERT_CreateRDN(arena, NULL); | 427 trdn = CERT_CreateRDN(arena, NULL); |
427 » if (!trdn) { | 428 if (!trdn) { |
428 » » rv = SECFailure; | 429 rv = SECFailure; |
429 » » break; | 430 break; |
430 » } | 431 } |
431 » rv = CERT_CopyRDN(arena, trdn, frdn); | 432 rv = CERT_CopyRDN(arena, trdn, frdn); |
432 » if (rv != SECSuccess)· | 433 if (rv != SECSuccess) |
433 » break; | 434 break; |
434 » rv = CERT_AddRDN(to, trdn); | 435 rv = CERT_AddRDN(to, trdn); |
435 » if (rv != SECSuccess)· | 436 if (rv != SECSuccess) |
436 » break; | 437 break; |
437 » } | 438 } |
438 } | 439 } |
439 return rv; | 440 return rv; |
440 } | 441 } |
441 | 442 |
442 /************************************************************************/ | 443 /************************************************************************/ |
443 | 444 |
444 static void | 445 static void |
445 canonicalize(SECItem * foo) | 446 canonicalize(SECItem *foo) |
446 { | 447 { |
447 int ch, lastch, len, src, dest; | 448 int ch, lastch, len, src, dest; |
448 | 449 |
449 /* strip trailing whitespace. */ | 450 /* strip trailing whitespace. */ |
450 len = foo->len; | 451 len = foo->len; |
451 while (len > 0 && ((ch = foo->data[len - 1]) == ' ' ||· | 452 while (len > 0 && ((ch = foo->data[len - 1]) == ' ' || ch == '\t' || |
452 ch == '\t' || ch == '\r' || ch == '\n')) { | 453 ch == '\r' || ch == '\n')) { |
453 » len--; | 454 len--; |
454 } | 455 } |
455 | 456 |
456 src = 0; | 457 src = 0; |
457 /* strip leading whitespace. */ | 458 /* strip leading whitespace. */ |
458 while (src < len && ((ch = foo->data[src]) == ' ' ||· | 459 while (src < len && ((ch = foo->data[src]) == ' ' || ch == '\t' || |
459 ch == '\t' || ch == '\r' || ch == '\n')) { | 460 ch == '\r' || ch == '\n')) { |
460 » src++; | 461 src++; |
461 } | 462 } |
462 dest = 0; lastch = ' '; | 463 dest = 0; |
| 464 lastch = ' '; |
463 while (src < len) { | 465 while (src < len) { |
464 ch = foo->data[src++]; | 466 ch = foo->data[src++]; |
465 » if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n') { | 467 if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n') { |
466 » ch = ' '; | 468 ch = ' '; |
467 » if (ch == lastch) | 469 if (ch == lastch) |
468 » continue; | 470 continue; |
469 » } else if (ch >= 'A' && ch <= 'Z') { | 471 } |
470 » ch |= 0x20; /* downshift */ | 472 else if (ch >= 'A' && ch <= 'Z') { |
471 » } | 473 ch |= 0x20; /* downshift */ |
472 » foo->data[dest++] = lastch = ch; | 474 } |
| 475 foo->data[dest++] = lastch = ch; |
473 } | 476 } |
474 foo->len = dest; | 477 foo->len = dest; |
475 } | 478 } |
476 | 479 |
477 /* SECItems a and b contain DER-encoded printable strings. */ | 480 /* SECItems a and b contain DER-encoded printable strings. */ |
478 SECComparison | 481 SECComparison |
479 CERT_CompareDERPrintableStrings(const SECItem *a, const SECItem *b) | 482 CERT_CompareDERPrintableStrings(const SECItem *a, const SECItem *b) |
480 { | 483 { |
481 SECComparison rv = SECLessThan; | 484 SECComparison rv = SECLessThan; |
482 SECItem * aVal = CERT_DecodeAVAValue(a); | 485 SECItem *aVal = CERT_DecodeAVAValue(a); |
483 SECItem * bVal = CERT_DecodeAVAValue(b); | 486 SECItem *bVal = CERT_DecodeAVAValue(b); |
484 | 487 |
485 if (aVal && aVal->len && aVal->data && | 488 if (aVal && aVal->len && aVal->data && bVal && bVal->len && bVal->data) { |
486 » bVal && bVal->len && bVal->data) { | 489 canonicalize(aVal); |
487 » canonicalize(aVal); | 490 canonicalize(bVal); |
488 » canonicalize(bVal); | 491 rv = SECITEM_CompareItem(aVal, bVal); |
489 » rv = SECITEM_CompareItem(aVal, bVal); | |
490 } | 492 } |
491 SECITEM_FreeItem(aVal, PR_TRUE); | 493 SECITEM_FreeItem(aVal, PR_TRUE); |
492 SECITEM_FreeItem(bVal, PR_TRUE); | 494 SECITEM_FreeItem(bVal, PR_TRUE); |
493 return rv; | 495 return rv; |
494 } | 496 } |
495 | 497 |
496 SECComparison | 498 SECComparison |
497 CERT_CompareAVA(const CERTAVA *a, const CERTAVA *b) | 499 CERT_CompareAVA(const CERTAVA *a, const CERTAVA *b) |
498 { | 500 { |
499 SECComparison rv; | 501 SECComparison rv; |
500 | 502 |
501 rv = SECITEM_CompareItem(&a->type, &b->type); | 503 rv = SECITEM_CompareItem(&a->type, &b->type); |
502 if (SECEqual != rv) | 504 if (SECEqual != rv) |
503 » return rv; /* Attribute types don't match. */ | 505 return rv; /* Attribute types don't match. */ |
504 /* Let's be optimistic. Maybe the values will just compare equal. */ | 506 /* Let's be optimistic. Maybe the values will just compare equal. */ |
505 rv = SECITEM_CompareItem(&a->value, &b->value); | 507 rv = SECITEM_CompareItem(&a->value, &b->value); |
506 if (SECEqual == rv) | 508 if (SECEqual == rv) |
507 return rv; /* values compared exactly. */ | 509 return rv; /* values compared exactly. */ |
508 if (a->value.len && a->value.data && b->value.len && b->value.data) { | 510 if (a->value.len && a->value.data && b->value.len && b->value.data) { |
509 » /* Here, the values did not match.·· | 511 /* Here, the values did not match. |
510 » ** If the values had different encodings, convert them to the same | 512 ** If the values had different encodings, convert them to the same |
511 » ** encoding and compare that way. | 513 ** encoding and compare that way. |
512 » */ | 514 */ |
513 » if (a->value.data[0] != b->value.data[0]) { | 515 if (a->value.data[0] != b->value.data[0]) { |
514 » /* encodings differ. Convert both to UTF-8 and compare. */ | 516 /* encodings differ. Convert both to UTF-8 and compare. */ |
515 » SECItem * aVal = CERT_DecodeAVAValue(&a->value); | 517 SECItem *aVal = CERT_DecodeAVAValue(&a->value); |
516 » SECItem * bVal = CERT_DecodeAVAValue(&b->value); | 518 SECItem *bVal = CERT_DecodeAVAValue(&b->value); |
517 » if (aVal && aVal->len && aVal->data && | 519 if (aVal && aVal->len && aVal->data && bVal && bVal->len && |
518 » bVal && bVal->len && bVal->data) { | 520 bVal->data) { |
519 » » rv = SECITEM_CompareItem(aVal, bVal); | 521 rv = SECITEM_CompareItem(aVal, bVal); |
520 » } | 522 } |
521 » SECITEM_FreeItem(aVal, PR_TRUE); | 523 SECITEM_FreeItem(aVal, PR_TRUE); |
522 » SECITEM_FreeItem(bVal, PR_TRUE); | 524 SECITEM_FreeItem(bVal, PR_TRUE); |
523 » } else if (a->value.data[0] == 0x13) { /* both are printable strings. */ | 525 } |
524 » /* printable strings */ | 526 else if (a->value.data[0] == 0x13) { /* both are printable strings. */ |
525 » rv = CERT_CompareDERPrintableStrings(&a->value, &b->value); | 527 /* printable strings */ |
526 » } | 528 rv = CERT_CompareDERPrintableStrings(&a->value, &b->value); |
| 529 } |
527 } | 530 } |
528 return rv; | 531 return rv; |
529 } | 532 } |
530 | 533 |
531 SECComparison | 534 SECComparison |
532 CERT_CompareRDN(const CERTRDN *a, const CERTRDN *b) | 535 CERT_CompareRDN(const CERTRDN *a, const CERTRDN *b) |
533 { | 536 { |
534 CERTAVA **aavas, *aava; | 537 CERTAVA **aavas, *aava; |
535 CERTAVA **bavas, *bava; | 538 CERTAVA **bavas, *bava; |
536 int ac, bc; | 539 int ac, bc; |
537 SECComparison rv = SECEqual; | 540 SECComparison rv = SECEqual; |
538 | 541 |
539 aavas = a->avas; | 542 aavas = a->avas; |
540 bavas = b->avas; | 543 bavas = b->avas; |
541 | 544 |
542 /* | 545 /* |
543 ** Make sure array of ava's are the same length. If not, then we are | 546 ** Make sure array of ava's are the same length. If not, then we are |
544 ** not equal | 547 ** not equal |
545 */ | 548 */ |
546 ac = CountArray((void**) aavas); | 549 ac = CountArray((void **)aavas); |
547 bc = CountArray((void**) bavas); | 550 bc = CountArray((void **)bavas); |
548 if (ac < bc) return SECLessThan; | 551 if (ac < bc) |
549 if (ac > bc) return SECGreaterThan; | 552 return SECLessThan; |
| 553 if (ac > bc) |
| 554 return SECGreaterThan; |
550 | 555 |
551 while (NULL != (aava = *aavas++)) { | 556 while (NULL != (aava = *aavas++)) { |
552 » for (bavas = b->avas; NULL != (bava = *bavas++); ) { | 557 for (bavas = b->avas; NULL != (bava = *bavas++);) { |
553 » rv = SECITEM_CompareItem(&aava->type, &bava->type); | 558 rv = SECITEM_CompareItem(&aava->type, &bava->type); |
554 » if (SECEqual == rv) { | 559 if (SECEqual == rv) { |
555 » » rv = CERT_CompareAVA(aava, bava); | 560 rv = CERT_CompareAVA(aava, bava); |
556 » » if (SECEqual != rv)· | 561 if (SECEqual != rv) |
557 » » return rv; | 562 return rv; |
558 » » break; | 563 break; |
559 » } | 564 } |
560 » } | 565 } |
561 » if (!bava) /* didn't find a match */ | 566 if (!bava) /* didn't find a match */ |
562 » return SECGreaterThan; | 567 return SECGreaterThan; |
563 } | 568 } |
564 return rv; | 569 return rv; |
565 } | 570 } |
566 | 571 |
567 SECComparison | 572 SECComparison |
568 CERT_CompareName(const CERTName *a, const CERTName *b) | 573 CERT_CompareName(const CERTName *a, const CERTName *b) |
569 { | 574 { |
570 CERTRDN **ardns, *ardn; | 575 CERTRDN **ardns, *ardn; |
571 CERTRDN **brdns, *brdn; | 576 CERTRDN **brdns, *brdn; |
572 int ac, bc; | 577 int ac, bc; |
573 SECComparison rv = SECEqual; | 578 SECComparison rv = SECEqual; |
574 | 579 |
575 ardns = a->rdns; | 580 ardns = a->rdns; |
576 brdns = b->rdns; | 581 brdns = b->rdns; |
577 | 582 |
578 /* | 583 /* |
579 ** Make sure array of rdn's are the same length. If not, then we are | 584 ** Make sure array of rdn's are the same length. If not, then we are |
580 ** not equal | 585 ** not equal |
581 */ | 586 */ |
582 ac = CountArray((void**) ardns); | 587 ac = CountArray((void **)ardns); |
583 bc = CountArray((void**) brdns); | 588 bc = CountArray((void **)brdns); |
584 if (ac < bc) return SECLessThan; | 589 if (ac < bc) |
585 if (ac > bc) return SECGreaterThan; | 590 return SECLessThan; |
| 591 if (ac > bc) |
| 592 return SECGreaterThan; |
586 | 593 |
587 for (;;) { | 594 for (;;) { |
588 » ardn = *ardns++; | 595 ardn = *ardns++; |
589 » brdn = *brdns++; | 596 brdn = *brdns++; |
590 » if (!ardn) { | 597 if (!ardn) { |
591 » break; | 598 break; |
592 » } | 599 } |
593 » rv = CERT_CompareRDN(ardn, brdn); | 600 rv = CERT_CompareRDN(ardn, brdn); |
594 » if (rv) return rv; | 601 if (rv) |
| 602 return rv; |
595 } | 603 } |
596 return rv; | 604 return rv; |
597 } | 605 } |
598 | 606 |
599 /* Moved from certhtml.c */ | 607 /* Moved from certhtml.c */ |
600 SECItem * | 608 SECItem * |
601 CERT_DecodeAVAValue(const SECItem *derAVAValue) | 609 CERT_DecodeAVAValue(const SECItem *derAVAValue) |
602 { | 610 { |
603 SECItem *retItem; | 611 SECItem *retItem; |
604 const SEC_ASN1Template *theTemplate = NULL; | 612 const SEC_ASN1Template *theTemplate = NULL; |
605 enum { conv_none, conv_ucs4, conv_ucs2, conv_iso88591 } convert = conv
_none; | 613 enum { conv_none, conv_ucs4, conv_ucs2, conv_iso88591 } convert = conv_none; |
606 SECItem avaValue = {siBuffer, 0}; | 614 SECItem avaValue = { siBuffer, 0 }; |
607 PLArenaPool *newarena = NULL; | 615 PLArenaPool *newarena = NULL; |
608 | 616 |
609 if (!derAVAValue || !derAVAValue->len || !derAVAValue->data) { | 617 if (!derAVAValue || !derAVAValue->len || !derAVAValue->data) { |
610 » PORT_SetError(SEC_ERROR_INVALID_ARGS); | 618 PORT_SetError(SEC_ERROR_INVALID_ARGS); |
611 » return NULL; | 619 return NULL; |
612 } | 620 } |
613 | 621 |
614 switch(derAVAValue->data[0]) { | 622 switch (derAVAValue->data[0]) { |
615 » case SEC_ASN1_UNIVERSAL_STRING: | 623 case SEC_ASN1_UNIVERSAL_STRING: |
616 » convert = conv_ucs4; | 624 convert = conv_ucs4; |
617 » theTemplate = SEC_ASN1_GET(SEC_UniversalStringTemplate); | 625 theTemplate = SEC_ASN1_GET(SEC_UniversalStringTemplate); |
618 » break; | 626 break; |
619 » case SEC_ASN1_IA5_STRING: | 627 case SEC_ASN1_IA5_STRING: |
620 » theTemplate = SEC_ASN1_GET(SEC_IA5StringTemplate); | 628 theTemplate = SEC_ASN1_GET(SEC_IA5StringTemplate); |
621 » break; | 629 break; |
622 » case SEC_ASN1_PRINTABLE_STRING: | 630 case SEC_ASN1_PRINTABLE_STRING: |
623 » theTemplate = SEC_ASN1_GET(SEC_PrintableStringTemplate); | 631 theTemplate = SEC_ASN1_GET(SEC_PrintableStringTemplate); |
624 » break; | 632 break; |
625 » case SEC_ASN1_T61_STRING: | 633 case SEC_ASN1_T61_STRING: |
626 » /* | 634 /* |
627 » * Per common practice, we're not decoding actual T.61, but instead | 635 * Per common practice, we're not decoding actual T.61, but instead |
628 » * treating T61-labeled strings as containing ISO-8859-1. | 636 * treating T61-labeled strings as containing ISO-8859-1. |
629 » */ | 637 */ |
630 » convert = conv_iso88591; | 638 convert = conv_iso88591; |
631 » theTemplate = SEC_ASN1_GET(SEC_T61StringTemplate); | 639 theTemplate = SEC_ASN1_GET(SEC_T61StringTemplate); |
632 » break; | 640 break; |
633 » case SEC_ASN1_BMP_STRING: | 641 case SEC_ASN1_BMP_STRING: |
634 » convert = conv_ucs2; | 642 convert = conv_ucs2; |
635 » theTemplate = SEC_ASN1_GET(SEC_BMPStringTemplate); | 643 theTemplate = SEC_ASN1_GET(SEC_BMPStringTemplate); |
636 » break; | 644 break; |
637 » case SEC_ASN1_UTF8_STRING: | 645 case SEC_ASN1_UTF8_STRING: |
638 » /* No conversion needed ! */ | 646 /* No conversion needed ! */ |
639 » theTemplate = SEC_ASN1_GET(SEC_UTF8StringTemplate); | 647 theTemplate = SEC_ASN1_GET(SEC_UTF8StringTemplate); |
640 » break; | 648 break; |
641 » default: | 649 default: |
642 » PORT_SetError(SEC_ERROR_INVALID_AVA); | 650 PORT_SetError(SEC_ERROR_INVALID_AVA); |
643 » return NULL; | 651 return NULL; |
644 } | 652 } |
645 | 653 |
646 PORT_Memset(&avaValue, 0, sizeof(SECItem)); | 654 PORT_Memset(&avaValue, 0, sizeof(SECItem)); |
647 newarena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE); | 655 newarena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE); |
648 if (!newarena) { | 656 if (!newarena) { |
649 return NULL; | 657 return NULL; |
650 } | 658 } |
651 if(SEC_QuickDERDecodeItem(newarena, &avaValue, theTemplate, derAVAValue) | 659 if (SEC_QuickDERDecodeItem(newarena, &avaValue, theTemplate, derAVAValue) != |
652 » » » » != SECSuccess) { | 660 SECSuccess) { |
653 » PORT_FreeArena(newarena, PR_FALSE); | 661 PORT_FreeArena(newarena, PR_FALSE); |
654 » return NULL; | 662 return NULL; |
655 } | 663 } |
656 | 664 |
657 if (convert != conv_none) { | 665 if (convert != conv_none) { |
658 » unsigned int utf8ValLen = avaValue.len * 3; | 666 unsigned int utf8ValLen = avaValue.len * 3; |
659 » unsigned char *utf8Val = (unsigned char*) | 667 unsigned char *utf8Val = |
660 » » » » PORT_ArenaZAlloc(newarena, utf8ValLen); | 668 (unsigned char *)PORT_ArenaZAlloc(newarena, utf8ValLen); |
661 | 669 |
662 switch (convert) { | 670 switch (convert) { |
663 case conv_ucs4: | 671 case conv_ucs4: |
664 if(avaValue.len % 4 != 0 || | 672 if (avaValue.len % 4 != 0 || |
665 !PORT_UCS4_UTF8Conversion(PR_FALSE, avaValue.data, avaValue.len, | 673 !PORT_UCS4_UTF8Conversion(PR_FALSE, avaValue.data, |
666 » » » » » utf8Val, utf8ValLen, &utf8ValLen)) { | 674 avaValue.len, utf8Val, utf8ValLen, |
667 PORT_FreeArena(newarena, PR_FALSE); | 675 &utf8ValLen)) { |
668 PORT_SetError(SEC_ERROR_INVALID_AVA); | 676 PORT_FreeArena(newarena, PR_FALSE); |
669 » » return NULL; | 677 PORT_SetError(SEC_ERROR_INVALID_AVA); |
670 » } | 678 return NULL; |
671 » break; | 679 } |
672 » case conv_ucs2: | 680 break; |
673 if(avaValue.len % 2 != 0 || | 681 case conv_ucs2: |
674 !PORT_UCS2_UTF8Conversion(PR_FALSE, avaValue.data, avaValue.len, | 682 if (avaValue.len % 2 != 0 || |
675 » » » » » utf8Val, utf8ValLen, &utf8ValLen)) { | 683 !PORT_UCS2_UTF8Conversion(PR_FALSE, avaValue.data, |
676 PORT_FreeArena(newarena, PR_FALSE); | 684 avaValue.len, utf8Val, utf8ValLen, |
677 PORT_SetError(SEC_ERROR_INVALID_AVA); | 685 &utf8ValLen)) { |
678 » » return NULL; | 686 PORT_FreeArena(newarena, PR_FALSE); |
679 » } | 687 PORT_SetError(SEC_ERROR_INVALID_AVA); |
680 » break; | 688 return NULL; |
681 » case conv_iso88591: | 689 } |
682 if(!PORT_ISO88591_UTF8Conversion(avaValue.data, avaValue.len, | 690 break; |
683 » » » » » utf8Val, utf8ValLen, &utf8ValLen)) { | 691 case conv_iso88591: |
684 PORT_FreeArena(newarena, PR_FALSE); | 692 if (!PORT_ISO88591_UTF8Conversion(avaValue.data, avaValue.len, |
685 PORT_SetError(SEC_ERROR_INVALID_AVA); | 693 utf8Val, utf8ValLen, |
686 » » return NULL; | 694 &utf8ValLen)) { |
687 » } | 695 PORT_FreeArena(newarena, PR_FALSE); |
688 » break; | 696 PORT_SetError(SEC_ERROR_INVALID_AVA); |
689 » case conv_none: | 697 return NULL; |
690 » PORT_Assert(0); /* not reached */ | 698 } |
691 » break; | 699 break; |
692 » } | 700 case conv_none: |
693 »········· | 701 PORT_Assert(0); /* not reached */ |
694 » avaValue.data = utf8Val; | 702 break; |
695 » avaValue.len = utf8ValLen; | 703 } |
| 704 |
| 705 avaValue.data = utf8Val; |
| 706 avaValue.len = utf8ValLen; |
696 } | 707 } |
697 | 708 |
698 retItem = SECITEM_DupItem(&avaValue); | 709 retItem = SECITEM_DupItem(&avaValue); |
699 PORT_FreeArena(newarena, PR_FALSE); | 710 PORT_FreeArena(newarena, PR_FALSE); |
700 return retItem; | 711 return retItem; |
701 } | 712 } |
OLD | NEW |