Upgrade chrome's OpenSSL to same version Android ships with.

openssl/apps/ca.c

 /* apps/ca.c */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
  * This package is an SSL implementation written
  * by Eric Young (eay@cryptsoft.com).
  * The implementation was written so as to conform with Netscapes SSL.
  * 
  * This library is free for commercial and non-commercial use as long as
  * the following conditions are aheared to.  The following conditions
@@ skipping 45 matching lines @@
  * [including the GNU Public Licence.]
  */
 
 /* The PPKI stuff has been donated by Jeff Barber <jeffb@issl.atl.hp.com> */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 #include <sys/types.h>
-#include <sys/stat.h>
 #include <openssl/conf.h>
 #include <openssl/bio.h>
 #include <openssl/err.h>
 #include <openssl/bn.h>
 #include <openssl/txt_db.h>
 #include <openssl/evp.h>
 #include <openssl/x509.h>
 #include <openssl/x509v3.h>
 #include <openssl/objects.h>
 #include <openssl/ocsp.h>
 #include <openssl/pem.h>
 
 #ifndef W_OK
 #  ifdef OPENSSL_SYS_VMS
 #    if defined(__DECC)
 #      include <unistd.h>
 #    else
 #      include <unixlib.h>
 #    endif
-#  elif !defined(OPENSSL_SYS_VXWORKS) && !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_NETWARE) && !defined(__TANDEM)
+#  elif !defined(OPENSSL_SYS_VXWORKS) && !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_NETWARE)
 #    include <sys/file.h>
 #  endif
 #endif
 
 #include "apps.h"
 
 #ifndef W_OK
 #  define F_OK 0
 #  define X_OK 1
 #  define W_OK 2
@@ skipping 154 matching lines @@
         int badops=0;
         int ret=1;
         int email_dn=1;
         int req=0;
         int verbose=0;
         int gencrl=0;
         int dorevoke=0;
         int doupdatedb=0;
         long crldays=0;
         long crlhours=0;
+        long crlsec=0;
         long errorline= -1;
         char *configfile=NULL;
         char *md=NULL;
         char *policy=NULL;
         char *keyfile=NULL;
         char *certfile=NULL;
         int keyform=FORMAT_PEM;
         char *infile=NULL;
         char *spkac_file=NULL;
         char *ss_cert_file=NULL;
@@ skipping 27 matching lines @@
         X509 *x509=NULL, *x509p = NULL;
         X509 *x=NULL;
         BIO *in=NULL,*out=NULL,*Sout=NULL,*Cout=NULL;
         char *dbfile=NULL;
         CA_DB *db=NULL;
         X509_CRL *crl=NULL;
         X509_REVOKED *r=NULL;
         ASN1_TIME *tmptm;
         ASN1_INTEGER *tmpser;
         char *f;
-        const char *p, **pp;
+        const char *p;
+        char * const *pp;
         int i,j;
         const EVP_MD *dgst=NULL;
         STACK_OF(CONF_VALUE) *attribs=NULL;
         STACK_OF(X509) *cert_sk=NULL;
 #undef BSIZE
 #define BSIZE 256
         MS_STATIC char buf[3][BSIZE];
         char *randfile=NULL;
 #ifndef OPENSSL_NO_ENGINE
         char *engine = NULL;
@@ skipping 130 matching lines @@
                 else if (strcmp(*argv,"-crldays") == 0)
                         {
                         if (--argc < 1) goto bad;
                         crldays= atol(*(++argv));
                         }
                 else if (strcmp(*argv,"-crlhours") == 0)
                         {
                         if (--argc < 1) goto bad;
                         crlhours= atol(*(++argv));
                         }
