← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/nss/jaunty-proposed

« back to all changes in this revision

Viewing changes to mozilla/security/nss/lib/certdb/cert.h

  • Committer: Bazaar Package Importer
  • Author(s): Alexander Sack, Fabien Tassin, Alexander Sack
  • Date: 2009-01-11 15:06:17 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20090111150617-iz4lw05qgy2odorl
Tags: 3.12.2~rc1-0ubuntu1
* New upstream snapshot: 3.12.2 RC1

[ Fabien Tassin <fta@ubuntu.com> ]
* Remove patch applied upstream:
  - drop debian/patches/80_security_tools.patch
  - update debian/patches/series
* Update diverged patches:
  - update debian/patches/38_kbsd.patch
  - update debian/patches/38_mips64_build.patch
* Add new symbols to symbols file
  - update debian/libnss3-1d.symbols

[ Alexander Sack <asac@ubuntu.com> ]
* disable soname patch to become binary compatible with upstream
  - update debian/patches/series
* flip links: libnss3.so <- libnss3.so.1d (before: libnss3.so ->
  libnss3.so.1d); same link flipping was done for all other previously
  soname patched libs: libnssutil3.so, libsmime3.so.1d, libssl3.so.1d
  - update debian/libnss3-1d.links
  - update debian/libnss3-1d.symbols
* properly transition links in preinst and postrm; also cover abort-
  cases in the other maintainer scripts
  - add debian/libnss3-1d.postinst
  - add debian/libnss3-1d.postrm
  - add debian/libnss3-1d.preinst
  - add debian/libnss3-1d.prerm
* remove hack from debian/rules that debian uses to recreate
  libsoftokn3.so with a versioned SONAME
  - update debian/rules
* install the unversioned .so binaries
  - update debian/rules
* only install the 4 main libraries into /usr/lib; all the others
  go to pkglibdir
  - update debian/rules
* higher bar for libnspr4 Build-Depend to >= 4.7.3~, which is
  the version where the soname droppage is going to happen
  - update debian/control
* explitily pass libraries to be used for dpkg-gensymbols run of
  dh_makeshlibs
  - update debian/rules
* fix lintian complain about no-shlibs-control-file
  - update debian/rules

Show diffs side-by-side

added added

removed removed

Lines of Context:
mozilla/security/nss/lib/certdb/cert.h
37
37
/*
38
38
 * cert.h - public data structures and prototypes for the certificate library
39
39
 *
40
 
 * $Id: cert.h,v 1.68 2008/03/15 02:15:34 alexei.volkov.bugs%sun.com Exp $
 
40
 * $Id: cert.h,v 1.74 2008/08/04 22:31:54 nelson%bolyard.com Exp $
41
41
 */
42
42
 
43
43
#ifndef _CERT_H_
71
71
/*
72
72
** Convert an CERTName into its RFC1485 encoded equivalent.
73
73
** Returns a string that must be freed with PORT_Free().
 
74
** This version produces a string for maximum human readability,
 
75
** not for strict RFC compliance.
74
76
*/
75
77
extern char *CERT_NameToAscii(CERTName *name);
76
78
 
77
 
extern CERTAVA *CERT_CopyAVA(PRArenaPool *arena, CERTAVA *src);
 
79
/*
 
80
** Convert an CERTName into its RFC1485 encoded equivalent.
 
81
** Returns a string that must be freed with PORT_Free().
 
82
** Caller chooses encoding rules.
 
83
*/
 
84
extern char *CERT_NameToAsciiInvertible(CERTName *name, 
 
85
                                        CertStrictnessLevel strict);
 
86
 
 
87
extern CERTAVA *CERT_CopyAVA(PLArenaPool *arena, CERTAVA *src);
78
88
 
79
89
/* convert an OID to dotted-decimal representation */
80
90
/* Returns a string that must be freed with PR_smprintf_free(). */
95
105
** Create an RDN (relative-distinguished-name). The argument list is a
96
106
** NULL terminated list of AVA's.
97
107
*/
98
 
