Dev/utvpn/utvpn-unix-v101-7101-public/src/Mayaqua/openssl/pem.h

   1 /* crypto/pem/pem.h */\r
   2 /* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)\r
   3  * All rights reserved.\r
   4  *\r
   5  * This package is an SSL implementation written\r
   6  * by Eric Young (eay@cryptsoft.com).\r
   7  * The implementation was written so as to conform with Netscapes SSL.\r
   8  * \r
   9  * This library is free for commercial and non-commercial use as long as\r
  10  * the following conditions are aheared to.  The following conditions\r
  11  * apply to all code found in this distribution, be it the RC4, RSA,\r
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation\r
  13  * included with this distribution is covered by the same copyright terms\r
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).\r
  15  * \r
  16  * Copyright remains Eric Young's, and as such any Copyright notices in\r
  17  * the code are not to be removed.\r
  18  * If this package is used in a product, Eric Young should be given attribution\r
  19  * as the author of the parts of the library used.\r
  20  * This can be in the form of a textual message at program startup or\r
  21  * in documentation (online or textual) provided with the package.\r
  22  * \r
  23  * Redistribution and use in source and binary forms, with or without\r
  24  * modification, are permitted provided that the following conditions\r
  25  * are met:\r
  26  * 1. Redistributions of source code must retain the copyright\r
  27  *    notice, this list of conditions and the following disclaimer.\r
  28  * 2. Redistributions in binary form must reproduce the above copyright\r
  29  *    notice, this list of conditions and the following disclaimer in the\r
  30  *    documentation and/or other materials provided with the distribution.\r
  31  * 3. All advertising materials mentioning features or use of this software\r
  32  *    must display the following acknowledgement:\r
  33  *    "This product includes cryptographic software written by\r
  34  *     Eric Young (eay@cryptsoft.com)"\r
  35  *    The word 'cryptographic' can be left out if the rouines from the library\r
  36  *    being used are not cryptographic related :-).\r
  37  * 4. If you include any Windows specific code (or a derivative thereof) from \r
  38  *    the apps directory (application code) you must include an acknowledgement:\r
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"\r
  40  * \r
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND\r
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\r
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
  51  * SUCH DAMAGE.\r
  52  * \r
  53  * The licence and distribution terms for any publically available version or\r
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be\r
  55  * copied and put under another distribution licence\r
  56  * [including the GNU Public Licence.]\r
  57  */\r
  58 \r
  59 #ifndef HEADER_PEM_H\r
  60 #define HEADER_PEM_H\r
  61 \r
  62 #include <openssl/e_os2.h>\r
  63 #ifndef OPENSSL_NO_BIO\r
  64 #include <openssl/bio.h>\r
  65 #endif\r
  66 #ifndef OPENSSL_NO_STACK\r
  67 #include <openssl/stack.h>\r
  68 #endif\r
  69 #include <openssl/evp.h>\r
  70 #include <openssl/x509.h>\r
  71 #include <openssl/pem2.h>\r
  72 \r
  73 #ifdef  __cplusplus\r
  74 extern "C" {\r
  75 #endif\r
  76 \r
  77 #define PEM_BUFSIZE             1024\r
  78 \r
  79 #define PEM_OBJ_UNDEF           0\r
  80 #define PEM_OBJ_X509            1\r
  81 #define PEM_OBJ_X509_REQ        2\r
  82 #define PEM_OBJ_CRL             3\r
  83 #define PEM_OBJ_SSL_SESSION     4\r
  84 #define PEM_OBJ_PRIV_KEY        10\r
  85 #define PEM_OBJ_PRIV_RSA        11\r
  86 #define PEM_OBJ_PRIV_DSA        12\r
  87 #define PEM_OBJ_PRIV_DH         13\r
  88 #define PEM_OBJ_PUB_RSA         14\r
  89 #define PEM_OBJ_PUB_DSA         15\r
  90 #define PEM_OBJ_PUB_DH          16\r
  91 #define PEM_OBJ_DHPARAMS        17\r
  92 #define PEM_OBJ_DSAPARAMS       18\r
  93 #define PEM_OBJ_PRIV_RSA_PUBLIC 19\r
  94 #define PEM_OBJ_PRIV_ECDSA      20\r
  95 #define PEM_OBJ_PUB_ECDSA       21\r
  96 #define PEM_OBJ_ECPARAMETERS    22\r
  97 \r
  98 #define PEM_ERROR               30\r
  99 #define PEM_DEK_DES_CBC         40\r
 100 #define PEM_DEK_IDEA_CBC        45\r
 101 #define PEM_DEK_DES_EDE         50\r
 102 #define PEM_DEK_DES_ECB         60\r
 103 #define PEM_DEK_RSA             70\r
 104 #define PEM_DEK_RSA_MD2         80\r
 105 #define PEM_DEK_RSA_MD5         90\r
 106 \r
 107 #define PEM_MD_MD2              NID_md2\r
 108 #define PEM_MD_MD5              NID_md5\r
 109 #define PEM_MD_SHA              NID_sha\r
 110 #define PEM_MD_MD2_RSA          NID_md2WithRSAEncryption\r
 111 #define PEM_MD_MD5_RSA          NID_md5WithRSAEncryption\r
 112 #define PEM_MD_SHA_RSA          NID_sha1WithRSAEncryption\r
 113 \r
 114 #define PEM_STRING_X509_OLD     "X509 CERTIFICATE"\r
 115 #define PEM_STRING_X509         "CERTIFICATE"\r
 116 #define PEM_STRING_X509_PAIR    "CERTIFICATE PAIR"\r
 117 #define PEM_STRING_X509_TRUSTED "TRUSTED CERTIFICATE"\r
 118 #define PEM_STRING_X509_REQ_OLD "NEW CERTIFICATE REQUEST"\r
 119 #define PEM_STRING_X509_REQ     "CERTIFICATE REQUEST"\r
 120 #define PEM_STRING_X509_CRL     "X509 CRL"\r
 121 #define PEM_STRING_EVP_PKEY     "ANY PRIVATE KEY"\r
 122 #define PEM_STRING_PUBLIC       "PUBLIC KEY"\r
 123 #define PEM_STRING_RSA          "RSA PRIVATE KEY"\r
 124 #define PEM_STRING_RSA_PUBLIC   "RSA PUBLIC KEY"\r
 125 #define PEM_STRING_DSA          "DSA PRIVATE KEY"\r
 126 #define PEM_STRING_DSA_PUBLIC   "DSA PUBLIC KEY"\r
 127 #define PEM_STRING_PKCS7        "PKCS7"\r
 128 #define PEM_STRING_PKCS8        "ENCRYPTED PRIVATE KEY"\r
 129 #define PEM_STRING_PKCS8INF     "PRIVATE KEY"\r
 130 #define PEM_STRING_DHPARAMS     "DH PARAMETERS"\r
 131 #define PEM_STRING_SSL_SESSION  "SSL SESSION PARAMETERS"\r
 132 #define PEM_STRING_DSAPARAMS    "DSA PARAMETERS"\r
 133 #define PEM_STRING_ECDSA_PUBLIC "ECDSA PUBLIC KEY"\r
 134 #define PEM_STRING_ECPARAMETERS "EC PARAMETERS"\r
 135 #define PEM_STRING_ECPRIVATEKEY "EC PRIVATE KEY"\r
 136 \r
 137   /* Note that this structure is initialised by PEM_SealInit and cleaned up\r
 138      by PEM_SealFinal (at least for now) */\r
 139 typedef struct PEM_Encode_Seal_st\r
 140         {\r
 141         EVP_ENCODE_CTX encode;\r
 142         EVP_MD_CTX md;\r
 143         EVP_CIPHER_CTX cipher;\r
 144         } PEM_ENCODE_SEAL_CTX;\r
 145 \r
 146 /* enc_type is one off */\r
 147 #define PEM_TYPE_ENCRYPTED      10\r
 148 #define PEM_TYPE_MIC_ONLY       20\r
 149 #define PEM_TYPE_MIC_CLEAR      30\r
 150 #define PEM_TYPE_CLEAR          40\r
 151 \r
 152 typedef struct pem_recip_st\r
 153         {\r
 154         char *name;\r
 155         X509_NAME *dn;\r
 156 \r
 157         int cipher;\r
 158         int key_enc;\r
 159         /*      char iv[8]; unused and wrong size */\r
 160         } PEM_USER;\r
 161 \r
 162 typedef struct pem_ctx_st\r
 163         {\r
 164         int type;               /* what type of object */\r
 165 \r
 166         struct  {\r
 167                 int version;    \r
 168                 int mode;               \r
 169                 } proc_type;\r
 170 \r
 171         char *domain;\r
 172 \r
 173         struct  {\r
 174                 int cipher;\r
 175         /* unused, and wrong size\r
 176            unsigned char iv[8]; */\r
 177                 } DEK_info;\r
 178                 \r
 179         PEM_USER *originator;\r
 180 \r
 181         int num_recipient;\r
 182         PEM_USER **recipient;\r
 183 \r
 184 #ifndef OPENSSL_NO_STACK\r
 185         STACK *x509_chain;      /* certificate chain */\r
 186 #else\r
 187         char *x509_chain;       /* certificate chain */\r
 188 #endif\r
 189         EVP_MD *md;             /* signature type */\r
 190 \r
 191         int md_enc;             /* is the md encrypted or not? */\r
 192         int md_len;             /* length of md_data */\r
 193         char *md_data;          /* message digest, could be pkey encrypted */\r
 194 \r
 195         EVP_CIPHER *dec;        /* date encryption cipher */\r
 196         int key_len;            /* key length */\r
 197         unsigned char *key;     /* key */\r
 198         /* unused, and wrong size\r
 199            unsigned char iv[8]; */\r
 200 \r
 201         \r
 202         int  data_enc;          /* is the data encrypted */\r
 203         int data_len;\r
 204         unsigned char *data;\r
 205         } PEM_CTX;\r
 206 \r
 207 /* These macros make the PEM_read/PEM_write functions easier to maintain and\r
 208  * write. Now they are all implemented with either:\r
 209  * IMPLEMENT_PEM_rw(...) or IMPLEMENT_PEM_rw_cb(...)\r
 210  */\r
 211 \r
 212 #ifdef OPENSSL_NO_FP_API\r
 213 \r
 214 #define IMPLEMENT_PEM_read_fp(name, type, str, asn1) /**/\r
 215 #define IMPLEMENT_PEM_write_fp(name, type, str, asn1) /**/\r
 216 #define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) /**/\r
 217 \r
 218 #else\r
 219 \r
 220 #define IMPLEMENT_PEM_read_fp(name, type, str, asn1) \\r
 221 type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u)\\r
 222 { \\r
 223 return(((type *(*)(D2I_OF(type),char *,FILE *,type **,pem_password_cb *,void *))openssl_fcast(PEM_ASN1_read))(d2i_##asn1, str,fp,x,cb,u)); \\r
 224 } \\r
 225 \r
 226 #define IMPLEMENT_PEM_write_fp(name, type, str, asn1) \\r
 227 int PEM_write_##name(FILE *fp, type *x) \\r
 228 { \\r
 229 return(((int (*)(I2D_OF(type),const char *,FILE *,type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write))(i2d_##asn1,str,fp,x,NULL,NULL,0,NULL,NULL)); \\r
 230 }\r
 231 \r
 232 #define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) \\r
 233 int PEM_write_##name(FILE *fp, const type *x) \\r
 234 { \\r
 235 return(((int (*)(I2D_OF_const(type),const char *,FILE *, const type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write))(i2d_##asn1,str,fp,x,NULL,NULL,0,NULL,NULL)); \\r
 236 }\r
 237 \r
 238 #define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) \\r
 239 int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \\r
 240              unsigned char *kstr, int klen, pem_password_cb *cb, \\r
 241                   void *u) \\r
 242         { \\r
 243         return(((int (*)(I2D_OF(type),const char *,FILE *,type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write))(i2d_##asn1,str,fp,x,enc,kstr,klen,cb,u)); \\r
 244         }\r
 245 \r
 246 #define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) \\r
 247 int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \\r
 248              unsigned char *kstr, int klen, pem_password_cb *cb, \\r
 249                   void *u) \\r
 250         { \\r
 251         return(((int (*)(I2D_OF_const(type),const char *,FILE *,type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write))(i2d_##asn1,str,fp,x,enc,kstr,klen,cb,u)); \\r
 252         }\r
 253 \r
 254 #endif\r
 255 \r
 256 #define IMPLEMENT_PEM_read_bio(name, type, str, asn1) \\r
 257 type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u)\\r
 258 { \\r
 259 return(((type *(*)(D2I_OF(type),const char *,BIO *,type **,pem_password_cb *,void *))openssl_fcast(PEM_ASN1_read_bio))(d2i_##asn1, str,bp,x,cb,u)); \\r
 260 }\r
 261 \r
 262 #define IMPLEMENT_PEM_write_bio(name, type, str, asn1) \\r
 263 int PEM_write_bio_##name(BIO *bp, type *x) \\r
 264 { \\r
 265 return(((int (*)(I2D_OF(type),const char *,BIO *,type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write_bio))(i2d_##asn1,str,bp,x,NULL,NULL,0,NULL,NULL)); \\r
 266 }\r
 267 \r
 268 #define IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \\r
 269 int PEM_write_bio_##name(BIO *bp, const type *x) \\r
 270 { \\r
 271 return(((int (*)(I2D_OF_const(type),const char *,BIO *,const type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write_bio))(i2d_##asn1,str,bp,x,NULL,NULL,0,NULL,NULL)); \\r
 272 }\r
 273 \r
 274 #define IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \\r
 275 int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \\r
 276              unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \\r
 277         { \\r
 278         return(((int (*)(I2D_OF(type),const char *,BIO *,type *,const EVP_CIPHER *,unsigned char *,int,pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write_bio))(i2d_##asn1,str,bp,x,enc,kstr,klen,cb,u)); \\r
 279         }\r
 280 \r
 281 #define IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \\r
 282 int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \\r
 283              unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \\r
 284         { \\r
 285         return(((int (*)(I2D_OF_const(type),const char *,BIO *,type *,const EVP_CIPHER *,unsigned char *,int,pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write_bio))(i2d_##asn1,str,bp,x,enc,kstr,klen,cb,u)); \\r
 286         }\r
 287 \r
 288 #define IMPLEMENT_PEM_write(name, type, str, asn1) \\r
 289         IMPLEMENT_PEM_write_bio(name, type, str, asn1) \\r
 290         IMPLEMENT_PEM_write_fp(name, type, str, asn1) \r
 291 \r
 292 #define IMPLEMENT_PEM_write_const(name, type, str, asn1) \\r
 293         IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \\r
 294         IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) \r
 295 \r
 296 #define IMPLEMENT_PEM_write_cb(name, type, str, asn1) \\r
 297         IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \\r
 298         IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) \r
 299 \r
 300 #define IMPLEMENT_PEM_write_cb_const(name, type, str, asn1) \\r
 301         IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \\r
 302         IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) \r
 303 \r
 304 #define IMPLEMENT_PEM_read(name, type, str, asn1) \\r
 305         IMPLEMENT_PEM_read_bio(name, type, str, asn1) \\r
 306         IMPLEMENT_PEM_read_fp(name, type, str, asn1) \r
 307 \r
 308 #define IMPLEMENT_PEM_rw(name, type, str, asn1) \\r
 309         IMPLEMENT_PEM_read(name, type, str, asn1) \\r
 310         IMPLEMENT_PEM_write(name, type, str, asn1)\r
 311 \r
 312 #define IMPLEMENT_PEM_rw_const(name, type, str, asn1) \\r
 313         IMPLEMENT_PEM_read(name, type, str, asn1) \\r
 314         IMPLEMENT_PEM_write_const(name, type, str, asn1)\r
 315 \r
 316 #define IMPLEMENT_PEM_rw_cb(name, type, str, asn1) \\r
 317         IMPLEMENT_PEM_read(name, type, str, asn1) \\r
 318         IMPLEMENT_PEM_write_cb(name, type, str, asn1)\r
 319 \r
 320 /* These are the same except they are for the declarations */\r
 321 \r
 322 #if defined(OPENSSL_SYS_WIN16) || defined(OPENSSL_NO_FP_API)\r
 323 \r
 324 #define DECLARE_PEM_read_fp(name, type) /**/\r
 325 #define DECLARE_PEM_write_fp(name, type) /**/\r
 326 #define DECLARE_PEM_write_cb_fp(name, type) /**/\r
 327 \r
 328 #else\r
 329 \r
 330 #define DECLARE_PEM_read_fp(name, type) \\r
 331         type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u);\r
 332 \r
 333 #define DECLARE_PEM_write_fp(name, type) \\r
 334         int PEM_write_##name(FILE *fp, type *x);\r
 335 \r
 336 #define DECLARE_PEM_write_fp_const(name, type) \\r
 337         int PEM_write_##name(FILE *fp, const type *x);\r
 338 \r
 339 #define DECLARE_PEM_write_cb_fp(name, type) \\r
 340         int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \\r
 341              unsigned char *kstr, int klen, pem_password_cb *cb, void *u);\r
 342 \r
 343 #endif\r
 344 \r
 345 #ifndef OPENSSL_NO_BIO\r
 346 #define DECLARE_PEM_read_bio(name, type) \\r
 347         type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u);\r
 348 \r
 349 #define DECLARE_PEM_write_bio(name, type) \\r
 350         int PEM_write_bio_##name(BIO *bp, type *x);\r
 351 \r
 352 #define DECLARE_PEM_write_bio_const(name, type) \\r
 353         int PEM_write_bio_##name(BIO *bp, const type *x);\r
 354 \r
 355 #define DECLARE_PEM_write_cb_bio(name, type) \\r
 356         int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \\r
 357              unsigned char *kstr, int klen, pem_password_cb *cb, void *u);\r
 358 \r
 359 #else\r
 360 \r
 361 #define DECLARE_PEM_read_bio(name, type) /**/\r
 362 #define DECLARE_PEM_write_bio(name, type) /**/\r
 363 #define DECLARE_PEM_write_cb_bio(name, type) /**/\r
 364 \r
 365 #endif\r
 366 \r
 367 #define DECLARE_PEM_write(name, type) \\r
 368         DECLARE_PEM_write_bio(name, type) \\r
 369         DECLARE_PEM_write_fp(name, type) \r
 370 \r
 371 #define DECLARE_PEM_write_const(name, type) \\r
 372         DECLARE_PEM_write_bio_const(name, type) \\r
 373         DECLARE_PEM_write_fp_const(name, type)\r
 374 \r
 375 #define DECLARE_PEM_write_cb(name, type) \\r
 376         DECLARE_PEM_write_cb_bio(name, type) \\r
 377         DECLARE_PEM_write_cb_fp(name, type) \r
 378 \r
 379 #define DECLARE_PEM_read(name, type) \\r
 380         DECLARE_PEM_read_bio(name, type) \\r
 381         DECLARE_PEM_read_fp(name, type)\r
 382 \r
 383 #define DECLARE_PEM_rw(name, type) \\r
 384         DECLARE_PEM_read(name, type) \\r
 385         DECLARE_PEM_write(name, type)\r
 386 \r
 387 #define DECLARE_PEM_rw_const(name, type) \\r
 388         DECLARE_PEM_read(name, type) \\r
 389         DECLARE_PEM_write_const(name, type)\r
 390 \r
 391 #define DECLARE_PEM_rw_cb(name, type) \\r
 392         DECLARE_PEM_read(name, type) \\r
 393         DECLARE_PEM_write_cb(name, type)\r
 394 \r
 395 #ifdef SSLEAY_MACROS\r
 396 \r
 397 #define PEM_write_SSL_SESSION(fp,x) \\r
 398                 PEM_ASN1_write((int (*)())i2d_SSL_SESSION, \\r
 399                         PEM_STRING_SSL_SESSION,fp, (char *)x, NULL,NULL,0,NULL,NULL)\r
 400 #define PEM_write_X509(fp,x) \\r
 401                 PEM_ASN1_write((int (*)())i2d_X509,PEM_STRING_X509,fp, \\r
 402                         (char *)x, NULL,NULL,0,NULL,NULL)\r
 403 #define PEM_write_X509_REQ(fp,x) PEM_ASN1_write( \\r
 404                 (int (*)())i2d_X509_REQ,PEM_STRING_X509_REQ,fp,(char *)x, \\r
 405                         NULL,NULL,0,NULL,NULL)\r
 406 #define PEM_write_X509_CRL(fp,x) \\r
 407                 PEM_ASN1_write((int (*)())i2d_X509_CRL,PEM_STRING_X509_CRL, \\r
 408                         fp,(char *)x, NULL,NULL,0,NULL,NULL)\r
 409 #define PEM_write_RSAPrivateKey(fp,x,enc,kstr,klen,cb,u) \\r
 410                 PEM_ASN1_write((int (*)())i2d_RSAPrivateKey,PEM_STRING_RSA,fp,\\r
 411                         (char *)x,enc,kstr,klen,cb,u)\r
 412 #define PEM_write_RSAPublicKey(fp,x) \\r
 413                 PEM_ASN1_write((int (*)())i2d_RSAPublicKey,\\r
 414                         PEM_STRING_RSA_PUBLIC,fp,(char *)x,NULL,NULL,0,NULL,NULL)\r
 415 #define PEM_write_DSAPrivateKey(fp,x,enc,kstr,klen,cb,u) \\r
 416                 PEM_ASN1_write((int (*)())i2d_DSAPrivateKey,PEM_STRING_DSA,fp,\\r
 417                         (char *)x,enc,kstr,klen,cb,u)\r
 418 #define PEM_write_PrivateKey(bp,x,enc,kstr,klen,cb,u) \\r
 419                 PEM_ASN1_write((int (*)())i2d_PrivateKey,\\r
 420                 (((x)->type == EVP_PKEY_DSA)?PEM_STRING_DSA:PEM_STRING_RSA),\\r
 421                         bp,(char *)x,enc,kstr,klen,cb,u)\r
 422 #define PEM_write_PKCS7(fp,x) \\r
 423                 PEM_ASN1_write((int (*)())i2d_PKCS7,PEM_STRING_PKCS7,fp, \\r
 424                         (char *)x, NULL,NULL,0,NULL,NULL)\r
 425 #define PEM_write_DHparams(fp,x) \\r
 426                 PEM_ASN1_write((int (*)())i2d_DHparams,PEM_STRING_DHPARAMS,fp,\\r
 427                         (char *)x,NULL,NULL,0,NULL,NULL)\r
 428 \r
 429 #define PEM_write_NETSCAPE_CERT_SEQUENCE(fp,x) \\r
 430                 PEM_ASN1_write((int (*)())i2d_NETSCAPE_CERT_SEQUENCE, \\r
 431                         PEM_STRING_X509,fp, \\r
 432                         (char *)x, NULL,NULL,0,NULL,NULL)\r
 433 \r
 434 #define PEM_read_SSL_SESSION(fp,x,cb,u) (SSL_SESSION *)PEM_ASN1_read( \\r
 435         (char *(*)())d2i_SSL_SESSION,PEM_STRING_SSL_SESSION,fp,(char **)x,cb,u)\r
 436 #define PEM_read_X509(fp,x,cb,u) (X509 *)PEM_ASN1_read( \\r
 437         (char *(*)())d2i_X509,PEM_STRING_X509,fp,(char **)x,cb,u)\r
 438 #define PEM_read_X509_REQ(fp,x,cb,u) (X509_REQ *)PEM_ASN1_read( \\r
 439         (char *(*)())d2i_X509_REQ,PEM_STRING_X509_REQ,fp,(char **)x,cb,u)\r
 440 #define PEM_read_X509_CRL(fp,x,cb,u) (X509_CRL *)PEM_ASN1_read( \\r
 441         (char *(*)())d2i_X509_CRL,PEM_STRING_X509_CRL,fp,(char **)x,cb,u)\r
 442 #define PEM_read_RSAPrivateKey(fp,x,cb,u) (RSA *)PEM_ASN1_read( \\r
 443         (char *(*)())d2i_RSAPrivateKey,PEM_STRING_RSA,fp,(char **)x,cb,u)\r
 444 #define PEM_read_RSAPublicKey(fp,x,cb,u) (RSA *)PEM_ASN1_read( \\r
 445         (char *(*)())d2i_RSAPublicKey,PEM_STRING_RSA_PUBLIC,fp,(char **)x,cb,u)\r
 446 #define PEM_read_DSAPrivateKey(fp,x,cb,u) (DSA *)PEM_ASN1_read( \\r
 447         (char *(*)())d2i_DSAPrivateKey,PEM_STRING_DSA,fp,(char **)x,cb,u)\r
 448 #define PEM_read_PrivateKey(fp,x,cb,u) (EVP_PKEY *)PEM_ASN1_read( \\r
 449         (char *(*)())d2i_PrivateKey,PEM_STRING_EVP_PKEY,fp,(char **)x,cb,u)\r
 450 #define PEM_read_PKCS7(fp,x,cb,u) (PKCS7 *)PEM_ASN1_read( \\r
 451         (char *(*)())d2i_PKCS7,PEM_STRING_PKCS7,fp,(char **)x,cb,u)\r
 452 #define PEM_read_DHparams(fp,x,cb,u) (DH *)PEM_ASN1_read( \\r
 453         (char *(*)())d2i_DHparams,PEM_STRING_DHPARAMS,fp,(char **)x,cb,u)\r
 454 \r
 455 #define PEM_read_NETSCAPE_CERT_SEQUENCE(fp,x,cb,u) \\r
 456                 (NETSCAPE_CERT_SEQUENCE *)PEM_ASN1_read( \\r
 457         (char *(*)())d2i_NETSCAPE_CERT_SEQUENCE,PEM_STRING_X509,fp,\\r
 458                                                         (char **)x,cb,u)\r
 459 \r
 460 #define PEM_write_bio_X509(bp,x) \\r
 461                 PEM_ASN1_write_bio((int (*)())i2d_X509,PEM_STRING_X509,bp, \\r
 462                         (char *)x, NULL,NULL,0,NULL,NULL)\r
 463 #define PEM_write_bio_X509_REQ(bp,x) PEM_ASN1_write_bio( \\r
 464                 (int (*)())i2d_X509_REQ,PEM_STRING_X509_REQ,bp,(char *)x, \\r
 465                         NULL,NULL,0,NULL,NULL)\r
 466 #define PEM_write_bio_X509_CRL(bp,x) \\r
 467                 PEM_ASN1_write_bio((int (*)())i2d_X509_CRL,PEM_STRING_X509_CRL,\\r
 468                         bp,(char *)x, NULL,NULL,0,NULL,NULL)\r
 469 #define PEM_write_bio_RSAPrivateKey(bp,x,enc,kstr,klen,cb,u) \\r
 470                 PEM_ASN1_write_bio((int (*)())i2d_RSAPrivateKey,PEM_STRING_RSA,\\r
 471                         bp,(char *)x,enc,kstr,klen,cb,u)\r
 472 #define PEM_write_bio_RSAPublicKey(bp,x) \\r
 473                 PEM_ASN1_write_bio((int (*)())i2d_RSAPublicKey, \\r
 474                         PEM_STRING_RSA_PUBLIC,\\r
 475                         bp,(char *)x,NULL,NULL,0,NULL,NULL)\r
 476 #define PEM_write_bio_DSAPrivateKey(bp,x,enc,kstr,klen,cb,u) \\r
 477                 PEM_ASN1_write_bio((int (*)())i2d_DSAPrivateKey,PEM_STRING_DSA,\\r
 478                         bp,(char *)x,enc,kstr,klen,cb,u)\r
 479 #define PEM_write_bio_PrivateKey(bp,x,enc,kstr,klen,cb,u) \\r
 480                 PEM_ASN1_write_bio((int (*)())i2d_PrivateKey,\\r
 481                 (((x)->type == EVP_PKEY_DSA)?PEM_STRING_DSA:PEM_STRING_RSA),\\r
 482                         bp,(char *)x,enc,kstr,klen,cb,u)\r
 483 #define PEM_write_bio_PKCS7(bp,x) \\r
 484                 PEM_ASN1_write_bio((int (*)())i2d_PKCS7,PEM_STRING_PKCS7,bp, \\r
 485                         (char *)x, NULL,NULL,0,NULL,NULL)\r
 486 #define PEM_write_bio_DHparams(bp,x) \\r
 487                 PEM_ASN1_write_bio((int (*)())i2d_DHparams,PEM_STRING_DHPARAMS,\\r
 488                         bp,(char *)x,NULL,NULL,0,NULL,NULL)\r
 489 #define PEM_write_bio_DSAparams(bp,x) \\r
 490                 PEM_ASN1_write_bio((int (*)())i2d_DSAparams, \\r
 491                         PEM_STRING_DSAPARAMS,bp,(char *)x,NULL,NULL,0,NULL,NULL)\r
 492 \r
 493 #define PEM_write_bio_NETSCAPE_CERT_SEQUENCE(bp,x) \\r
 494                 PEM_ASN1_write_bio((int (*)())i2d_NETSCAPE_CERT_SEQUENCE, \\r
 495                         PEM_STRING_X509,bp, \\r
 496                         (char *)x, NULL,NULL,0,NULL,NULL)\r
 497 \r
 498 #define PEM_read_bio_X509(bp,x,cb,u) (X509 *)PEM_ASN1_read_bio( \\r
 499         (char *(*)())d2i_X509,PEM_STRING_X509,bp,(char **)x,cb,u)\r
 500 #define PEM_read_bio_X509_REQ(bp,x,cb,u) (X509_REQ *)PEM_ASN1_read_bio( \\r
 501         (char *(*)())d2i_X509_REQ,PEM_STRING_X509_REQ,bp,(char **)x,cb,u)\r
 502 #define PEM_read_bio_X509_CRL(bp,x,cb,u) (X509_CRL *)PEM_ASN1_read_bio( \\r
 503         (char *(*)())d2i_X509_CRL,PEM_STRING_X509_CRL,bp,(char **)x,cb,u)\r
 504 #define PEM_read_bio_RSAPrivateKey(bp,x,cb,u) (RSA *)PEM_ASN1_read_bio( \\r
 505         (char *(*)())d2i_RSAPrivateKey,PEM_STRING_RSA,bp,(char **)x,cb,u)\r
 506 #define PEM_read_bio_RSAPublicKey(bp,x,cb,u) (RSA *)PEM_ASN1_read_bio( \\r
 507         (char *(*)())d2i_RSAPublicKey,PEM_STRING_RSA_PUBLIC,bp,(char **)x,cb,u)\r
 508 #define PEM_read_bio_DSAPrivateKey(bp,x,cb,u) (DSA *)PEM_ASN1_read_bio( \\r
 509         (char *(*)())d2i_DSAPrivateKey,PEM_STRING_DSA,bp,(char **)x,cb,u)\r
 510 #define PEM_read_bio_PrivateKey(bp,x,cb,u) (EVP_PKEY *)PEM_ASN1_read_bio( \\r
 511         (char *(*)())d2i_PrivateKey,PEM_STRING_EVP_PKEY,bp,(char **)x,cb,u)\r
 512 \r
 513 #define PEM_read_bio_PKCS7(bp,x,cb,u) (PKCS7 *)PEM_ASN1_read_bio( \\r
 514         (char *(*)())d2i_PKCS7,PEM_STRING_PKCS7,bp,(char **)x,cb,u)\r
 515 #define PEM_read_bio_DHparams(bp,x,cb,u) (DH *)PEM_ASN1_read_bio( \\r
 516         (char *(*)())d2i_DHparams,PEM_STRING_DHPARAMS,bp,(char **)x,cb,u)\r
 517 #define PEM_read_bio_DSAparams(bp,x,cb,u) (DSA *)PEM_ASN1_read_bio( \\r
 518         (char *(*)())d2i_DSAparams,PEM_STRING_DSAPARAMS,bp,(char **)x,cb,u)\r
 519 \r
 520 #define PEM_read_bio_NETSCAPE_CERT_SEQUENCE(bp,x,cb,u) \\r
 521                 (NETSCAPE_CERT_SEQUENCE *)PEM_ASN1_read_bio( \\r
 522         (char *(*)())d2i_NETSCAPE_CERT_SEQUENCE,PEM_STRING_X509,bp,\\r
 523                                                         (char **)x,cb,u)\r
 524 \r
 525 #endif\r
 526 \r
 527 #if 1\r
 528 /* "userdata": new with OpenSSL 0.9.4 */\r
 529 typedef int pem_password_cb(char *buf, int size, int rwflag, void *userdata);\r
 530 #else\r
 531 /* OpenSSL 0.9.3, 0.9.3a */\r
 532 typedef int pem_password_cb(char *buf, int size, int rwflag);\r
 533 #endif\r
 534 \r
 535 int     PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher);\r
 536 int     PEM_do_header (EVP_CIPHER_INFO *cipher, unsigned char *data,long *len,\r
 537         pem_password_cb *callback,void *u);\r
 538 \r
 539 #ifndef OPENSSL_NO_BIO\r
 540 int     PEM_read_bio(BIO *bp, char **name, char **header,\r
 541                 unsigned char **data,long *len);\r
 542 int     PEM_write_bio(BIO *bp,const char *name,char *hdr,unsigned char *data,\r
 543                 long len);\r
 544 int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm, const char *name, BIO *bp,\r
 545              pem_password_cb *cb, void *u);\r
 546 void *  PEM_ASN1_read_bio(d2i_of_void *d2i, const char *name, BIO *bp,\r
 547                           void **x, pem_password_cb *cb, void *u);\r
 548 #define PEM_ASN1_read_bio_of(type,d2i,name,bp,x,cb,u) \\r
 549 ((type *(*)(D2I_OF(type),const char *,BIO *,type **,pem_password_cb *,void *))openssl_fcast(PEM_ASN1_read_bio))(d2i,name,bp,x,cb,u)\r
 550 int     PEM_ASN1_write_bio(i2d_of_void *i2d,const char *name,BIO *bp,char *x,\r
 551                            const EVP_CIPHER *enc,unsigned char *kstr,int klen,\r
 552                            pem_password_cb *cb, void *u);\r
 553 #define PEM_ASN1_write_bio_of(type,i2d,name,bp,x,enc,kstr,klen,cb,u) \\r
 554         ((int (*)(I2D_OF(type),const char *,BIO *,type *, const EVP_CIPHER *,unsigned char *,int, pem_password_cb *,void *))openssl_fcast(PEM_ASN1_write_bio))(i2d,name,bp,x,enc,kstr,klen,cb,u)\r
 555 \r
 556 STACK_OF(X509_INFO) *   PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk, pem_password_cb *cb, void *u);\r
 557 int     PEM_X509_INFO_write_bio(BIO *bp,X509_INFO *xi, EVP_CIPHER *enc,\r
 558                 unsigned char *kstr, int klen, pem_password_cb *cd, void *u);\r
 559 #endif\r
 560 \r
 561 #ifndef OPENSSL_SYS_WIN16\r
 562 int     PEM_read(FILE *fp, char **name, char **header,\r
 563                 unsigned char **data,long *len);\r
 564 int     PEM_write(FILE *fp,char *name,char *hdr,unsigned char *data,long len);\r
 565 void *  PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x,\r
 566                       pem_password_cb *cb, void *u);\r
 567 int     PEM_ASN1_write(i2d_of_void *i2d,const char *name,FILE *fp,\r
 568                        char *x,const EVP_CIPHER *enc,unsigned char *kstr,\r
 569                        int klen,pem_password_cb *callback, void *u);\r
 570 STACK_OF(X509_INFO) *   PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk,\r
 571         pem_password_cb *cb, void *u);\r
 572 #endif\r
 573 \r
 574 int     PEM_SealInit(PEM_ENCODE_SEAL_CTX *ctx, EVP_CIPHER *type,\r
 575                 EVP_MD *md_type, unsigned char **ek, int *ekl,\r
 576                 unsigned char *iv, EVP_PKEY **pubk, int npubk);\r
 577 void    PEM_SealUpdate(PEM_ENCODE_SEAL_CTX *ctx, unsigned char *out, int *outl,\r
 578                 unsigned char *in, int inl);\r
 579 int     PEM_SealFinal(PEM_ENCODE_SEAL_CTX *ctx, unsigned char *sig,int *sigl,\r
 580                 unsigned char *out, int *outl, EVP_PKEY *priv);\r
 581 \r
 582 void    PEM_SignInit(EVP_MD_CTX *ctx, EVP_MD *type);\r
 583 void    PEM_SignUpdate(EVP_MD_CTX *ctx,unsigned char *d,unsigned int cnt);\r
 584 int     PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret,\r
 585                 unsigned int *siglen, EVP_PKEY *pkey);\r
 586 \r
 587 int     PEM_def_callback(char *buf, int num, int w, void *key);\r
 588 void    PEM_proc_type(char *buf, int type);\r
 589 void    PEM_dek_info(char *buf, const char *type, int len, char *str);\r
 590 \r
 591 #ifndef SSLEAY_MACROS\r
 592 \r
 593 #include <openssl/symhacks.h>\r
 594 \r
 595 DECLARE_PEM_rw(X509, X509)\r
 596 \r
 597 DECLARE_PEM_rw(X509_AUX, X509)\r
 598 \r
 599 DECLARE_PEM_rw(X509_CERT_PAIR, X509_CERT_PAIR)\r
 600 \r
 601 DECLARE_PEM_rw(X509_REQ, X509_REQ)\r
 602 DECLARE_PEM_write(X509_REQ_NEW, X509_REQ)\r
 603 \r
 604 DECLARE_PEM_rw(X509_CRL, X509_CRL)\r
 605 \r
 606 DECLARE_PEM_rw(PKCS7, PKCS7)\r
 607 \r
 608 DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE)\r
 609 \r
 610 DECLARE_PEM_rw(PKCS8, X509_SIG)\r
 611 \r
 612 DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO)\r
 613 \r
 614 #ifndef OPENSSL_NO_RSA\r
 615 \r
 616 DECLARE_PEM_rw_cb(RSAPrivateKey, RSA)\r
 617 \r
 618 DECLARE_PEM_rw_const(RSAPublicKey, RSA)\r
 619 DECLARE_PEM_rw(RSA_PUBKEY, RSA)\r
 620 \r
 621 #endif\r
 622 \r
 623 #ifndef OPENSSL_NO_DSA\r
 624 \r
 625 DECLARE_PEM_rw_cb(DSAPrivateKey, DSA)\r
 626 \r
 627 DECLARE_PEM_rw(DSA_PUBKEY, DSA)\r
 628 \r
 629 DECLARE_PEM_rw_const(DSAparams, DSA)\r
 630 \r
 631 #endif\r
 632 \r
 633 #ifndef OPENSSL_NO_EC\r
 634 DECLARE_PEM_rw_const(ECPKParameters, EC_GROUP)\r
 635 DECLARE_PEM_rw_cb(ECPrivateKey, EC_KEY)\r
 636 DECLARE_PEM_rw(EC_PUBKEY, EC_KEY)\r
 637 #endif\r
 638 \r
 639 #ifndef OPENSSL_NO_DH\r
 640 \r
 641 DECLARE_PEM_rw_const(DHparams, DH)\r
 642 \r
 643 #endif\r
 644 \r
 645 DECLARE_PEM_rw_cb(PrivateKey, EVP_PKEY)\r
 646 \r
 647 DECLARE_PEM_rw(PUBKEY, EVP_PKEY)\r
 648 \r
 649 int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, EVP_PKEY *x, int nid,\r
 650                                   char *kstr, int klen,\r
 651                                   pem_password_cb *cb, void *u);\r
 652 int PEM_write_bio_PKCS8PrivateKey(BIO *, EVP_PKEY *, const EVP_CIPHER *,\r
 653                                   char *, int, pem_password_cb *, void *);\r
 654 int i2d_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,\r
 655                                   char *kstr, int klen,\r
 656                                   pem_password_cb *cb, void *u);\r
 657 int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, EVP_PKEY *x, int nid,\r
 658                                   char *kstr, int klen,\r
 659                                   pem_password_cb *cb, void *u);\r
 660 EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, void *u);\r
 661 \r
 662 int i2d_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,\r
 663                                   char *kstr, int klen,\r
 664                                   pem_password_cb *cb, void *u);\r
 665 int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, EVP_PKEY *x, int nid,\r
 666                                   char *kstr, int klen,\r
 667                                   pem_password_cb *cb, void *u);\r
 668 int PEM_write_PKCS8PrivateKey_nid(FILE *fp, EVP_PKEY *x, int nid,\r
 669                                   char *kstr, int klen,\r
 670                                   pem_password_cb *cb, void *u);\r
 671 \r
 672 EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb, void *u);\r
 673 \r
 674 int PEM_write_PKCS8PrivateKey(FILE *fp,EVP_PKEY *x,const EVP_CIPHER *enc,\r
 675                               char *kstr,int klen, pem_password_cb *cd, void *u);\r
 676 \r
 677 #endif /* SSLEAY_MACROS */\r
 678 \r
 679 \r
 680 /* BEGIN ERROR CODES */\r
 681 /* The following lines are auto generated by the script mkerr.pl. Any changes\r
 682  * made after this point may be overwritten when the script is next run.\r
 683  */\r
 684 void ERR_load_PEM_strings(void);\r
 685 \r
 686 /* Error codes for the PEM functions. */\r
 687 \r
 688 /* Function codes. */\r
 689 #define PEM_F_D2I_PKCS8PRIVATEKEY_BIO                    120\r
 690 #define PEM_F_D2I_PKCS8PRIVATEKEY_FP                     121\r
 691 #define PEM_F_DO_PK8PKEY                                 126\r
 692 #define PEM_F_DO_PK8PKEY_FP                              125\r
 693 #define PEM_F_LOAD_IV                                    101\r
 694 #define PEM_F_PEM_ASN1_READ                              102\r
 695 #define PEM_F_PEM_ASN1_READ_BIO                          103\r
 696 #define PEM_F_PEM_ASN1_WRITE                             104\r
 697 #define PEM_F_PEM_ASN1_WRITE_BIO                         105\r
 698 #define PEM_F_PEM_DEF_CALLBACK                           100\r
 699 #define PEM_F_PEM_DO_HEADER                              106\r
 700 #define PEM_F_PEM_F_PEM_WRITE_PKCS8PRIVATEKEY            118\r
 701 #define PEM_F_PEM_GET_EVP_CIPHER_INFO                    107\r
 702 #define PEM_F_PEM_PK8PKEY                                119\r
 703 #define PEM_F_PEM_READ                                   108\r
 704 #define PEM_F_PEM_READ_BIO                               109\r
 705 #define PEM_F_PEM_READ_BIO_PRIVATEKEY                    123\r
 706 #define PEM_F_PEM_READ_PRIVATEKEY                        124\r
 707 #define PEM_F_PEM_SEALFINAL                              110\r
 708 #define PEM_F_PEM_SEALINIT                               111\r
 709 #define PEM_F_PEM_SIGNFINAL                              112\r
 710 #define PEM_F_PEM_WRITE                                  113\r
 711 #define PEM_F_PEM_WRITE_BIO                              114\r
 712 #define PEM_F_PEM_X509_INFO_READ                         115\r
 713 #define PEM_F_PEM_X509_INFO_READ_BIO                     116\r
 714 #define PEM_F_PEM_X509_INFO_WRITE_BIO                    117\r
 715 \r
 716 /* Reason codes. */\r
 717 #define PEM_R_BAD_BASE64_DECODE                          100\r
 718 #define PEM_R_BAD_DECRYPT                                101\r
 719 #define PEM_R_BAD_END_LINE                               102\r
 720 #define PEM_R_BAD_IV_CHARS                               103\r
 721 #define PEM_R_BAD_PASSWORD_READ                          104\r
 722 #define PEM_R_ERROR_CONVERTING_PRIVATE_KEY               115\r
 723 #define PEM_R_NOT_DEK_INFO                               105\r
 724 #define PEM_R_NOT_ENCRYPTED                              106\r
 725 #define PEM_R_NOT_PROC_TYPE                              107\r
 726 #define PEM_R_NO_START_LINE                              108\r
 727 #define PEM_R_PROBLEMS_GETTING_PASSWORD                  109\r
 728 #define PEM_R_PUBLIC_KEY_NO_RSA                          110\r
 729 #define PEM_R_READ_KEY                                   111\r
 730 #define PEM_R_SHORT_HEADER                               112\r
 731 #define PEM_R_UNSUPPORTED_CIPHER                         113\r
 732 #define PEM_R_UNSUPPORTED_ENCRYPTION                     114\r
 733 \r
 734 #ifdef  __cplusplus\r
 735 }\r
 736 #endif\r
 737 #endif\r