+                else if (strcmp(*argv,"-crlsec") == 0)
+                        {
+                        if (--argc < 1) goto bad;
+                        crlsec = atol(*(++argv));
+                        }
                 else if (strcmp(*argv,"-infiles") == 0)
                         {
                         argc--;
                         argv++;
                         req=1;
                         break;
                         }
                 else if (strcmp(*argv, "-ss_cert") == 0)
                         {
                         if (--argc < 1) goto bad;
@@ skipping 73 matching lines @@
                         BIO_printf(bio_err,"unknown option %s\n",*argv);
                         badops=1;
                         break;
                         }
                 argc--;
                 argv++;
                 }
 
         if (badops)
                 {
-                for (pp=ca_usage; (*pp != NULL); pp++)
-                        BIO_printf(bio_err,"%s",*pp);
+                const char **pp2;
+
+                for (pp2=ca_usage; (*pp2 != NULL); pp2++)
+                        BIO_printf(bio_err,"%s",*pp2);
                 goto err;
                 }
 
         ERR_load_crypto_strings();
 
         /*****************************************************************/
         tofree=NULL;
         if (configfile == NULL) configfile = getenv("OPENSSL_CONF");
         if (configfile == NULL) configfile = getenv("SSLEAY_CONF");
         if (configfile == NULL)
@@ skipping 254 matching lines @@
                         goto err;
                         }
                 }
         else
                 ERR_clear_error();
 
         /*****************************************************************/
         /* lookup where to write new certificates */
         if ((outdir == NULL) && (req))
                 {
-                struct stat sb;
 
                 if ((outdir=NCONF_get_string(conf,section,ENV_NEW_CERTS_DIR))
                         == NULL)
                         {
                         BIO_printf(bio_err,"there needs to be defined a directory for new certificate to be placed in\n");
                         goto err;
                         }
 #ifndef OPENSSL_SYS_VMS
             /* outdir is a directory spec, but access() for VMS demands a
                filename.  In any case, stat(), below, will catch the problem
                if outdir is not a directory spec, and the fopen() or open()
                will catch an error if there is no write access.
 
                Presumably, this problem could also be solved by using the DEC
                C routines to convert the directory syntax to Unixly, and give
                that to access().  However, time's too short to do that just
                now.
             */
+#ifndef _WIN32
                 if (access(outdir,R_OK|W_OK|X_OK) != 0)
+#else
+                if (_access(outdir,R_OK|W_OK|X_OK) != 0)
+#endif
                         {
                         BIO_printf(bio_err,"I am unable to access the %s directory\n",outdir);
                         perror(outdir);
                         goto err;
                         }
 
-                if (stat(outdir,&sb) != 0)
-                        {
-                        BIO_printf(bio_err,"unable to stat(%s)\n",outdir);
-                        perror(outdir);
-                        goto err;
-                        }
-#ifdef S_ISDIR
-                if (!S_ISDIR(sb.st_mode))
+                if (app_isdir(outdir)<=0)
                         {
                         BIO_printf(bio_err,"%s need to be a directory\n",outdir);
                         perror(outdir);
                         goto err;
                         }
 #endif
-#endif
                 }
 
         /*****************************************************************/
         /* we need to load the database file */
         if ((dbfile=NCONF_get_string(conf,section,ENV_DATABASE)) == NULL)
                 {
                 lookup_fail(section,ENV_DATABASE);
                 goto err;
                 }
         db = load_index(dbfile, &db_attr);
         if (db == NULL) goto err;
 
         /* Lets check some fields */