extern CERTRDN *CERT_CreateRDN(PRArenaPool *arena, CERTAVA *avas, ...);
 
108
extern CERTRDN *CERT_CreateRDN(PLArenaPool *arena, CERTAVA *avas, ...);
99
109
 
100
110
/*
101
111
** Make a copy of "src" storing it in "dest".
102
112
*/
103
 
extern SECStatus CERT_CopyRDN(PRArenaPool *arena, CERTRDN *dest, CERTRDN *src);
 
113
extern SECStatus CERT_CopyRDN(PLArenaPool *arena, CERTRDN *dest, CERTRDN *src);
104
114
 
105
115
/*
106
116
** Destory an RDN object.
114
124
**      "rdn" the RDN to add to
115
125
**      "ava" the AVA to add
116
126
*/
117
 
extern SECStatus CERT_AddAVA(PRArenaPool *arena, CERTRDN *rdn, CERTAVA *ava);
 
127
extern SECStatus CERT_AddAVA(PLArenaPool *arena, CERTRDN *rdn, CERTAVA *ava);
118
128
 
119
129
/*
120
130
** Compare two RDN's, returning the difference between them.
132
142
** "dest" before allocation is done (use CERT_DestroyName(dest, PR_FALSE) to
133
143
** do that).
134
144
*/
135
 
extern SECStatus CERT_CopyName(PRArenaPool *arena, CERTName *dest, CERTName *src);
 
145
extern SECStatus CERT_CopyName(PLArenaPool *arena, CERTName *dest, CERTName *src);
136
146
 
137
147
/*
138
148
** Destroy a Name object.
175
185
**      "notBefore" the time before which the validity is not valid
176
186
**      "notAfter" the time after which the validity is not valid
177
187
*/
178
 
extern CERTValidity *CERT_CreateValidity(int64 notBefore, int64 notAfter);
 
188
extern CERTValidity *CERT_CreateValidity(PRTime notBefore, PRTime notAfter);
179
189
 
180
190
/*
181
191
** Destroy a validity object.
191
201
** that).
192
202
*/
193
203
extern SECStatus CERT_CopyValidity
194
 
   (PRArenaPool *arena, CERTValidity *dest, CERTValidity *src);
 
204
   (PLArenaPool *arena, CERTValidity *dest, CERTValidity *src);
195
205
 
196
206
/*
197
207
** The cert lib considers a cert or CRL valid if the "notBefore" time is
305
315
extern CERTCertDBHandle *CERT_GetDefaultCertDB(void);
306
316
 
307
317
extern CERTCertList *CERT_GetCertChainFromCert(CERTCertificate *cert, 
308
 
                                               int64 time, 
 
318
                                               PRTime time, 
309
319
                                               SECCertUsage usage);
310
320
extern CERTCertificate *
311
321
CERT_NewTempCertificate (CERTCertDBHandle *handle, SECItem *derCert,
327
337
**      "value" is the null terminated string containing the value
328
338
*/
329
339
extern CERTAVA *CERT_CreateAVA
330
 
   (PRArenaPool *arena, SECOidTag kind, int valueType, char *value);
 
340
   (PLArenaPool *arena, SECOidTag kind, int valueType, char *value);
331
341
 
332
342
/*
333
343
** Extract the Distinguished Name from a DER encoded certificate
346
356
 
347
357
extern SECItem *
348
358
CERT_EncodeGeneralName(CERTGeneralName *genName, SECItem *dest,
349
 
                       PRArenaPool *arena);
 
359
                       PLArenaPool *arena);
350
360
 
351
361
extern CERTGeneralName *
352
 
CERT_DecodeGeneralName(PRArenaPool *reqArena, SECItem *encodedName,
 
362
CERT_DecodeGeneralName(PLArenaPool *reqArena, SECItem *encodedName,
353
363
                       CERTGeneralName  *genName);
354
364
 
355
365
 
361
371
**      "derCert" the DER encoded certificate
362
372
**      "key" the returned key
363
373
*/
364
 