-        for (i=0; i<sk_num(db->db->data); i++)
+        for (i=0; i<sk_OPENSSL_PSTRING_num(db->db->data); i++)
                 {
-                pp=(const char **)sk_value(db->db->data,i);
+                pp=sk_OPENSSL_PSTRING_value(db->db->data,i);
                 if ((pp[DB_type][0] != DB_TYPE_REV) &&
                         (pp[DB_rev_date][0] != '\0'))
                         {
                         BIO_printf(bio_err,"entry %d: not revoked yet, but has a revocation date\n",i+1);
                         goto err;
                         }
                 if ((pp[DB_type][0] == DB_TYPE_REV) &&
                         !make_revoked(NULL, pp[DB_rev_date]))
                         {
                         BIO_printf(bio_err," in entry %d\n", i+1);
                         goto err;
                         }
-                if (!check_time_format(pp[DB_exp_date]))
+                if (!check_time_format((char *)pp[DB_exp_date]))
                         {
                         BIO_printf(bio_err,"entry %d: invalid expiry date\n",i+1);
                         goto err;
                         }
                 p=pp[DB_serial];
                 j=strlen(p);
                 if (*p == '-')
                         {
                         p++;
                         j--;
@@ skipping 19 matching lines @@
                 {
                 BIO_set_fp(out,stdout,BIO_NOCLOSE|BIO_FP_TEXT); /* cannot fail */
 #ifdef OPENSSL_SYS_VMS
                 {
                 BIO *tmpbio = BIO_new(BIO_f_linebuffer());
                 out = BIO_push(tmpbio, out);
                 }
 #endif
                 TXT_DB_write(out,db->db);
                 BIO_printf(bio_err,"%d entries loaded from the database\n",
-                        db->db->data->num);
+                           sk_OPENSSL_PSTRING_num(db->db->data));
                 BIO_printf(bio_err,"generating index\n");
                 }
         
         if (!index_index(db)) goto err;
 
         /*****************************************************************/
         /* Update the db file for expired certificates */
         if (doupdatedb)
                 {
                 if (verbose)
@@ skipping 70 matching lines @@
                         }
                 }
 
         if ((md == NULL) && ((md=NCONF_get_string(conf,
                 section,ENV_DEFAULT_MD)) == NULL))
                 {
                 lookup_fail(section,ENV_DEFAULT_MD);
                 goto err;
                 }
 
+        if (!strcmp(md, "default"))
+                {
+                int def_nid;
+                if (EVP_PKEY_get_default_digest_nid(pkey, &def_nid) <= 0)
+                        {
+                        BIO_puts(bio_err,"no default digest\n");
+                        goto err;
+                        }
+                md = (char *)OBJ_nid2sn(def_nid);
+                }
+
         if ((dgst=EVP_get_digestbyname(md)) == NULL)
                 {
                 BIO_printf(bio_err,"%s is an unsupported message digest type\n",md);
                 goto err;
                 }
 
         if (req)
                 {
                 if ((email_dn == 1) && ((tmp_email_dn=NCONF_get_string(conf,
                         section,ENV_DEFAULT_EMAIL_DN)) != NULL ))
@@ skipping 49 matching lines @@
                                 }
                         }
 
                 if (startdate == NULL)
                         {
                         startdate=NCONF_get_string(conf,section,
                                 ENV_DEFAULT_STARTDATE);
                         if (startdate == NULL)
                                 ERR_clear_error();
                         }
-                if (startdate && !ASN1_UTCTIME_set_string(NULL,startdate))
+                if (startdate && !ASN1_TIME_set_string(NULL, startdate))
                         {
-                        BIO_printf(bio_err,"start date is invalid, it should be YYMMDDHHMMSSZ\n");
+                        BIO_printf(bio_err,"start date is invalid, it should be YYMMDDHHMMSSZ or YYYYMMDDHHMMSSZ\n");
                         goto err;
                         }
                 if (startdate == NULL) startdate="today";
 
                 if (enddate == NULL)
                         {
                         enddate=NCONF_get_string(conf,section,
                                 ENV_DEFAULT_ENDDATE);
                         if (enddate == NULL)
                                 ERR_clear_error();
                         }
-                if (enddate && !ASN1_UTCTIME_set_string(NULL,enddate))
+                if (enddate && !ASN1_TIME_set_string(NULL, enddate))
                         {
-                        BIO_printf(bio_err,"end date is invalid, it should be YYMMDDHHMMSSZ\n");
+                        BIO_printf(bio_err,"end date is invalid, it should be YYMMDDHHMMSSZ or YYYYMMDDHHMMSSZ\n");
                         goto err;
                         }
 
                 if (days == 0)
                         {
                         if(!NCONF_get_number(conf,section, ENV_DEFAULT_DAYS, &days))
                                 days = 0;
                         }
                 if (!enddate && (days == 0))
                         {
@@ skipping 239 matching lines @@
                         }
 
                 if ((crlnumberfile=NCONF_get_string(conf,section,ENV_CRLNUMBER))
                         != NULL)
                         if ((crlnumber=load_serial(crlnumberfile,0,NULL)) == NULL)
                                 {
                                 BIO_printf(bio_err,"error while loading CRL number\n");
                                 goto err;
                                 }
 
-                if (!crldays && !crlhours)
+                if (!crldays && !crlhours && !crlsec)
                         {
                         if (!NCONF_get_number(conf,section,
                                 ENV_DEFAULT_CRL_DAYS, &crldays))
                                 crldays = 0;
                         if (!NCONF_get_number(conf,section,
                                 ENV_DEFAULT_CRL_HOURS, &crlhours))
                                 crlhours = 0;
                         }
-                if ((crldays == 0) && (crlhours == 0))
+                if ((crldays == 0) && (crlhours == 0) && (crlsec == 0))
                         {
                         BIO_printf(bio_err,"cannot lookup how long until the next CRL is issued\n");
                         goto err;
                         }
 
                 if (verbose) BIO_printf(bio_err,"making CRL\n");
                 if ((crl=X509_CRL_new()) == NULL) goto err;
                 if (!X509_CRL_set_issuer_name(crl, X509_get_subject_name(x509))) goto err;
 
                 tmptm = ASN1_TIME_new();
                 if (!tmptm) goto err;
                 X509_gmtime_adj(tmptm,0);
                 X509_CRL_set_lastUpdate(crl, tmptm);    
-                X509_gmtime_adj(tmptm,(crldays*24+crlhours)*60*60);
+                if (!X509_time_adj_ex(tmptm, crldays, crlhours*60*60 + crlsec,
+                        NULL))
+                        {
+                        BIO_puts(bio_err, "error setting CRL nextUpdate\n");
+                        goto err;
+                        }
                 X509_CRL_set_nextUpdate(crl, tmptm);    
 
                 ASN1_TIME_free(tmptm);
 
-                for (i=0; i<sk_num(db->db->data); i++)
+                for (i=0; i<sk_OPENSSL_PSTRING_num(db->db->data); i++)
                         {
-                        pp=(const char **)sk_value(db->db->data,i);
+                        pp=sk_OPENSSL_PSTRING_value(db->db->data,i);
                         if (pp[DB_type][0] == DB_TYPE_REV)
                                 {
                                 if ((r=X509_REVOKED_new()) == NULL) goto err;
                                 j = make_revoked(r, pp[DB_rev_date]);
                                 if (!j) goto err;
                                 if (j == 2) crl_v2 = 1;
                                 if (!BN_hex2bn(&serial, pp[DB_serial]))
                                         goto err;
                                 tmpser = BN_to_ASN1_INTEGER(serial, NULL);
                                 BN_free(serial);
                                 serial = NULL;
                                 if (!tmpser)
                                         goto err;
                                 X509_REVOKED_set_serialNumber(r, tmpser);
                                 ASN1_INTEGER_free(tmpser);
                                 X509_CRL_add0_revoked(crl,r);
                                 }
                         }
 
                 /* sort the data so it will be written in serial
                  * number order */
                 X509_CRL_sort(crl);
 
                 /* we now have a CRL */
                 if (verbose) BIO_printf(bio_err,"signing CRL\n");
-#ifndef OPENSSL_NO_DSA
-                if (pkey->type == EVP_PKEY_DSA) 
-                        dgst=EVP_dss1();
-                else
-#endif
-#ifndef OPENSSL_NO_ECDSA
-                if (pkey->type == EVP_PKEY_EC)
-                        dgst=EVP_ecdsa();
-#endif
 
                 /* Add any extensions asked for */
 
                 if (crl_ext || crlnumberfile != NULL)
                         {
                         X509V3_CTX crlctx;
                         X509V3_set_ctx(&crlctx, x509, NULL, NULL, crl, 0);
                         X509V3_set_nconf(&crlctx, conf);
 
                         if (crl_ext)
@@ skipping 12 matching lines @@
                 if (crl_ext || crl_v2)
                         {
                         if (!X509_CRL_set_version(crl, 1))
                                 goto err; /* version 2 CRL */
                         }
 
                 
                 if (crlnumberfile != NULL)      /* we have a CRL number that need updating */
                         if (!save_serial(crlnumberfile,"new",crlnumber,NULL)) goto err;
 
+                if (crlnumber)
+                        {
+                        BN_free(crlnumber);
+                        crlnumber = NULL;
+                        }
+
                 if (!X509_CRL_sign(crl,pkey,dgst)) goto err;
 
                 PEM_write_bio_X509_CRL(Sout,crl);
 
                 if (crlnumberfile != NULL)      /* Rename the crlnumber file */
                         if (!rotate_serial(crlnumberfile,"new","old")) goto err;
 
                 }
         /*****************************************************************/
         if (dorevoke)