extern SECStatus CERT_KeyFromDERCert(PRArenaPool *reqArena, SECItem *derCert,
 
374
extern SECStatus CERT_KeyFromDERCert(PLArenaPool *reqArena, SECItem *derCert,
365
375
                                     SECItem *key);
366
376
 
367
 
extern SECStatus CERT_KeyFromIssuerAndSN(PRArenaPool *arena, SECItem *issuer,
 
377
extern SECStatus CERT_KeyFromIssuerAndSN(PLArenaPool *arena, SECItem *issuer,
368
378
                                         SECItem *sn, SECItem *key);
369
379
 
370
380
extern SECStatus CERT_SerialNumberFromDERCert(SECItem *derCert, 
378
388
**      "derCrl" the DER encoded crl
379
389
**      "key" the returned key
380
390
*/
381
 
extern SECStatus CERT_KeyFromDERCrl(PRArenaPool *arena, SECItem *derCrl, SECItem *key);
 
391
extern SECStatus CERT_KeyFromDERCrl(PLArenaPool *arena, SECItem *derCrl, SECItem *key);
382
392
 
383
393
/*
384
394
** Open the certificate database.  Use callback to get name of database.
437
447
#define SEC_KRL_TYPE    0
438
448
 
439
449
extern CERTSignedCrl *
440
 
CERT_DecodeDERCrl (PRArenaPool *arena, SECItem *derSignedCrl,int type);
 
450
CERT_DecodeDERCrl (PLArenaPool *arena, SECItem *derSignedCrl,int type);
441
451
 
442
452
/*
443
453
 * same as CERT_DecodeDERCrl, plus allow options to be passed in
444
454
 */
445
455
 
446
456
extern CERTSignedCrl *
447
 
CERT_DecodeDERCrlWithFlags(PRArenaPool *narena, SECItem *derSignedCrl,
 
457
CERT_DecodeDERCrlWithFlags(PLArenaPool *narena, SECItem *derSignedCrl,
448
458
                          int type, PRInt32 options);
449
459
 
450
460
/* CRL options to pass */
550
560
CERT_FindCertBySubjectKeyID (CERTCertDBHandle *handle, SECItem *subjKeyID);
551
561
 
552
562
/*
 
563
** Encode Certificate SKID (Subject Key ID) extension.
 
564
**
 
565
*/
 
566
extern SECStatus 
 
567
CERT_EncodeSubjectKeyID(PLArenaPool *arena, const SECItem* srcString,
 
568
                        SECItem *encodedValue);
 
569
 
 
570
/*
553
571
** Find a certificate in the database by a nickname
554
572
**      "nickname" is the ascii string nickname to look for
555
573
*/
588
606
 * Find the issuer of a cert
589
607
 */
590
608
CERTCertificate *
591
 
CERT_FindCertIssuer(CERTCertificate *cert, int64 validTime, SECCertUsage usage);
 
609
CERT_FindCertIssuer(CERTCertificate *cert, PRTime validTime, SECCertUsage usage);
592
610
 
593
611
/*
594
612
** Check the validity times of a certificate vs. time 't', allowing
603
621
                                                    PRBool allowOverride);
604
622
 
605
623
/*
606
 
** WARNING - this function is depricated, and will either go away or have
 
624
** WARNING - this function is deprecated, and will either go away or have
607
625
**              a new API in the near future.
608
626
**
609
627
** Check the validity times of a certificate vs. the current time, allowing
624
642
/*
625
643
** Extract the issuer and serial number from a certificate
626
644
*/
627
 
extern CERTIssuerAndSN *CERT_GetCertIssuerAndSN(PRArenaPool *, 
 
645
extern CERTIssuerAndSN *CERT_GetCertIssuerAndSN(PLArenaPool *, 
628
646
                                                        CERTCertificate *);
629
647
 
630
648
/*
634
652
*/
635
653
extern SECStatus CERT_VerifySignedData(CERTSignedData *sd,
636
654
                                       CERTCertificate *cert,
637
 
                                       int64 t,
 
655
                                       PRTime t,
638
656
                                       void *wincx);
639
657
/*
640
658
** verify the signature of a signed data object with the given DER publickey
662
680
extern SECStatus
663
681
CERT_VerifyCertificate(CERTCertDBHandle *handle, CERTCertificate *cert,
664
682
                PRBool checkSig, SECCertificateUsage requiredUsages,
665
 
                int64 t, void *wincx, CERTVerifyLog *log,
 
683
                PRTime t, void *wincx, CERTVerifyLog *log,
666
684
                SECCertificateUsage* returnedUsages);
667
685
 
668
686
/* same as above, but uses current time */
678
696
*/
679
697
extern SECStatus
680
698
CERT_VerifyCACertForUsage(CERTCertDBHandle *handle, CERTCertificate *cert,
681
 
                PRBool checkSig, SECCertUsage certUsage, int64 t,
 
699
                PRBool checkSig, SECCertUsage certUsage, PRTime t,
682
700
                void *wincx, CERTVerifyLog *log);
683
701
 
684
702
/*
691
709
*/
692
710
extern SECStatus
693
711
CERT_VerifyCert(CERTCertDBHandle *handle, CERTCertificate *cert,
694
 
                PRBool checkSig, SECCertUsage certUsage, int64 t,
 
712
                PRBool checkSig, SECCertUsage certUsage, PRTime t,
695
713
                void *wincx, CERTVerifyLog *log);
696
714
 
697
715
/* same as above, but uses current time */
701
719
 
702
720
SECStatus
703
721
CERT_VerifyCertChain(CERTCertDBHandle *handle, CERTCertificate *cert,
704
 
                     PRBool checkSig, SECCertUsage certUsage, int64 t,
 
722
                     PRBool checkSig, SECCertUsage certUsage, PRTime t,
705
723
                     void *wincx, CERTVerifyLog *log);
706
724
 
707
725
/*
834
852
 
835
853
 
836
854
extern SECStatus
837
 
CERT_EncodeAltNameExtension(PRArenaPool *arena,  CERTGeneralName  *value, SECItem *encodedValue);
 
855
CERT_EncodeAltNameExtension(PLArenaPool *arena,  CERTGeneralName  *value, SECItem *encodedValue);
838
856
 
839
857
 
840
858
/*
874
892
**      encodedValue - output encoded value
875
893
*/
876
894
extern SECStatus CERT_EncodeBasicConstraintValue
877
 
   (PRArenaPool *arena, CERTBasicConstraints *value, SECItem *encodedValue);
 
895
   (PLArenaPool *arena, CERTBasicConstraints *value, SECItem *encodedValue);
878
896
 
879
897
/*
880
898
** Encode the value of the authorityKeyIdentifier extension.
881
899
*/
882
900
extern SECStatus CERT_EncodeAuthKeyID
883
 
   (PRArenaPool *arena, CERTAuthKeyID *value, SECItem *encodedValue);
 
901
   (PLArenaPool *arena, CERTAuthKeyID *value, SECItem *encodedValue);
884
902
 
885
903
/*
886
904
** Encode the value of the crlDistributionPoints extension.
887
905
*/
888
906
extern SECStatus CERT_EncodeCRLDistributionPoints
889
 
   (PRArenaPool *arena, CERTCrlDistributionPoints *value,SECItem *derValue);
 
907
   (PLArenaPool *arena, CERTCrlDistributionPoints *value,SECItem *derValue);
890
908
 
891
909
/*
892
910
** Decodes a DER encoded basicConstaint extension value into a readable format
903
921
**      Returns a CERTAuthKeyID structure which contains the decoded value
904
922
*/
905
923
extern CERTAuthKeyID *CERT_DecodeAuthKeyID 
906
 
                        (PRArenaPool *arena, SECItem *encodedValue);
 
924
                        (PLArenaPool *arena, SECItem *encodedValue);
907
925
 
908
926
 
909
927
/* Decodes a DER encoded crlDistributionPoints extension value into a 
914
932
**          decoded value
915
933
*/
916
934
extern CERTCrlDistributionPoints * CERT_DecodeCRLDistributionPoints
917
 
   (PRArenaPool *arena, SECItem *der);
 
935
   (PLArenaPool *arena, SECItem *der);
918
936
 
919
937
/* Extract certain name type from a generalName */
920
938
extern void *CERT_GetGeneralNameByType
953
971
/* Returns the decoded value of the authKeyID extension.
954
972
**   Note that this uses passed in the arena to allocate storage for the result
955
973
*/
956
 
extern CERTAuthKeyID * CERT_FindAuthKeyIDExten (PRArenaPool *arena,CERTCertificate *cert);
 
974
extern CERTAuthKeyID * CERT_FindAuthKeyIDExten (PLArenaPool *arena,CERTCertificate *cert);
957
975
 
958
976
/* Returns the decoded value of the basicConstraint extension.
959
977
 */
1004
1022
   (CERTCrl *crl, int tag, SECItem *value);
1005
1023
 
1006
1024
extern SECStatus
1007
 
   CERT_FindInvalidDateExten (CERTCrl *crl, int64 *value);
 
1025
   CERT_FindInvalidDateExten (CERTCrl *crl, PRTime *value);
1008
1026
 
1009
1027
/*
1010
1028
** Set up a crl for adding X509v3 extensions.  Returns an opaque handle
1027
1045
/*
1028
1046
** Finds the crlNumber extension and decodes its value into 'value'
1029
1047
*/
1030
 
extern SECStatus CERT_FindCRLNumberExten (PRArenaPool *arena, CERTCrl *crl,
 
1048
extern SECStatus CERT_FindCRLNumberExten (PLArenaPool *arena, CERTCrl *crl,
1031
1049
                                          SECItem *value);
1032
1050
 
1033
1051
extern SECStatus CERT_FindCRLEntryReasonExten (CERTCrlEntry *crlEntry,
1137
1155
SECStatus
1138
1156
CERT_AddNewCerts(CERTCertDBHandle *handle);
1139
1157
 
1140
 
CERTPackageType
1141
 
CERT_CertPackageType(SECItem *package, SECItem *certitem);
1142
 
 
1143
1158
CERTCertificatePolicies *
1144
1159
CERT_DecodeCertificatePoliciesExtension(SECItem *extnValue);
1145
1160
 
1163
1178
CERT_DecodeUserNotice(SECItem *noticeItem);
1164
1179
 
1165
1180
extern CERTGeneralName *
1166
 
CERT_DecodeAltNameExtension(PRArenaPool *reqArena, SECItem *EncodedAltName);
 
1181
CERT_DecodeAltNameExtension(PLArenaPool *reqArena, SECItem *EncodedAltName);
1167
1182
 
1168
1183
extern CERTNameConstraints *
1169
 
CERT_DecodeNameConstraintsExtension(PRArenaPool *arena, 
 
1184
CERT_DecodeNameConstraintsExtension(PLArenaPool *arena, 
1170
1185
                                    SECItem *encodedConstraints);
1171
1186
 
1172
1187
/* returns addr of a NULL termainated array of pointers to CERTAuthInfoAccess */
1173
1188
extern CERTAuthInfoAccess **
1174
 
CERT_DecodeAuthInfoAccessExtension(PRArenaPool *reqArena,
 
1189
CERT_DecodeAuthInfoAccessExtension(PLArenaPool *reqArena,
1175
1190
                                   SECItem     *encodedExtension);
1176
1191
 
1177
1192
extern CERTPrivKeyUsagePeriod *
1256
1271
CERT_CheckForEvilCert(CERTCertificate *cert);
1257
1272
 
1258
1273
CERTGeneralName *
1259
 
CERT_GetCertificateNames(CERTCertificate *cert, PRArenaPool *arena);
 
1274
CERT_GetCertificateNames(CERTCertificate *cert, PLArenaPool *arena);
1260
1275
 
1261
1276
char *
1262
 
CERT_GetNickName(CERTCertificate   *cert, CERTCertDBHandle *handle, PRArenaPool *nicknameArena);
 
1277
CERT_GetNickName(CERTCertificate   *cert, CERTCertDBHandle *handle, PLArenaPool *nicknameArena);
1263
1278
 
1264
1279
/*
1265
1280
 * Creates or adds to a list of all certs with a give subject name, sorted by
1268
1283
 */
1269
1284
CERTCertList *
1270
1285
CERT_CreateSubjectCertList(CERTCertList *certList, CERTCertDBHandle *handle,
1271
 
                           SECItem *name, int64 sorttime, PRBool validOnly);
1272
 
 
1273
 
/*
1274
 
 * Creates or adds to a list of all certs with a give nickname, sorted by
1275
 
 * validity time, newest first.  Invalid certs are considered older than valid
1276
 
 * certs. If validOnly is set, do not include invalid certs on list.
1277
 
 */
1278
 
CERTCertList *
1279
 
CERT_CreateNicknameCertList(CERTCertList *certList, CERTCertDBHandle *handle,
1280
 
                            char *nickname, int64 sorttime, PRBool validOnly);
1281
 
 
1282
 
/*
1283
 
 * Creates or adds to a list of all certs with a give email addr, sorted by
1284
 
 * validity time, newest first.  Invalid certs are considered older than valid
1285
 
 * certs. If validOnly is set, do not include invalid certs on list.
1286
 
 */
1287
 
CERTCertList *
1288
 
CERT_CreateEmailAddrCertList(CERTCertList *certList, CERTCertDBHandle *handle,
1289
 
                             char *emailAddr, int64 sorttime, PRBool validOnly);
 
1286
                           SECItem *name, PRTime sorttime, PRBool validOnly);
1290
1287
 
1291
1288
/*
1292
1289
 * remove certs from a list that don't have keyUsage and certType
1414
1411
 *              not yet good.
1415
1412
 */
1416
1413
char *
1417
 
CERT_GetCertNicknameWithValidity(PRArenaPool *arena, CERTCertificate *cert,
 
1414
CERT_GetCertNicknameWithValidity(PLArenaPool *arena, CERTCertificate *cert,
1418
1415
                                 char *expiredString, char *notYetGoodString);
1419
1416
 
1420
1417
/*
1437
1434
CERTCertificate *
1438
1435
CERT_FindMatchingCert(CERTCertDBHandle *handle, SECItem *derName,
1439
1436
                      CERTCertOwner owner, SECCertUsage usage,
1440
 
                      PRBool preferTrusted, int64 validTime, PRBool validOnly);
 
1437
                      PRBool preferTrusted, PRTime validTime, PRBool validOnly);
1441
1438
 
1442
1439
/*
1443
1440
 * Acquire the global lock on the cert database.
1512
1509
 * results in a NULL being returned (and an appropriate error set).
1513
1510
 */ 
1514
1511
extern SECItem *
1515
 
CERT_GetSPKIDigest(PRArenaPool *arena, const CERTCertificate *cert,
 
1512
CERT_GetSPKIDigest(PLArenaPool *arena, const CERTCertificate *cert,
1516
1513
                   SECOidTag digestAlg, SECItem *fill);
1517
1514
 
1518
1515
 
1519
1516
SECStatus CERT_CheckCRL(CERTCertificate* cert, CERTCertificate* issuer,
1520
 
                        SECItem* dp, int64 t, void* wincx);
 
1517
                        SECItem* dp, PRTime t, void* wincx);
1521
1518
 
1522
1519
 
1523
1520
/*
1533
1530
 * SECItem data.
1534
1531
 */
1535
1532
extern CERTNameConstraint *
1536
 
CERT_CopyNameConstraint(PRArenaPool         *arena, 
 
1533
CERT_CopyNameConstraint(PLArenaPool         *arena, 
1537
1534
                        CERTNameConstraint  *dest, 
1538
1535
                        CERTNameConstraint  *src);
1539
1536
 
1542
1539
 * the name.
1543
1540
 */
1544
1541
extern SECStatus
1545
 
CERT_CheckNameSpace(PRArenaPool          *arena,
 
1542
CERT_CheckNameSpace(PLArenaPool          *arena,
1546
1543
                    CERTNameConstraints  *constraints,
1547
1544
                    CERTGeneralName      *currentName);
1548
1545
 
1550
1547
 * Extract and allocate the name constraints extension from the CA cert.
1551
1548
 */
1552
1549
extern SECStatus
1553
 
CERT_FindNameConstraintsExten(PRArenaPool      *arena,
 
1550
CERT_FindNameConstraintsExten(PLArenaPool      *arena,
1554
1551
                              CERTCertificate  *cert,
1555
1552
                              CERTNameConstraints **constraints);
1556
1553
 
1564
1561
 * PKIX extension encoding routines
1565
1562
 */
1566
1563
extern SECStatus
1567
 
CERT_EncodePolicyConstraintsExtension(PRArenaPool *arena,
 
1564
CERT_EncodePolicyConstraintsExtension(PLArenaPool *arena,
1568
1565
                                      CERTCertificatePolicyConstraints *constr,
1569
1566
                                      SECItem *dest);
1570
1567
extern SECStatus
1571
 
CERT_EncodeInhibitAnyExtension(PRArenaPool *arena,
 
1568
CERT_EncodeInhibitAnyExtension(PLArenaPool *arena,
1572
1569
                               CERTCertificateInhibitAny *inhibitAny,
1573
1570
                               SECItem *dest);
1574
1571
extern SECStatus
1575
 
CERT_EncodePolicyMappingExtension(PRArenaPool *arena,
 
1572
CERT_EncodePolicyMappingExtension(PLArenaPool *arena,
1576
1573
                                  CERTCertificatePolicyMappings *maps,
1577
1574
                                  SECItem *dest);
1578
1575
 
1579
 
extern SECStatus CERT_EncodeInfoAccessExtension(PRArenaPool *arena,
 
1576
extern SECStatus CERT_EncodeInfoAccessExtension(PLArenaPool *arena,
1580
1577
                                                    CERTAuthInfoAccess **info,
1581
1578
                                                    SECItem *dest);
1582
1579
extern SECStatus
1583
 
CERT_EncodeUserNotice(PRArenaPool *arena,
 
1580
CERT_EncodeUserNotice(PLArenaPool *arena,
1584
1581
                      CERTUserNotice *notice,
1585
1582
                      SECItem *dest);
1586
1583
 
1587
1584
extern SECStatus
1588
 
CERT_EncodeDisplayText(PRArenaPool *arena,
 
1585
CERT_EncodeDisplayText(PLArenaPool *arena,
1589
1586
                       SECItem *text,
1590
1587
                       SECItem *dest);
1591
1588
 
1592
1589
extern SECStatus
1593
 
CERT_EncodeCertPoliciesExtension(PRArenaPool *arena,
 
1590
CERT_EncodeCertPoliciesExtension(PLArenaPool *arena,
1594
1591
                                 CERTPolicyInfo **info,
1595
1592
                                 SECItem *dest);
1596
1593
extern SECStatus
1597
 
CERT_EncodeNoticeReference(PRArenaPool *arena,
 
1594
CERT_EncodeNoticeReference(PLArenaPool *arena,
1598
1595
                           CERTNoticeReference *reference,
1599
1596
                           SECItem *dest);
1600
1597