@@ skipping 32 matching lines @@
         BIO_free_all(in);
 
         if (cert_sk)
                 sk_X509_pop_free(cert_sk,X509_free);
 
         if (ret) ERR_print_errors(bio_err);
         app_RAND_write_file(randfile, bio_err);
         if (free_key && key)
                 OPENSSL_free(key);
         BN_free(serial);
+        BN_free(crlnumber);
         free_index(db);
         EVP_PKEY_free(pkey);
         if (x509) X509_free(x509);
         X509_CRL_free(crl);
         NCONF_free(conf);
         NCONF_free(extconf);
         OBJ_cleanup();
         apps_shutdown();
         OPENSSL_EXIT(ret);
         }
@@ skipping 138 matching lines @@
         ASN1_STRING *str,*str2;
         ASN1_OBJECT *obj;
         X509 *ret=NULL;
         X509_CINF *ci;
         X509_NAME_ENTRY *ne;
         X509_NAME_ENTRY *tne,*push;
         EVP_PKEY *pktmp;
         int ok= -1,i,j,last,nid;
         const char *p;
         CONF_VALUE *cv;
-        char *row[DB_NUMBER],**rrow=NULL,**irow=NULL;
+        OPENSSL_STRING row[DB_NUMBER];
+        OPENSSL_STRING *irow=NULL;
+        OPENSSL_STRING *rrow=NULL;
         char buf[25];
 
         tmptm=ASN1_UTCTIME_new();
         if (tmptm == NULL)
                 {
                 BIO_printf(bio_err,"malloc error\n");
                 return(0);
                 }
 
         for (i=0; i<DB_NUMBER; i++)
@@ skipping 221 matching lines @@
         else
                 row[DB_serial]=BN_bn2hex(serial);
         if (row[DB_serial] == NULL)
                 {
                 BIO_printf(bio_err,"Memory allocation failure\n");
                 goto err;
                 }
 
         if (db->attributes.unique_subject)
                 {
-                rrow=TXT_DB_get_by_index(db->db,DB_name,row);
+                OPENSSL_STRING *crow=row;
+
+                rrow=TXT_DB_get_by_index(db->db,DB_name,crow);
                 if (rrow != NULL)
                         {
                         BIO_printf(bio_err,
                                 "ERROR:There is already a certificate for %s\n",
                                 row[DB_name]);
                         }
                 }
         if (rrow == NULL)
                 {
                 rrow=TXT_DB_get_by_index(db->db,DB_serial,row);
@@ skipping 55 matching lines @@
                         goto err;
                 }
         else
                 {
                 if (!X509_set_issuer_name(ret,X509_get_subject_name(x509)))
                         goto err;
                 }
 
         if (strcmp(startdate,"today") == 0)
                 X509_gmtime_adj(X509_get_notBefore(ret),0);
-        else ASN1_UTCTIME_set_string(X509_get_notBefore(ret),startdate);
+        else ASN1_TIME_set_string(X509_get_notBefore(ret),startdate);
 
         if (enddate == NULL)
-                X509_gmtime_adj(X509_get_notAfter(ret),(long)60*60*24*days);
-        else ASN1_UTCTIME_set_string(X509_get_notAfter(ret),enddate);
+                X509_time_adj_ex(X509_get_notAfter(ret),days, 0, NULL);
+        else ASN1_TIME_set_string(X509_get_notAfter(ret),enddate);
 
         if (!X509_set_subject_name(ret,subject)) goto err;
 
         pktmp=X509_REQ_get_pubkey(req);
         i = X509_set_pubkey(ret,pktmp);
         EVP_PKEY_free(pktmp);
         if (!i) goto err;
 
         /* Lets add the extensions, if there are any */
         if (ext_sect)
@@ skipping 99 matching lines @@
                         goto err;
                         }
                 if (!((buf[0] == 'y') || (buf[0] == 'Y')))
                         {
                         BIO_printf(bio_err,"CERTIFICATE WILL NOT BE CERTIFIED\n");
                         ok=0;
                         goto err;
                         }
                 }
 
-
-#ifndef OPENSSL_NO_DSA
-        if (pkey->type == EVP_PKEY_DSA) dgst=EVP_dss1();
         pktmp=X509_get_pubkey(ret);
         if (EVP_PKEY_missing_parameters(pktmp) &&
                 !EVP_PKEY_missing_parameters(pkey))
                 EVP_PKEY_copy_parameters(pktmp,pkey);
         EVP_PKEY_free(pktmp);
-#endif
-#ifndef OPENSSL_NO_ECDSA
-        if (pkey->type == EVP_PKEY_EC)
-                dgst = EVP_ecdsa();
-        pktmp = X509_get_pubkey(ret);
-        if (EVP_PKEY_missing_parameters(pktmp) &&
-                !EVP_PKEY_missing_parameters(pkey))
-                EVP_PKEY_copy_parameters(pktmp, pkey);
-        EVP_PKEY_free(pktmp);
-#endif
-
 
         if (!X509_sign(ret,pkey,dgst))
                 goto err;
 
         /* We now just add it to the database */
         row[DB_type]=(char *)OPENSSL_malloc(2);
 
         tm=X509_get_notAfter(ret);
         row[DB_exp_date]=(char *)OPENSSL_malloc(tm->length+1);
         memcpy(row[DB_exp_date],tm->data,tm->length);
@@ skipping 81 matching lines @@
         PEM_write_bio_X509(bp,x);
         }
 
 static int certify_spkac(X509 **xret, char *infile, EVP_PKEY *pkey, X509 *x509,
              const EVP_MD *dgst, STACK_OF(CONF_VALUE) *policy, CA_DB *db,
              BIGNUM *serial, char *subj,unsigned long chtype, int multirdn, int email_dn, char *startdate, char *enddate,
              long days, char *ext_sect, CONF *lconf, int verbose, unsigned long certopt,
              unsigned long nameopt, int default_op, int ext_copy)
         {
         STACK_OF(CONF_VALUE) *sk=NULL;
-        LHASH *parms=NULL;
+        LHASH_OF(CONF_VALUE) *parms=NULL;
         X509_REQ *req=NULL;
         CONF_VALUE *cv=NULL;
         NETSCAPE_SPKI *spki = NULL;
         X509_REQ_INFO *ri;
         char *type,*buf;
         EVP_PKEY *pktmp=NULL;
         X509_NAME *n=NULL;
         X509_NAME_ENTRY *ne=NULL;
         int ok= -1,i,j;
         long errline;
@@ skipping 113 matching lines @@
         if (req != NULL) X509_REQ_free(req);
         if (parms != NULL) CONF_free(parms);
         if (spki != NULL) NETSCAPE_SPKI_free(spki);
         if (ne != NULL) X509_NAME_ENTRY_free(ne);
 
         return(ok);
         }
 
 static int check_time_format(const char *str)
         {
-        ASN1_TIME tm;
-
-        tm.data=(unsigned char *)str;
-        tm.length=strlen(str);
-        tm.type=V_ASN1_UTCTIME;
-        if (ASN1_TIME_check(&tm))
-                return 1;
-        tm.type=V_ASN1_GENERALIZEDTIME;
-        return ASN1_TIME_check(&tm);
+        return ASN1_TIME_set_string(NULL, str);
         }
 
 static int do_revoke(X509 *x509, CA_DB *db, int type, char *value)
         {
         ASN1_UTCTIME *tm=NULL;
         char *row[DB_NUMBER],**rrow,**irow;
         char *rev_str = NULL;
         BIGNUM *bn = NULL;
         int ok=-1,i;
 
         for (i=0; i<DB_NUMBER; i++)
                 row[i]=NULL;
         row[DB_name]=X509_NAME_oneline(X509_get_subject_name(x509),NULL,0);
         bn = ASN1_INTEGER_to_BN(X509_get_serialNumber(x509),NULL);
+        if (!bn)
+                goto err;
         if (BN_is_zero(bn))
                 row[DB_serial]=BUF_strdup("00");
         else
                 row[DB_serial]=BN_bn2hex(bn);
         BN_free(bn);
         if ((row[DB_name] == NULL) || (row[DB_serial] == NULL))
                 {
                 BIO_printf(bio_err,"Memory allocation failure\n");
                 goto err;
                 }
@@ skipping 49 matching lines @@
                         BIO_printf(bio_err,"TXT_DB error number %ld\n",db->db->error);
                         goto err;
                         }
 
                 /* Revoke Certificate */
                 ok = do_revoke(x509,db, type, value);
 
                 goto err;
 
                 }
-        else if (index_name_cmp((const char **)row,(const char **)rrow))
+        else if (index_name_cmp_noconst(row, rrow))
                 {
                 BIO_printf(bio_err,"ERROR:name does not match %s\n",
                            row[DB_name]);
                 goto err;
                 }
         else if (rrow[DB_type][0]=='R')
                 {
                 BIO_printf(bio_err,"ERROR:Already revoked, serial number %s\n",
                            row[DB_serial]);
                 goto err;
@@ skipping 128 matching lines @@
                 }
 
         memcpy(a_tm_s, a_tm->data, a_tm->length);
         a_tm_s[a_tm->length] = '\0';
 
         if (strncmp(a_tm_s, "49", 2) <= 0)
                 a_y2k = 1;
         else
                 a_y2k = 0;
 
-        for (i = 0; i < sk_num(db->db->data); i++)
+        for (i = 0; i < sk_OPENSSL_PSTRING_num(db->db->data); i++)
                 {
-                rrow = (char **) sk_value(db->db->data, i);
+                rrow = sk_OPENSSL_PSTRING_value(db->db->data, i);
 
                 if (rrow[DB_type][0] == 'V')
                         {
                         /* ignore entries that are not valid */
                         if (strncmp(rrow[DB_exp_date], "49", 2) <= 0)
                                 db_y2k = 1;
                         else
                                 db_y2k = 0;
 
                         if (db_y2k == a_y2k)
@@ skipping 226 matching lines @@
         else if (str->type == V_ASN1_IA5STRING)
                 BIO_printf(bp,"IA5STRING:'");
         else if (str->type == V_ASN1_UNIVERSALSTRING)
                 BIO_printf(bp,"UNIVERSALSTRING:'");
         else
                 BIO_printf(bp,"ASN.1 %2d:'",str->type);
                         
         p=(char *)str->data;
         for (j=str->length; j>0; j--)
                 {
-#ifdef CHARSET_EBCDIC
-                if ((*p >= 0x20) && (*p <= 0x7e))
-                        BIO_printf(bp,"%c",os_toebcdic[*p]);
-#else
                 if ((*p >= ' ') && (*p <= '~'))
                         BIO_printf(bp,"%c",*p);
-#endif
                 else if (*p & 0x80)
                         BIO_printf(bp,"\\0x%02X",*p);
                 else if ((unsigned char)*p == 0xf7)
                         BIO_printf(bp,"^?");
-#ifdef CHARSET_EBCDIC
-                else    BIO_printf(bp,"^%c",os_toebcdic[*p+0x40]);
-#else
                 else    BIO_printf(bp,"^%c",*p+'@');
-#endif
                 p++;
                 }
         BIO_printf(bp,"'\n");
         return 1;
         }
 
 int unpack_revinfo(ASN1_TIME **prevtm, int *preason, ASN1_OBJECT **phold, ASN1_GENERALIZEDTIME **pinvtm, const char *str)
         {
         char *tmp = NULL;
         char *rtime_str, *reason_str = NULL, *arg_str = NULL, *p;
@@ skipping 92 matching lines @@
         ret = 1;
 
         err:
 
         if (tmp) OPENSSL_free(tmp);
         if (!phold) ASN1_OBJECT_free(hold);
         if (!pinvtm) ASN1_GENERALIZEDTIME_free(comp_time);
 
         return ret;
         }