Update from 1.0.0-stable
authorDr. Stephen Henson <steve@openssl.org>
Mon, 27 Jul 2009 21:10:00 +0000 (21:10 +0000)
committerDr. Stephen Henson <steve@openssl.org>
Mon, 27 Jul 2009 21:10:00 +0000 (21:10 +0000)
22 files changed:
apps/apps.c
apps/apps.h
apps/asn1pars.c
apps/ca.c
apps/cms.c
apps/crl2p7.c
apps/dgst.c
apps/engine.c
apps/ocsp.c
apps/pkcs12.c
apps/req.c
apps/s_server.c
apps/smime.c
apps/x509.c
crypto/cryptlib.c
crypto/engine/eng_dyn.c
crypto/lhash/lhash.h
crypto/stack/safestack.h
crypto/txt_db/txt_db.c
crypto/txt_db/txt_db.h
crypto/x509v3/v3_utl.c
crypto/x509v3/x509v3.h

index 88a479d..09d9df2 100644 (file)
@@ -1488,7 +1488,7 @@ char *make_config_name()
        return p;
        }
 
-static unsigned long index_serial_hash(const CSTRING *a)
+static unsigned long index_serial_hash(const OPENSSL_CSTRING *a)
        {
        const char *n;
 
@@ -1497,7 +1497,7 @@ static unsigned long index_serial_hash(const CSTRING *a)
        return(lh_strhash(n));
        }
 
-static int index_serial_cmp(const CSTRING *a, const CSTRING *b)
+static int index_serial_cmp(const OPENSSL_CSTRING *a, const OPENSSL_CSTRING *b)
        {
        const char *aa,*bb;
 
@@ -1509,16 +1509,16 @@ static int index_serial_cmp(const CSTRING *a, const CSTRING *b)
 static int index_name_qual(char **a)
        { return(a[0][0] == 'V'); }
 
-static unsigned long index_name_hash(const CSTRING *a)
+static unsigned long index_name_hash(const OPENSSL_CSTRING *a)
        { return(lh_strhash(a[DB_name])); }
 
-int index_name_cmp(const CSTRING *a, const CSTRING *b)
+int index_name_cmp(const OPENSSL_CSTRING *a, const OPENSSL_CSTRING *b)
        { return(strcmp(a[DB_name], b[DB_name])); }
 
-static IMPLEMENT_LHASH_HASH_FN(index_serial, CSTRING)
-static IMPLEMENT_LHASH_COMP_FN(index_serial, CSTRING)
-static IMPLEMENT_LHASH_HASH_FN(index_name, CSTRING)
-static IMPLEMENT_LHASH_COMP_FN(index_name, CSTRING)
+static IMPLEMENT_LHASH_HASH_FN(index_serial, OPENSSL_CSTRING)
+static IMPLEMENT_LHASH_COMP_FN(index_serial, OPENSSL_CSTRING)
+static IMPLEMENT_LHASH_HASH_FN(index_name, OPENSSL_CSTRING)
+static IMPLEMENT_LHASH_COMP_FN(index_name, OPENSSL_CSTRING)
 
 #undef BSIZE
 #define BSIZE 256
index 4b0a0e1..cdfb5ef 100644 (file)
@@ -295,9 +295,9 @@ int save_index(const char *dbfile, const char *suffix, CA_DB *db);
 int rotate_index(const char *dbfile, const char *new_suffix, const char *old_suffix);
 void free_index(CA_DB *db);
 #define index_name_cmp_noconst(a, b) \
-       index_name_cmp((const CSTRING *)CHECKED_PTR_OF(STRING, a), \
-       (const CSTRING *)CHECKED_PTR_OF(STRING, b))
-int index_name_cmp(const CSTRING *a, const CSTRING *b);
+       index_name_cmp((const OPENSSL_CSTRING *)CHECKED_PTR_OF(OPENSSL_STRING, a), \
+       (const OPENSSL_CSTRING *)CHECKED_PTR_OF(OPENSSL_STRING, b))
+int index_name_cmp(const OPENSSL_CSTRING *a, const OPENSSL_CSTRING *b);
 int parse_yesno(const char *str, int def);
 
 X509_NAME *parse_name(char *str, long chtype, int multirdn);
index caf6787..b5d65e7 100644 (file)
@@ -96,7 +96,7 @@ int MAIN(int argc, char **argv)
        unsigned char *tmpbuf;
        const unsigned char *ctmpbuf;
        BUF_MEM *buf=NULL;
-       STACK_OF(STRING) *osk=NULL;
+       STACK_OF(OPENSSL_STRING) *osk=NULL;
        ASN1_TYPE *at=NULL;
 
        informat=FORMAT_PEM;
@@ -113,7 +113,7 @@ int MAIN(int argc, char **argv)
        prog=argv[0];
        argc--;
        argv++;
-       if ((osk=sk_STRING_new_null()) == NULL)
+       if ((osk=sk_OPENSSL_STRING_new_null()) == NULL)
                {
                BIO_printf(bio_err,"Memory allocation failure\n");
                goto end;
@@ -169,7 +169,7 @@ int MAIN(int argc, char **argv)
                else if (strcmp(*argv,"-strparse") == 0)
                        {
                        if (--argc < 1) goto bad;
-                       sk_STRING_push(osk,*(++argv));
+                       sk_OPENSSL_STRING_push(osk,*(++argv));
                        }
                else if (strcmp(*argv,"-genstr") == 0)
                        {
@@ -302,18 +302,18 @@ bad:
 
        /* If any structs to parse go through in sequence */
 
-       if (sk_STRING_num(osk))
+       if (sk_OPENSSL_STRING_num(osk))
                {
                tmpbuf=(unsigned char *)str;
                tmplen=num;
-               for (i=0; i<sk_STRING_num(osk); i++)
+               for (i=0; i<sk_OPENSSL_STRING_num(osk); i++)
                        {
                        ASN1_TYPE *atmp;
                        int typ;
-                       j=atoi(sk_STRING_value(osk,i));
+                       j=atoi(sk_OPENSSL_STRING_value(osk,i));
                        if (j == 0)
                                {
-                               BIO_printf(bio_err,"'%s' is an invalid number\n",sk_STRING_value(osk,i));
+                               BIO_printf(bio_err,"'%s' is an invalid number\n",sk_OPENSSL_STRING_value(osk,i));
                                continue;
                                }
                        tmpbuf+=j;
@@ -378,7 +378,7 @@ end:
                ERR_print_errors(bio_err);
        if (buf != NULL) BUF_MEM_free(buf);
        if (at != NULL) ASN1_TYPE_free(at);
-       if (osk != NULL) sk_STRING_free(osk);
+       if (osk != NULL) sk_OPENSSL_STRING_free(osk);
        OBJ_cleanup();
        apps_shutdown();
        OPENSSL_EXIT(ret);
index 4f236cc..aabf86b 100644 (file)
--- a/apps/ca.c
+++ b/apps/ca.c
@@ -883,9 +883,9 @@ bad:
        if (db == NULL) goto err;
 
        /* Lets check some fields */
-       for (i=0; i<sk_PSTRING_num(db->db->data); i++)
+       for (i=0; i<sk_OPENSSL_PSTRING_num(db->db->data); i++)
                {
-               pp=sk_PSTRING_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'))
                        {
@@ -938,7 +938,7 @@ bad:
 #endif
                TXT_DB_write(out,db->db);
                BIO_printf(bio_err,"%d entries loaded from the database\n",
-                          sk_PSTRING_num(db->db->data));
+                          sk_OPENSSL_PSTRING_num(db->db->data));
                BIO_printf(bio_err,"generating index\n");
                }
        
@@ -1408,9 +1408,9 @@ bad:
 
                ASN1_TIME_free(tmptm);
 
-               for (i=0; i<sk_PSTRING_num(db->db->data); i++)
+               for (i=0; i<sk_OPENSSL_PSTRING_num(db->db->data); i++)
                        {
-                       pp=sk_PSTRING_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;
@@ -1685,9 +1685,9 @@ static int do_body(X509 **xret, EVP_PKEY *pkey, X509 *x509, const EVP_MD *dgst,
        int ok= -1,i,j,last,nid;
        const char *p;
        CONF_VALUE *cv;
-       STRING row[DB_NUMBER];
-       STRING *irow=NULL;
-       STRING *rrow=NULL;
+       OPENSSL_STRING row[DB_NUMBER];
+       OPENSSL_STRING *irow=NULL;
+       OPENSSL_STRING *rrow=NULL;
        char buf[25];
 
        tmptm=ASN1_UTCTIME_new();
@@ -1929,7 +1929,7 @@ again2:
 
        if (db->attributes.unique_subject)
                {
-               STRING *crow=row;
+               OPENSSL_STRING *crow=row;
 
                rrow=TXT_DB_get_by_index(db->db,DB_name,crow);
                if (rrow != NULL)
@@ -2632,9 +2632,9 @@ static int do_updatedb (CA_DB *db)
        else
                a_y2k = 0;
 
-       for (i = 0; i < sk_PSTRING_num(db->db->data); i++)
+       for (i = 0; i < sk_OPENSSL_PSTRING_num(db->db->data); i++)
                {
-               rrow = sk_PSTRING_value(db->db->data, i);
+               rrow = sk_OPENSSL_PSTRING_value(db->db->data, i);
 
                if (rrow[DB_type][0] == 'V')
                        {
index f16e646..3adcd78 100644 (file)
@@ -71,9 +71,9 @@
 static int save_certs(char *signerfile, STACK_OF(X509) *signers);
 static int cms_cb(int ok, X509_STORE_CTX *ctx);
 static void receipt_request_print(BIO *out, CMS_ContentInfo *cms);
-static CMS_ReceiptRequest *make_receipt_request(STACK_OF(STRING) *rr_to,
+static CMS_ReceiptRequest *make_receipt_request(STACK_OF(OPENSSL_STRING) *rr_to,
                                                int rr_allorfirst,
-                                               STACK_OF(STRING) *rr_from);
+                                       STACK_OF(OPENSSL_STRING) *rr_from);
 
 #define SMIME_OP       0x10
 #define SMIME_IP       0x20
@@ -108,7 +108,7 @@ int MAIN(int argc, char **argv)
        const char *inmode = "r", *outmode = "w";
        char *infile = NULL, *outfile = NULL, *rctfile = NULL;
        char *signerfile = NULL, *recipfile = NULL;
-       STACK_OF(STRING) *sksigners = NULL, *skkeys = NULL;
+       STACK_OF(OPENSSL_STRING) *sksigners = NULL, *skkeys = NULL;
        char *certfile = NULL, *keyfile = NULL, *contfile=NULL;
        char *certsoutfile = NULL;
        const EVP_CIPHER *cipher = NULL;
@@ -122,7 +122,7 @@ int MAIN(int argc, char **argv)
        int flags = CMS_DETACHED, noout = 0, print = 0;
        int verify_retcode = 0;
        int rr_print = 0, rr_allorfirst = -1;
-       STACK_OF(STRING) *rr_to = NULL, *rr_from = NULL;
+       STACK_OF(OPENSSL_STRING) *rr_to = NULL, *rr_from = NULL;
        CMS_ReceiptRequest *rr = NULL;
        char *to = NULL, *from = NULL, *subject = NULL;
        char *CAfile = NULL, *CApath = NULL;
@@ -281,8 +281,8 @@ int MAIN(int argc, char **argv)
                                goto argerr;
                        args++;
                        if (!rr_from)
-                               rr_from = sk_STRING_new_null();
-                       sk_STRING_push(rr_from, *args);
+                               rr_from = sk_OPENSSL_STRING_new_null();
+                       sk_OPENSSL_STRING_push(rr_from, *args);
                        }
                else if (!strcmp(*args,"-receipt_request_to"))
                        {
@@ -290,8 +290,8 @@ int MAIN(int argc, char **argv)
                                goto argerr;
                        args++;
                        if (!rr_to)
-                               rr_to = sk_STRING_new_null();
-                       sk_STRING_push(rr_to, *args);
+                               rr_to = sk_OPENSSL_STRING_new_null();
+                       sk_OPENSSL_STRING_push(rr_to, *args);
                        }
                else if (!strcmp (*args, "-print"))
                                {
@@ -387,13 +387,13 @@ int MAIN(int argc, char **argv)
                        if (signerfile)
                                {
                                if (!sksigners)
-                                       sksigners = sk_STRING_new_null();
-                               sk_STRING_push(sksigners, signerfile);
+                                       sksigners = sk_OPENSSL_STRING_new_null();
+                               sk_OPENSSL_STRING_push(sksigners, signerfile);
                                if (!keyfile)
                                        keyfile = signerfile;
                                if (!skkeys)
-                                       skkeys = sk_STRING_new_null();
-                               sk_STRING_push(skkeys, keyfile);
+                                       skkeys = sk_OPENSSL_STRING_new_null();
+                               sk_OPENSSL_STRING_push(skkeys, keyfile);
                                keyfile = NULL;
                                }
                        signerfile = *++args;
@@ -435,12 +435,12 @@ int MAIN(int argc, char **argv)
                                        goto argerr;
                                        }
                                if (!sksigners)
-                                       sksigners = sk_STRING_new_null();
-                               sk_STRING_push(sksigners, signerfile);
+                                       sksigners = sk_OPENSSL_STRING_new_null();
+                               sk_OPENSSL_STRING_push(sksigners, signerfile);
                                signerfile = NULL;
                                if (!skkeys)
-                                       skkeys = sk_STRING_new_null();
-                               sk_STRING_push(skkeys, keyfile);
+                                       skkeys = sk_OPENSSL_STRING_new_null();
+                               sk_OPENSSL_STRING_push(skkeys, keyfile);
                                }
                        keyfile = *++args;
                        }
@@ -539,13 +539,13 @@ int MAIN(int argc, char **argv)
                if (signerfile)
                        {
                        if (!sksigners)
-                               sksigners = sk_STRING_new_null();
-                       sk_STRING_push(sksigners, signerfile);
+                               sksigners = sk_OPENSSL_STRING_new_null();
+                       sk_OPENSSL_STRING_push(sksigners, signerfile);
                        if (!skkeys)
-                               skkeys = sk_STRING_new_null();
+                               skkeys = sk_OPENSSL_STRING_new_null();
                        if (!keyfile)
                                keyfile = signerfile;
-                       sk_STRING_push(skkeys, keyfile);
+                       sk_OPENSSL_STRING_push(skkeys, keyfile);
                        }
                if (!sksigners)
                        {
@@ -980,11 +980,11 @@ int MAIN(int argc, char **argv)
                        }
                else
                        flags |= CMS_REUSE_DIGEST;
-               for (i = 0; i < sk_STRING_num(sksigners); i++)
+               for (i = 0; i < sk_OPENSSL_STRING_num(sksigners); i++)
                        {
                        CMS_SignerInfo *si;
-                       signerfile = sk_STRING_value(sksigners, i);
-                       keyfile = sk_STRING_value(skkeys, i);
+                       signerfile = sk_OPENSSL_STRING_value(sksigners, i);
+                       keyfile = sk_OPENSSL_STRING_value(skkeys, i);
                        signer = load_cert(bio_err, signerfile,FORMAT_PEM, NULL,
                                        e, "signer certificate");
                        if (!signer)
@@ -1160,9 +1160,9 @@ end:
        if (vpm)
                X509_VERIFY_PARAM_free(vpm);
        if (sksigners)
-               sk_STRING_free(sksigners);
+               sk_OPENSSL_STRING_free(sksigners);
        if (skkeys)
-               sk_STRING_free(skkeys);
+               sk_OPENSSL_STRING_free(skkeys);
        if (secret_key)
                OPENSSL_free(secret_key);
        if (secret_keyid)
@@ -1172,9 +1172,9 @@ end:
        if (rr)
                CMS_ReceiptRequest_free(rr);
        if (rr_to)
-               sk_STRING_free(rr_to);
+               sk_OPENSSL_STRING_free(rr_to);
        if (rr_from)
-               sk_STRING_free(rr_from);
+               sk_OPENSSL_STRING_free(rr_from);
        X509_STORE_free(store);
        X509_free(cert);
        X509_free(recip);
@@ -1296,7 +1296,7 @@ static void receipt_request_print(BIO *out, CMS_ContentInfo *cms)
                }
        }
 
-static STACK_OF(GENERAL_NAMES) *make_names_stack(STACK_OF(STRING) *ns)
+static STACK_OF(GENERAL_NAMES) *make_names_stack(STACK_OF(OPENSSL_STRING) *ns)
        {
        int i;
        STACK_OF(GENERAL_NAMES) *ret;
@@ -1305,9 +1305,9 @@ static STACK_OF(GENERAL_NAMES) *make_names_stack(STACK_OF(STRING) *ns)
        ret = sk_GENERAL_NAMES_new_null();
        if (!ret)
                goto err;
-       for (i = 0; i < sk_STRING_num(ns); i++)
+       for (i = 0; i < sk_OPENSSL_STRING_num(ns); i++)
                {
-               char *str = sk_STRING_value(ns, i);
+               char *str = sk_OPENSSL_STRING_value(ns, i);
                gen = a2i_GENERAL_NAME(NULL, NULL, NULL, GEN_EMAIL, str, 0);
                if (!gen)
                        goto err;
@@ -1335,9 +1335,9 @@ static STACK_OF(GENERAL_NAMES) *make_names_stack(STACK_OF(STRING) *ns)
        }
 
 
-static CMS_ReceiptRequest *make_receipt_request(STACK_OF(STRING) *rr_to,
+static CMS_ReceiptRequest *make_receipt_request(STACK_OF(OPENSSL_STRING) *rr_to,
                                                int rr_allorfirst,
-                                               STACK_OF(STRING) *rr_from)
+                                               STACK_OF(OPENSSL_STRING) *rr_from)
        {
        STACK_OF(GENERAL_NAMES) *rct_to, *rct_from;
        CMS_ReceiptRequest *rr;
index 194971d..bbc8377 100644 (file)
@@ -92,7 +92,7 @@ int MAIN(int argc, char **argv)
        PKCS7 *p7 = NULL;
        PKCS7_SIGNED *p7s = NULL;
        X509_CRL *crl=NULL;
-       STACK_OF(STRING) *certflst=NULL;
+       STACK_OF(OPENSSL_STRING) *certflst=NULL;
        STACK_OF(X509_CRL) *crl_stack=NULL;
        STACK_OF(X509) *cert_stack=NULL;
        int ret=1,nocrl=0;
@@ -140,8 +140,8 @@ int MAIN(int argc, char **argv)
                else if (strcmp(*argv,"-certfile") == 0)
                        {
                        if (--argc < 1) goto bad;
-                       if(!certflst) certflst = sk_STRING_new_null();
-                       sk_STRING_push(certflst,*(++argv));
+                       if(!certflst) certflst = sk_OPENSSL_STRING_new_null();
+                       sk_OPENSSL_STRING_push(certflst,*(++argv));
                        }
                else
                        {
@@ -226,8 +226,8 @@ bad:
        if ((cert_stack=sk_X509_new_null()) == NULL) goto end;
        p7s->cert=cert_stack;
 
-       if(certflst) for(i = 0; i < sk_STRING_num(certflst); i++) {
-               certfile = sk_STRING_value(certflst, i);
+       if(certflst) for(i = 0; i < sk_OPENSSL_STRING_num(certflst); i++) {
+               certfile = sk_OPENSSL_STRING_value(certflst, i);
                if (add_certs_from_file(cert_stack,certfile) < 0)
                        {
                        BIO_printf(bio_err, "error loading certificates\n");
@@ -236,7 +236,7 @@ bad:
                        }
        }
 
-       sk_STRING_free(certflst);
+       sk_OPENSSL_STRING_free(certflst);
 
        if (outfile == NULL)
                {
index b148727..4c6644e 100644 (file)
@@ -127,7 +127,7 @@ int MAIN(int argc, char **argv)
 #endif
        char *hmac_key=NULL;
        char *mac_name=NULL;
-       STACK_OF(STRING) *sigopts = NULL, *macopts = NULL;
+       STACK_OF(OPENSSL_STRING) *sigopts = NULL, *macopts = NULL;
 
        apps_startup();
 
@@ -230,8 +230,8 @@ int MAIN(int argc, char **argv)
                        if (--argc < 1)
                                break;
                        if (!sigopts)
-                               sigopts = sk_STRING_new_null();
-                       if (!sigopts || !sk_STRING_push(sigopts, *(++argv)))
+                               sigopts = sk_OPENSSL_STRING_new_null();
+                       if (!sigopts || !sk_OPENSSL_STRING_push(sigopts, *(++argv)))
                                break;
                        }
                else if (strcmp(*argv,"-macopt") == 0)
@@ -239,8 +239,8 @@ int MAIN(int argc, char **argv)
                        if (--argc < 1)
                                break;
                        if (!macopts)
-                               macopts = sk_STRING_new_null();
-                       if (!macopts || !sk_STRING_push(macopts, *(++argv)))
+                               macopts = sk_OPENSSL_STRING_new_null();
+                       if (!macopts || !sk_OPENSSL_STRING_push(macopts, *(++argv)))
                                break;
                        }
                else if ((m=EVP_get_digestbyname(&((*argv)[1]))) != NULL)
@@ -365,9 +365,9 @@ int MAIN(int argc, char **argv)
                if (macopts)
                        {
                        char *macopt;
-                       for (i = 0; i < sk_STRING_num(macopts); i++)
+                       for (i = 0; i < sk_OPENSSL_STRING_num(macopts); i++)
                                {
-                               macopt = sk_STRING_value(macopts, i);
+                               macopt = sk_OPENSSL_STRING_value(macopts, i);
                                if (pkey_ctrl_string(mac_ctx, macopt) <= 0)
                                        {
                                        BIO_printf(bio_err,
@@ -424,9 +424,9 @@ int MAIN(int argc, char **argv)
                if (sigopts)
                        {
                        char *sigopt;
-                       for (i = 0; i < sk_STRING_num(sigopts); i++)
+                       for (i = 0; i < sk_OPENSSL_STRING_num(sigopts); i++)
                                {
-                               sigopt = sk_STRING_value(sigopts, i);
+                               sigopt = sk_OPENSSL_STRING_value(sigopts, i);
                                if (pkey_ctrl_string(pctx, sigopt) <= 0)
                                        {
                                        BIO_printf(bio_err,
@@ -531,9 +531,9 @@ end:
        BIO_free_all(out);
        EVP_PKEY_free(sigkey);
        if (sigopts)
-               sk_STRING_free(sigopts);
+               sk_OPENSSL_STRING_free(sigopts);
        if (macopts)
-               sk_STRING_free(macopts);
+               sk_OPENSSL_STRING_free(macopts);
        if(sigbuf) OPENSSL_free(sigbuf);
        if (bmd != NULL) BIO_free(bmd);
        apps_shutdown();
index 78e9f2b..9a02943 100644 (file)
@@ -200,7 +200,7 @@ static int util_verbose(ENGINE *e, int verbose, BIO *bio_out, const char *indent
        char *desc = NULL;
        int flags;
        int xpos = 0;
-       STACK_OF(STRING) *cmds = NULL;
+       STACK_OF(OPENSSL_STRING) *cmds = NULL;
        if(!ENGINE_ctrl(e, ENGINE_CTRL_HAS_CTRL_FUNCTION, 0, NULL, NULL) ||
                        ((num = ENGINE_ctrl(e, ENGINE_CTRL_GET_FIRST_CMD_TYPE,
                                        0, NULL, NULL)) <= 0))
@@ -211,7 +211,7 @@ static int util_verbose(ENGINE *e, int verbose, BIO *bio_out, const char *indent
                return 1;
                }
 
-       cmds = sk_STRING_new_null();
+       cmds = sk_OPENSSL_STRING_new_null();
 
        if(!cmds)
                goto err;
@@ -284,16 +284,16 @@ static int util_verbose(ENGINE *e, int verbose, BIO *bio_out, const char *indent
                BIO_printf(bio_out, "\n");
        ret = 1;
 err:
-       if(cmds) sk_STRING_pop_free(cmds, identity);
+       if(cmds) sk_OPENSSL_STRING_pop_free(cmds, identity);
        if(name) OPENSSL_free(name);
        if(desc) OPENSSL_free(desc);
        return ret;
        }
 
-static void util_do_cmds(ENGINE *e, STACK_OF(STRING) *cmds, BIO *bio_out,
-                        const char *indent)
+static void util_do_cmds(ENGINE *e, STACK_OF(OPENSSL_STRING) *cmds,
+                       BIO *bio_out, const char *indent)
        {
-       int loop, res, num = sk_STRING_num(cmds);
+       int loop, res, num = sk_OPENSSL_STRING_num(cmds);
 
        if(num < 0)
                {
@@ -304,7 +304,7 @@ static void util_do_cmds(ENGINE *e, STACK_OF(STRING) *cmds, BIO *bio_out,
                {
                char buf[256];
                const char *cmd, *arg;
-               cmd = sk_STRING_value(cmds, loop);
+               cmd = sk_OPENSSL_STRING_value(cmds, loop);
                res = 1; /* assume success */
                /* Check if this command has no ":arg" */
                if((arg = strstr(cmd, ":")) == NULL)
@@ -344,9 +344,9 @@ int MAIN(int argc, char **argv)
        const char **pp;
        int verbose=0, list_cap=0, test_avail=0, test_avail_noise = 0;
        ENGINE *e;
-       STACK_OF(STRING) *engines = sk_STRING_new_null();
-       STACK_OF(STRING) *pre_cmds = sk_STRING_new_null();
-       STACK_OF(STRING) *post_cmds = sk_STRING_new_null();
+       STACK_OF(OPENSSL_STRING) *engines = sk_OPENSSL_STRING_new_null();
+       STACK_OF(OPENSSL_STRING) *pre_cmds = sk_OPENSSL_STRING_new_null();
+       STACK_OF(OPENSSL_STRING) *post_cmds = sk_OPENSSL_STRING_new_null();
        int badops=1;
        BIO *bio_out=NULL;
        const char *indent = "     ";
@@ -393,20 +393,20 @@ int MAIN(int argc, char **argv)
                        argc--; argv++;
                        if (argc == 0)
                                goto skip_arg_loop;
-                       sk_STRING_push(pre_cmds,*argv);
+                       sk_OPENSSL_STRING_push(pre_cmds,*argv);
                        }
                else if (strcmp(*argv,"-post") == 0)
                        {
                        argc--; argv++;
                        if (argc == 0)
                                goto skip_arg_loop;
-                       sk_STRING_push(post_cmds,*argv);
+                       sk_OPENSSL_STRING_push(post_cmds,*argv);
                        }
                else if ((strncmp(*argv,"-h",2) == 0) ||
                                (strcmp(*argv,"-?") == 0))
                        goto skip_arg_loop;
                else
-                       sk_STRING_push(engines,*argv);
+                       sk_OPENSSL_STRING_push(engines,*argv);
                argc--;
                argv++;
                }
@@ -421,17 +421,17 @@ skip_arg_loop:
                goto end;
                }
 
-       if (sk_STRING_num(engines) == 0)
+       if (sk_OPENSSL_STRING_num(engines) == 0)
                {
                for(e = ENGINE_get_first(); e != NULL; e = ENGINE_get_next(e))
                        {
-                       sk_STRING_push(engines,(char *)ENGINE_get_id(e));
+                       sk_OPENSSL_STRING_push(engines,(char *)ENGINE_get_id(e));
                        }
                }
 
-       for (i=0; i<sk_STRING_num(engines); i++)
+       for (i=0; i<sk_OPENSSL_STRING_num(engines); i++)
                {
-               const char *id = sk_STRING_value(engines,i);
+               const char *id = sk_OPENSSL_STRING_value(engines,i);
                if ((e = ENGINE_by_id(id)) != NULL)
                        {
                        const char *name = ENGINE_get_name(e);
@@ -533,9 +533,9 @@ skip_pmeths:
 end:
 
        ERR_print_errors(bio_err);
-       sk_STRING_pop_free(engines, identity);
-       sk_STRING_pop_free(pre_cmds, identity);
-       sk_STRING_pop_free(post_cmds, identity);
+       sk_OPENSSL_STRING_pop_free(engines, identity);
+       sk_OPENSSL_STRING_pop_free(pre_cmds, identity);
+       sk_OPENSSL_STRING_pop_free(post_cmds, identity);
        if (bio_out != NULL) BIO_free_all(bio_out);
        apps_shutdown();
        OPENSSL_EXIT(ret);
index a8e00fd..03944c0 100644 (file)
@@ -99,7 +99,7 @@ static int add_ocsp_cert(OCSP_REQUEST **req, X509 *cert, const EVP_MD *cert_id_m
 static int add_ocsp_serial(OCSP_REQUEST **req, char *serial, const EVP_MD * cert_id_md, X509 *issuer,
                                STACK_OF(OCSP_CERTID) *ids);
 static int print_ocsp_summary(BIO *out, OCSP_BASICRESP *bs, OCSP_REQUEST *req,
-                             STACK_OF(STRING) *names,
+                             STACK_OF(OPENSSL_STRING) *names,
                              STACK_OF(OCSP_CERTID) *ids, long nsec,
                              long maxage);
 
@@ -153,7 +153,7 @@ int MAIN(int argc, char **argv)
        int badarg = 0;
        int i;
        int ignore_err = 0;
-       STACK_OF(STRING) *reqnames = NULL;
+       STACK_OF(OPENSSL_STRING) *reqnames = NULL;
        STACK_OF(OCSP_CERTID) *ids = NULL;
 
        X509 *rca_cert = NULL;
@@ -170,7 +170,7 @@ int MAIN(int argc, char **argv)
        SSL_load_error_strings();
        OpenSSL_add_ssl_algorithms();
        args = argv + 1;
-       reqnames = sk_STRING_new_null();
+       reqnames = sk_OPENSSL_STRING_new_null();
        ids = sk_OCSP_CERTID_new_null();
        while (!badarg && *args && *args[0] == '-')
                {
@@ -432,7 +432,7 @@ int MAIN(int argc, char **argv)
                                if (!cert_id_md) cert_id_md = EVP_sha1();
                                if(!add_ocsp_cert(&req, cert, cert_id_md, issuer, ids))
                                        goto end;
-                               if(!sk_STRING_push(reqnames, *args))
+                               if(!sk_OPENSSL_STRING_push(reqnames, *args))
                                        goto end;
                                }
                        else badarg = 1;
@@ -445,7 +445,7 @@ int MAIN(int argc, char **argv)
                                if (!cert_id_md) cert_id_md = EVP_sha1();
                                if(!add_ocsp_serial(&req, *args, cert_id_md, issuer, ids))
                                        goto end;
-                               if(!sk_STRING_push(reqnames, *args))
+                               if(!sk_OPENSSL_STRING_push(reqnames, *args))
                                        goto end;
                                }
                        else badarg = 1;
@@ -901,7 +901,7 @@ end:
        OCSP_REQUEST_free(req);
        OCSP_RESPONSE_free(resp);
        OCSP_BASICRESP_free(bs);
-       sk_STRING_free(reqnames);
+       sk_OPENSSL_STRING_free(reqnames);
        sk_OCSP_CERTID_free(ids);
        sk_X509_pop_free(sign_other, X509_free);
        sk_X509_pop_free(verify_other, X509_free);
@@ -971,7 +971,7 @@ static int add_ocsp_serial(OCSP_REQUEST **req, char *serial,const EVP_MD *cert_i
        }
 
 static int print_ocsp_summary(BIO *out, OCSP_BASICRESP *bs, OCSP_REQUEST *req,
-                             STACK_OF(STRING) *names,
+                             STACK_OF(OPENSSL_STRING) *names,
                              STACK_OF(OCSP_CERTID) *ids, long nsec,
                              long maxage)
        {
@@ -983,13 +983,13 @@ static int print_ocsp_summary(BIO *out, OCSP_BASICRESP *bs, OCSP_REQUEST *req,
 
        ASN1_GENERALIZEDTIME *rev, *thisupd, *nextupd;
 
-       if (!bs || !req || !sk_STRING_num(names) || !sk_OCSP_CERTID_num(ids))
+       if (!bs || !req || !sk_OPENSSL_STRING_num(names) || !sk_OCSP_CERTID_num(ids))
                return 1;
 
        for (i = 0; i < sk_OCSP_CERTID_num(ids); i++)
                {
                id = sk_OCSP_CERTID_value(ids, i);
-               name = sk_STRING_value(names, i);
+               name = sk_OPENSSL_STRING_value(names, i);
                BIO_printf(out, "%s: ", name);
 
                if(!OCSP_resp_find_status(bs, id, &status, &reason,
index 39686b6..514a02e 100644 (file)
@@ -117,7 +117,7 @@ int MAIN(int argc, char **argv)
     int ret = 1;
     int macver = 1;
     int noprompt = 0;
-    STACK_OF(STRING) *canames = NULL;
+    STACK_OF(OPENSSL_STRING) *canames = NULL;
     char *cpass = NULL, *mpass = NULL;
     char *passargin = NULL, *passargout = NULL, *passarg = NULL;
     char *passin = NULL, *passout = NULL;
@@ -222,8 +222,8 @@ int MAIN(int argc, char **argv)
                } else if (!strcmp (*args, "-caname")) {
                    if (args[1]) {
                        args++; 
-                       if (!canames) canames = sk_STRING_new_null();
-                       sk_STRING_push(canames, *args);
+                       if (!canames) canames = sk_OPENSSL_STRING_new_null();
+                       sk_OPENSSL_STRING_push(canames, *args);
                    } else badarg = 1;
                } else if (!strcmp (*args, "-in")) {
                    if (args[1]) {
@@ -549,9 +549,9 @@ int MAIN(int argc, char **argv)
 
        /* Add any CA names */
 
-       for (i = 0; i < sk_STRING_num(canames); i++)
+       for (i = 0; i < sk_OPENSSL_STRING_num(canames); i++)
                {
-               catmp = (unsigned char *)sk_STRING_value(canames, i);
+               catmp = (unsigned char *)sk_OPENSSL_STRING_value(canames, i);
                X509_alias_set1(sk_X509_value(certs, i), catmp, -1);
                }
 
@@ -687,7 +687,7 @@ int MAIN(int argc, char **argv)
 #endif
     BIO_free(in);
     BIO_free_all(out);
-    if (canames) sk_STRING_free(canames);
+    if (canames) sk_OPENSSL_STRING_free(canames);
     if(passin) OPENSSL_free(passin);
     if(passout) OPENSSL_free(passout);
     apps_shutdown();
index e9b764b..b97a9f1 100644 (file)
@@ -165,7 +165,7 @@ int MAIN(int argc, char **argv)
        EVP_PKEY_CTX *genctx = NULL;
        const char *keyalg = NULL;
        char *keyalgstr = NULL;
-       STACK_OF(STRING) *pkeyopts = NULL;
+       STACK_OF(OPENSSL_STRING) *pkeyopts = NULL;
        EVP_PKEY *pkey=NULL;
        int i=0,badops=0,newreq=0,verbose=0,pkey_type=-1;
        long newkey = -1;
@@ -306,8 +306,8 @@ int MAIN(int argc, char **argv)
                        if (--argc < 1)
                                goto bad;
                        if (!pkeyopts)
-                               pkeyopts = sk_STRING_new_null();
-                       if (!pkeyopts || !sk_STRING_push(pkeyopts, *(++argv)))
+                               pkeyopts = sk_OPENSSL_STRING_new_null();
+                       if (!pkeyopts || !sk_OPENSSL_STRING_push(pkeyopts, *(++argv)))
                                goto bad;
                        }
                else if (strcmp(*argv,"-batch") == 0)
@@ -667,9 +667,9 @@ bad:
                if (pkeyopts)
                        {
                        char *genopt;
-                       for (i = 0; i < sk_STRING_num(pkeyopts); i++)
+                       for (i = 0; i < sk_OPENSSL_STRING_num(pkeyopts); i++)
                                {
-                               genopt = sk_STRING_value(pkeyopts, i);
+                               genopt = sk_OPENSSL_STRING_value(pkeyopts, i);
                                if (pkey_ctrl_string(genctx, genopt) <= 0)
                                        {
                                        BIO_printf(bio_err,
@@ -1083,7 +1083,7 @@ end:
        if (genctx)
                EVP_PKEY_CTX_free(genctx);
        if (pkeyopts)
-               sk_STRING_free(pkeyopts);
+               sk_OPENSSL_STRING_free(pkeyopts);
 #ifndef OPENSSL_NO_ENGINE
        if (gen_eng)
                ENGINE_free(gen_eng);
index 456952e..5ebbf6b 100644 (file)
@@ -712,7 +712,7 @@ static int cert_status_cb(SSL *s, void *arg)
        int use_ssl;
        unsigned char *rspder = NULL;
        int rspderlen;
-       STACK_OF(STRING) *aia = NULL;
+       STACK_OF(OPENSSL_STRING) *aia = NULL;
        X509 *x = NULL;
        X509_STORE_CTX inctx;
        X509_OBJECT obj;
@@ -734,7 +734,7 @@ BIO_printf(err, "cert_status: received %d ids\n", sk_OCSP_RESPID_num(ids));
        aia = X509_get1_ocsp(x);
        if (aia)
                {
-               if (!OCSP_parse_url(sk_STRING_value(aia, 0),
+               if (!OCSP_parse_url(sk_OPENSSL_STRING_value(aia, 0),
                        &host, &port, &path, &use_ssl))
                        {
                        BIO_puts(err, "cert_status: can't parse AIA URL\n");
@@ -742,7 +742,7 @@ BIO_printf(err, "cert_status: received %d ids\n", sk_OCSP_RESPID_num(ids));
                        }
                if (srctx->verbose)
                        BIO_printf(err, "cert_status: AIA URL: %s\n",
-                                       sk_STRING_value(aia, 0));
+                                       sk_OPENSSL_STRING_value(aia, 0));
                }
        else
                {
index 0416154..67df066 100644 (file)
@@ -93,7 +93,7 @@ int MAIN(int argc, char **argv)
        const char *inmode = "r", *outmode = "w";
        char *infile = NULL, *outfile = NULL;
        char *signerfile = NULL, *recipfile = NULL;
-       STACK_OF(STRING) *sksigners = NULL, *skkeys = NULL;
+       STACK_OF(OPENSSL_STRING) *sksigners = NULL, *skkeys = NULL;
        char *certfile = NULL, *keyfile = NULL, *contfile=NULL;
        const EVP_CIPHER *cipher = NULL;
        PKCS7 *p7 = NULL;
@@ -260,13 +260,13 @@ int MAIN(int argc, char **argv)
                        if (signerfile)
                                {
                                if (!sksigners)
-                                       sksigners = sk_STRING_new_null();
-                               sk_STRING_push(sksigners, signerfile);
+                                       sksigners = sk_OPENSSL_STRING_new_null();
+                               sk_OPENSSL_STRING_push(sksigners, signerfile);
                                if (!keyfile)
                                        keyfile = signerfile;
                                if (!skkeys)
-                                       skkeys = sk_STRING_new_null();
-                               sk_STRING_push(skkeys, keyfile);
+                                       skkeys = sk_OPENSSL_STRING_new_null();
+                               sk_OPENSSL_STRING_push(skkeys, keyfile);
                                keyfile = NULL;
                                }
                        signerfile = *++args;
@@ -302,12 +302,12 @@ int MAIN(int argc, char **argv)
                                        goto argerr;
                                        }
                                if (!sksigners)
-                                       sksigners = sk_STRING_new_null();
-                               sk_STRING_push(sksigners, signerfile);
+                                       sksigners = sk_OPENSSL_STRING_new_null();
+                               sk_OPENSSL_STRING_push(sksigners, signerfile);
                                signerfile = NULL;
                                if (!skkeys)
-                                       skkeys = sk_STRING_new_null();
-                               sk_STRING_push(skkeys, keyfile);
+                                       skkeys = sk_OPENSSL_STRING_new_null();
+                               sk_OPENSSL_STRING_push(skkeys, keyfile);
                                }
                        keyfile = *++args;
                        }
@@ -389,13 +389,13 @@ int MAIN(int argc, char **argv)
                if (signerfile)
                        {
                        if (!sksigners)
-                               sksigners = sk_STRING_new_null();
-                       sk_STRING_push(sksigners, signerfile);
+                               sksigners = sk_OPENSSL_STRING_new_null();
+                       sk_OPENSSL_STRING_push(sksigners, signerfile);
                        if (!skkeys)
-                               skkeys = sk_STRING_new_null();
+                               skkeys = sk_OPENSSL_STRING_new_null();
                        if (!keyfile)
                                keyfile = signerfile;
-                       sk_STRING_push(skkeys, keyfile);
+                       sk_OPENSSL_STRING_push(skkeys, keyfile);
                        }
                if (!sksigners)
                        {
@@ -707,10 +707,10 @@ int MAIN(int argc, char **argv)
                        }
                else
                        flags |= PKCS7_REUSE_DIGEST;
-               for (i = 0; i < sk_STRING_num(sksigners); i++)
+               for (i = 0; i < sk_OPENSSL_STRING_num(sksigners); i++)
                        {
-                       signerfile = sk_STRING_value(sksigners, i);
-                       keyfile = sk_STRING_value(skkeys, i);
+                       signerfile = sk_OPENSSL_STRING_value(sksigners, i);
+                       keyfile = sk_OPENSSL_STRING_value(skkeys, i);
                        signer = load_cert(bio_err, signerfile,FORMAT_PEM, NULL,
                                        e, "signer certificate");
                        if (!signer)
@@ -807,9 +807,9 @@ end:
        if (vpm)
                X509_VERIFY_PARAM_free(vpm);
        if (sksigners)
-               sk_STRING_free(sksigners);
+               sk_OPENSSL_STRING_free(sksigners);
        if (skkeys)
-               sk_STRING_free(skkeys);
+               sk_OPENSSL_STRING_free(skkeys);
        X509_STORE_free(store);
        X509_free(cert);
        X509_free(recip);
index f4198d9..72d104b 100644 (file)
@@ -738,14 +738,14 @@ bad:
                        else if ((email == i) || (ocsp_uri == i))
                                {
                                int j;
-                               STACK_OF(STRING) *emlst;
+                               STACK_OF(OPENSSL_STRING) *emlst;
                                if (email == i)
                                        emlst = X509_get1_email(x);
                                else
                                        emlst = X509_get1_ocsp(x);
-                               for (j = 0; j < sk_STRING_num(emlst); j++)
+                               for (j = 0; j < sk_OPENSSL_STRING_num(emlst); j++)
                                        BIO_printf(STDout, "%s\n",
-                                                  sk_STRING_value(emlst, j));
+                                                  sk_OPENSSL_STRING_value(emlst, j));
                                X509_email_free(emlst);
                                }
                        else if (aliasout == i)
index ed27d66..2768c48 100644 (file)
@@ -174,7 +174,7 @@ static const char* const lock_names[CRYPTO_NUM_LOCKS] =
 
 /* This is for applications to allocate new type names in the non-dynamic
    array of lock names.  These are numbered with positive numbers.  */
-static STACK_OF(STRING) *app_locks=NULL;
+static STACK_OF(OPENSSL_STRING) *app_locks=NULL;
 
 /* For applications that want a more dynamic way of handling threads, the
    following stack is used.  These are externally numbered with negative
@@ -210,7 +210,7 @@ int CRYPTO_get_new_lockid(char *name)
        SSLeay_MSVC5_hack=(double)name[0]*(double)name[1];
 #endif
 
-       if ((app_locks == NULL) && ((app_locks=sk_STRING_new_null()) == NULL))
+       if ((app_locks == NULL) && ((app_locks=sk_OPENSSL_STRING_new_null()) == NULL))
                {
                CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_LOCKID,ERR_R_MALLOC_FAILURE);
                return(0);
@@ -220,7 +220,7 @@ int CRYPTO_get_new_lockid(char *name)
                CRYPTOerr(CRYPTO_F_CRYPTO_GET_NEW_LOCKID,ERR_R_MALLOC_FAILURE);
                return(0);
                }
-       i=sk_STRING_push(app_locks,str);
+       i=sk_OPENSSL_STRING_push(app_locks,str);
        if (!i)
                OPENSSL_free(str);
        else
@@ -651,10 +651,10 @@ const char *CRYPTO_get_lock_name(int type)
                return("dynamic");
        else if (type < CRYPTO_NUM_LOCKS)
                return(lock_names[type]);
-       else if (type-CRYPTO_NUM_LOCKS > sk_STRING_num(app_locks))
+       else if (type-CRYPTO_NUM_LOCKS > sk_OPENSSL_STRING_num(app_locks))
                return("ERROR");
        else
-               return(sk_STRING_value(app_locks,type-CRYPTO_NUM_LOCKS));
+               return(sk_OPENSSL_STRING_value(app_locks,type-CRYPTO_NUM_LOCKS));
        }
 
 #if    defined(__i386)   || defined(__i386__)   || defined(_M_IX86) || \
index de164a6..807da7a 100644 (file)
@@ -146,7 +146,7 @@ struct st_dynamic_data_ctx
         * 'dirs' for loading. Default is to use 'dirs' as a fallback. */
        int dir_load;
        /* A stack of directories from which ENGINEs could be loaded */
-       STACK_OF(STRING) *dirs;
+       STACK_OF(OPENSSL_STRING) *dirs;
        };
 
 /* This is the "ex_data" index we obtain and reserve for use with our context
@@ -174,7 +174,7 @@ static void dynamic_data_ctx_free_func(void *parent, void *ptr,
                if(ctx->engine_id)
                        OPENSSL_free((void*)ctx->engine_id);
                if(ctx->dirs)
-                       sk_STRING_pop_free(ctx->dirs, int_free_str);
+                       sk_OPENSSL_STRING_pop_free(ctx->dirs, int_free_str);
                OPENSSL_free(ctx);
                }
        }
@@ -203,7 +203,7 @@ static int dynamic_set_data_ctx(ENGINE *e, dynamic_data_ctx **ctx)
        c->DYNAMIC_F1 = "v_check";
        c->DYNAMIC_F2 = "bind_engine";
        c->dir_load = 1;
-       c->dirs = sk_STRING_new_null();
+       c->dirs = sk_OPENSSL_STRING_new_null();
        if(!c->dirs)
                {
                ENGINEerr(ENGINE_F_DYNAMIC_SET_DATA_CTX,ERR_R_MALLOC_FAILURE);
@@ -393,7 +393,7 @@ static int dynamic_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void))
                                ERR_R_MALLOC_FAILURE);
                        return 0;
                        }
-               sk_STRING_insert(ctx->dirs, tmp_str, -1);
+               sk_OPENSSL_STRING_insert(ctx->dirs, tmp_str, -1);
                }
                return 1;
        default:
@@ -411,11 +411,11 @@ static int int_load(dynamic_data_ctx *ctx)
                                ctx->DYNAMIC_LIBNAME, NULL, 0)) != NULL)
                return 1;
        /* If we're not allowed to use 'dirs' or we have none, fail */
-       if(!ctx->dir_load || (num = sk_STRING_num(ctx->dirs)) < 1)
+       if(!ctx->dir_load || (num = sk_OPENSSL_STRING_num(ctx->dirs)) < 1)
                return 0;
        for(loop = 0; loop < num; loop++)
                {
-               const char *s = sk_STRING_value(ctx->dirs, loop);
+               const char *s = sk_OPENSSL_STRING_value(ctx->dirs, loop);
                char *merge = DSO_merge(ctx->dynamic_dso, ctx->DYNAMIC_LIBNAME, s);
                if(!merge)
                        return 0;
index 2fd376a..e7d8763 100644 (file)
@@ -230,8 +230,8 @@ void lh_node_usage_stats_bio(const _LHASH *lh, BIO *out);
   lh_stats_bio(CHECKED_LHASH_OF(type, lh), out)
 #define LHM_lh_free(type, lh) lh_free(CHECKED_LHASH_OF(type, lh))
 
-DECLARE_LHASH_OF(STRING);
-DECLARE_LHASH_OF(CSTRING);
+DECLARE_LHASH_OF(OPENSSL_STRING);
+DECLARE_LHASH_OF(OPENSSL_CSTRING);
 
 #ifdef  __cplusplus
 }
index 8a0a9c1..18fbd38 100644 (file)
@@ -110,9 +110,9 @@ o * In practice, however, it appears to be hard to have a const
  * string. For now, I'm settling for dealing with the fact it is a
  * string at all.
  */
-typedef char *STRING;
+typedef char *OPENSSL_STRING;
 
-typedef const char *CSTRING;
+typedef const char *OPENSSL_CSTRING;
 
 /* Confusingly, LHASH_OF(STRING) deals with char ** throughout, but
  * STACK_OF(STRING) is really more like STACK_OF(char), only, as
@@ -122,7 +122,7 @@ typedef const char *CSTRING;
  * macros below.
  */
 
-DECLARE_SPECIAL_STACK_OF(STRING, char)
+DECLARE_SPECIAL_STACK_OF(OPENSSL_STRING, char)
 
 /* Similarly, we sometimes use a block of characters, NOT
  * nul-terminated. These should also be distinguished from "normal"
@@ -2030,29 +2030,29 @@ DECLARE_SPECIAL_STACK_OF(BLOCK, void)
 #define sk_void_sort(st) SKM_sk_sort(void, (st))
 #define sk_void_is_sorted(st) SKM_sk_is_sorted(void, (st))
 
-#define sk_STRING_new(cmp) ((STACK_OF(STRING) *)sk_new(CHECKED_SK_CMP_FUNC(char, cmp)))
-#define sk_STRING_new_null() ((STACK_OF(STRING) *)sk_new_null())
-#define sk_STRING_push(st, val) sk_push(CHECKED_PTR_OF(STACK_OF(STRING), st), CHECKED_PTR_OF(char, val))
-#define sk_STRING_find(st, val) sk_find(CHECKED_PTR_OF(STACK_OF(STRING), st), CHECKED_PTR_OF(char, val))
-#define sk_STRING_value(st, i) ((STRING)sk_value(CHECKED_PTR_OF(STACK_OF(STRING), st), i))
-#define sk_STRING_num(st) SKM_sk_num(STRING, st)
-#define sk_STRING_pop_free(st, free_func) sk_pop_free(CHECKED_PTR_OF(STACK_OF(STRING), st), CHECKED_SK_FREE_FUNC2(STRING, free_func))
-#define sk_STRING_insert(st, val, i) sk_insert(CHECKED_PTR_OF(STACK_OF(STRING), st), CHECKED_PTR_OF(char, val), i)
-#define sk_STRING_free(st) SKM_sk_free(STRING, st)
-#define sk_STRING_set(st, i, val) sk_set((_STACK *)CHECKED_PTR_OF(STACK_OF(STRING), st), i, CHECKED_PTR_OF(char, val))
-#define sk_STRING_zero(st) SKM_sk_zero(STRING, (st))
-#define sk_STRING_unshift(st, val) sk_unshift((_STACK *)CHECKED_PTR_OF(STACK_OF(STRING), st), CHECKED_PTR_OF(char, val))
-#define sk_STRING_find_ex(st, val) sk_find_ex((_STACK *)CHECKED_CONST_PTR_OF(STACK_OF(STRING), st), CHECKED_CONST_PTR_OF(char, val))
-#define sk_STRING_delete(st, i) SKM_sk_delete(STRING, (st), (i))
-#define sk_STRING_delete_ptr(st, ptr) (STRING *)sk_delete_ptr((_STACK *)CHECKED_PTR_OF(STACK_OF(STRING), st), CHECKED_PTR_OF(char, ptr))
-#define sk_STRING_set_cmp_func(st, cmp)  \
+#define sk_OPENSSL_STRING_new(cmp) ((STACK_OF(OPENSSL_STRING) *)sk_new(CHECKED_SK_CMP_FUNC(char, cmp)))
+#define sk_OPENSSL_STRING_new_null() ((STACK_OF(OPENSSL_STRING) *)sk_new_null())
+#define sk_OPENSSL_STRING_push(st, val) sk_push(CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), CHECKED_PTR_OF(char, val))
+#define sk_OPENSSL_STRING_find(st, val) sk_find(CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), CHECKED_PTR_OF(char, val))
+#define sk_OPENSSL_STRING_value(st, i) ((OPENSSL_STRING)sk_value(CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), i))
+#define sk_OPENSSL_STRING_num(st) SKM_sk_num(OPENSSL_STRING, st)
+#define sk_OPENSSL_STRING_pop_free(st, free_func) sk_pop_free(CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), CHECKED_SK_FREE_FUNC2(OPENSSL_STRING, free_func))
+#define sk_OPENSSL_STRING_insert(st, val, i) sk_insert(CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), CHECKED_PTR_OF(char, val), i)
+#define sk_OPENSSL_STRING_free(st) SKM_sk_free(OPENSSL_STRING, st)
+#define sk_OPENSSL_STRING_set(st, i, val) sk_set((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), i, CHECKED_PTR_OF(char, val))
+#define sk_OPENSSL_STRING_zero(st) SKM_sk_zero(OPENSSL_STRING, (st))
+#define sk_OPENSSL_STRING_unshift(st, val) sk_unshift((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), CHECKED_PTR_OF(char, val))
+#define sk_OPENSSL_STRING_find_ex(st, val) sk_find_ex((_STACK *)CHECKED_CONST_PTR_OF(STACK_OF(OPENSSL_STRING), st), CHECKED_CONST_PTR_OF(char, val))
+#define sk_OPENSSL_STRING_delete(st, i) SKM_sk_delete(OPENSSL_STRING, (st), (i))
+#define sk_OPENSSL_STRING_delete_ptr(st, ptr) (OPENSSL_STRING *)sk_delete_ptr((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), CHECKED_PTR_OF(char, ptr))
+#define sk_OPENSSL_STRING_set_cmp_func(st, cmp)  \
        ((int (*)(const char * const *,const char * const *)) \
-       sk_set_cmp_func((_STACK *)CHECKED_PTR_OF(STACK_OF(STRING), st), CHECKED_SK_CMP_FUNC(char, cmp)))
-#define sk_STRING_dup(st) SKM_sk_dup(STRING, st)
-#define sk_STRING_shift(st) SKM_sk_shift(STRING, (st))
-#define sk_STRING_pop(st) (char *)sk_pop((_STACK *)CHECKED_PTR_OF(STACK_OF(STRING), st))
-#define sk_STRING_sort(st) SKM_sk_sort(STRING, (st))
-#define sk_STRING_is_sorted(st) SKM_sk_is_sorted(STRING, (st))
+       sk_set_cmp_func((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st), CHECKED_SK_CMP_FUNC(char, cmp)))
+#define sk_OPENSSL_STRING_dup(st) SKM_sk_dup(OPENSSL_STRING, st)
+#define sk_OPENSSL_STRING_shift(st) SKM_sk_shift(OPENSSL_STRING, (st))
+#define sk_OPENSSL_STRING_pop(st) (char *)sk_pop((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_STRING), st))
+#define sk_OPENSSL_STRING_sort(st) SKM_sk_sort(OPENSSL_STRING, (st))
+#define sk_OPENSSL_STRING_is_sorted(st) SKM_sk_is_sorted(OPENSSL_STRING, (st))
 
 
 #define sk_BLOCK_new(cmp) ((STACK_OF(BLOCK) *)sk_new(CHECKED_SK_CMP_FUNC(void, cmp)))
@@ -2080,29 +2080,29 @@ DECLARE_SPECIAL_STACK_OF(BLOCK, void)
 #define sk_BLOCK_is_sorted(st) SKM_sk_is_sorted(BLOCK, (st))
 
 
-#define sk_PSTRING_new(cmp) ((STACK_OF(PSTRING) *)sk_new(CHECKED_SK_CMP_FUNC(STRING, cmp)))
-#define sk_PSTRING_new_null() ((STACK_OF(PSTRING) *)sk_new_null())
-#define sk_PSTRING_push(st, val) sk_push(CHECKED_PTR_OF(STACK_OF(PSTRING), st), CHECKED_PTR_OF(STRING, val))
-#define sk_PSTRING_find(st, val) sk_find(CHECKED_PTR_OF(STACK_OF(PSTRING), st), CHECKED_PTR_OF(STRING, val))
-#define sk_PSTRING_value(st, i) ((PSTRING)sk_value(CHECKED_PTR_OF(STACK_OF(PSTRING), st), i))
-#define sk_PSTRING_num(st) SKM_sk_num(PSTRING, st)
-#define sk_PSTRING_pop_free(st, free_func) sk_pop_free(CHECKED_PTR_OF(STACK_OF(PSTRING), st), CHECKED_SK_FREE_FUNC2(PSTRING, free_func))
-#define sk_PSTRING_insert(st, val, i) sk_insert(CHECKED_PTR_OF(STACK_OF(PSTRING), st), CHECKED_PTR_OF(STRING, val), i)
-#define sk_PSTRING_free(st) SKM_sk_free(PSTRING, st)
-#define sk_PSTRING_set(st, i, val) sk_set((_STACK *)CHECKED_PTR_OF(STACK_OF(PSTRING), st), i, CHECKED_PTR_OF(STRING, val))
-#define sk_PSTRING_zero(st) SKM_sk_zero(PSTRING, (st))
-#define sk_PSTRING_unshift(st, val) sk_unshift((_STACK *)CHECKED_PTR_OF(STACK_OF(PSTRING), st), CHECKED_PTR_OF(STRING, val))
-#define sk_PSTRING_find_ex(st, val) sk_find_ex((_STACK *)CHECKED_CONST_PTR_OF(STACK_OF(PSTRING), st), CHECKED_CONST_PTR_OF(STRING, val))
-#define sk_PSTRING_delete(st, i) SKM_sk_delete(PSTRING, (st), (i))
-#define sk_PSTRING_delete_ptr(st, ptr) (PSTRING *)sk_delete_ptr((_STACK *)CHECKED_PTR_OF(STACK_OF(PSTRING), st), CHECKED_PTR_OF(STRING, ptr))
-#define sk_PSTRING_set_cmp_func(st, cmp)  \
-       ((int (*)(const STRING * const *,const STRING * const *)) \
-       sk_set_cmp_func((_STACK *)CHECKED_PTR_OF(STACK_OF(PSTRING), st), CHECKED_SK_CMP_FUNC(STRING, cmp)))
-#define sk_PSTRING_dup(st) SKM_sk_dup(PSTRING, st)
-#define sk_PSTRING_shift(st) SKM_sk_shift(PSTRING, (st))
-#define sk_PSTRING_pop(st) (STRING *)sk_pop((_STACK *)CHECKED_PTR_OF(STACK_OF(PSTRING), st))
-#define sk_PSTRING_sort(st) SKM_sk_sort(PSTRING, (st))
-#define sk_PSTRING_is_sorted(st) SKM_sk_is_sorted(PSTRING, (st))
+#define sk_OPENSSL_PSTRING_new(cmp) ((STACK_OF(OPENSSL_PSTRING) *)sk_new(CHECKED_SK_CMP_FUNC(OPENSSL_STRING, cmp)))
+#define sk_OPENSSL_PSTRING_new_null() ((STACK_OF(OPENSSL_PSTRING) *)sk_new_null())
+#define sk_OPENSSL_PSTRING_push(st, val) sk_push(CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), CHECKED_PTR_OF(OPENSSL_STRING, val))
+#define sk_OPENSSL_PSTRING_find(st, val) sk_find(CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), CHECKED_PTR_OF(OPENSSL_STRING, val))
+#define sk_OPENSSL_PSTRING_value(st, i) ((OPENSSL_PSTRING)sk_value(CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), i))
+#define sk_OPENSSL_PSTRING_num(st) SKM_sk_num(OPENSSL_PSTRING, st)
+#define sk_OPENSSL_PSTRING_pop_free(st, free_func) sk_pop_free(CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), CHECKED_SK_FREE_FUNC2(OPENSSL_PSTRING, free_func))
+#define sk_OPENSSL_PSTRING_insert(st, val, i) sk_insert(CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), CHECKED_PTR_OF(OPENSSL_STRING, val), i)
+#define sk_OPENSSL_PSTRING_free(st) SKM_sk_free(OPENSSL_PSTRING, st)
+#define sk_OPENSSL_PSTRING_set(st, i, val) sk_set((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), i, CHECKED_PTR_OF(OPENSSL_STRING, val))
+#define sk_OPENSSL_PSTRING_zero(st) SKM_sk_zero(OPENSSL_PSTRING, (st))
+#define sk_OPENSSL_PSTRING_unshift(st, val) sk_unshift((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), CHECKED_PTR_OF(OPENSSL_STRING, val))
+#define sk_OPENSSL_PSTRING_find_ex(st, val) sk_find_ex((_STACK *)CHECKED_CONST_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), CHECKED_CONST_PTR_OF(OPENSSL_STRING, val))
+#define sk_OPENSSL_PSTRING_delete(st, i) SKM_sk_delete(OPENSSL_PSTRING, (st), (i))
+#define sk_OPENSSL_PSTRING_delete_ptr(st, ptr) (OPENSSL_PSTRING *)sk_delete_ptr((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), CHECKED_PTR_OF(OPENSSL_STRING, ptr))
+#define sk_OPENSSL_PSTRING_set_cmp_func(st, cmp)  \
+       ((int (*)(const OPENSSL_STRING * const *,const OPENSSL_STRING * const *)) \
+       sk_set_cmp_func((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st), CHECKED_SK_CMP_FUNC(OPENSSL_STRING, cmp)))
+#define sk_OPENSSL_PSTRING_dup(st) SKM_sk_dup(OPENSSL_PSTRING, st)
+#define sk_OPENSSL_PSTRING_shift(st) SKM_sk_shift(OPENSSL_PSTRING, (st))
+#define sk_OPENSSL_PSTRING_pop(st) (OPENSSL_STRING *)sk_pop((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_PSTRING), st))
+#define sk_OPENSSL_PSTRING_sort(st) SKM_sk_sort(OPENSSL_PSTRING, (st))
+#define sk_OPENSSL_PSTRING_is_sorted(st) SKM_sk_is_sorted(OPENSSL_PSTRING, (st))
 
 
 #define d2i_ASN1_SET_OF_ACCESS_DESCRIPTION(st, pp, length, d2i_func, free_func, ex_tag, ex_class) \
@@ -2390,24 +2390,6 @@ DECLARE_SPECIAL_STACK_OF(BLOCK, void)
   LHM_lh_stats_bio(CONF_VALUE,lh,out)
 #define lh_CONF_VALUE_free(lh) LHM_lh_free(CONF_VALUE,lh)
 
-#define lh_CSTRING_new() LHM_lh_new(CSTRING,cstring)
-#define lh_CSTRING_insert(lh,inst) LHM_lh_insert(CSTRING,lh,inst)
-#define lh_CSTRING_retrieve(lh,inst) LHM_lh_retrieve(CSTRING,lh,inst)
-#define lh_CSTRING_delete(lh,inst) LHM_lh_delete(CSTRING,lh,inst)
-#define lh_CSTRING_doall(lh,fn) LHM_lh_doall(CSTRING,lh,fn)
-#define lh_CSTRING_doall_arg(lh,fn,arg_type,arg) \
-  LHM_lh_doall_arg(CSTRING,lh,fn,arg_type,arg)
-#define lh_CSTRING_error(lh) LHM_lh_error(CSTRING,lh)
-#define lh_CSTRING_num_items(lh) LHM_lh_num_items(CSTRING,lh)
-#define lh_CSTRING_down_load(lh) LHM_lh_down_load(CSTRING,lh)
-#define lh_CSTRING_node_stats_bio(lh,out) \
-  LHM_lh_node_stats_bio(CSTRING,lh,out)
-#define lh_CSTRING_node_usage_stats_bio(lh,out) \
-  LHM_lh_node_usage_stats_bio(CSTRING,lh,out)
-#define lh_CSTRING_stats_bio(lh,out) \
-  LHM_lh_stats_bio(CSTRING,lh,out)
-#define lh_CSTRING_free(lh) LHM_lh_free(CSTRING,lh)
-
 #define lh_ENGINE_PILE_new() LHM_lh_new(ENGINE_PILE,engine_pile)
 #define lh_ENGINE_PILE_insert(lh,inst) LHM_lh_insert(ENGINE_PILE,lh,inst)
 #define lh_ENGINE_PILE_retrieve(lh,inst) LHM_lh_retrieve(ENGINE_PILE,lh,inst)
@@ -2534,6 +2516,42 @@ DECLARE_SPECIAL_STACK_OF(BLOCK, void)
   LHM_lh_stats_bio(OBJ_NAME,lh,out)
 #define lh_OBJ_NAME_free(lh) LHM_lh_free(OBJ_NAME,lh)
 
+#define lh_OPENSSL_CSTRING_new() LHM_lh_new(OPENSSL_CSTRING,openssl_cstring)
+#define lh_OPENSSL_CSTRING_insert(lh,inst) LHM_lh_insert(OPENSSL_CSTRING,lh,inst)
+#define lh_OPENSSL_CSTRING_retrieve(lh,inst) LHM_lh_retrieve(OPENSSL_CSTRING,lh,inst)
+#define lh_OPENSSL_CSTRING_delete(lh,inst) LHM_lh_delete(OPENSSL_CSTRING,lh,inst)
+#define lh_OPENSSL_CSTRING_doall(lh,fn) LHM_lh_doall(OPENSSL_CSTRING,lh,fn)
+#define lh_OPENSSL_CSTRING_doall_arg(lh,fn,arg_type,arg) \
+  LHM_lh_doall_arg(OPENSSL_CSTRING,lh,fn,arg_type,arg)
+#define lh_OPENSSL_CSTRING_error(lh) LHM_lh_error(OPENSSL_CSTRING,lh)
+#define lh_OPENSSL_CSTRING_num_items(lh) LHM_lh_num_items(OPENSSL_CSTRING,lh)
+#define lh_OPENSSL_CSTRING_down_load(lh) LHM_lh_down_load(OPENSSL_CSTRING,lh)
+#define lh_OPENSSL_CSTRING_node_stats_bio(lh,out) \
+  LHM_lh_node_stats_bio(OPENSSL_CSTRING,lh,out)
+#define lh_OPENSSL_CSTRING_node_usage_stats_bio(lh,out) \
+  LHM_lh_node_usage_stats_bio(OPENSSL_CSTRING,lh,out)
+#define lh_OPENSSL_CSTRING_stats_bio(lh,out) \
+  LHM_lh_stats_bio(OPENSSL_CSTRING,lh,out)
+#define lh_OPENSSL_CSTRING_free(lh) LHM_lh_free(OPENSSL_CSTRING,lh)
+
+#define lh_OPENSSL_STRING_new() LHM_lh_new(OPENSSL_STRING,openssl_string)
+#define lh_OPENSSL_STRING_insert(lh,inst) LHM_lh_insert(OPENSSL_STRING,lh,inst)
+#define lh_OPENSSL_STRING_retrieve(lh,inst) LHM_lh_retrieve(OPENSSL_STRING,lh,inst)
+#define lh_OPENSSL_STRING_delete(lh,inst) LHM_lh_delete(OPENSSL_STRING,lh,inst)
+#define lh_OPENSSL_STRING_doall(lh,fn) LHM_lh_doall(OPENSSL_STRING,lh,fn)
+#define lh_OPENSSL_STRING_doall_arg(lh,fn,arg_type,arg) \
+  LHM_lh_doall_arg(OPENSSL_STRING,lh,fn,arg_type,arg)
+#define lh_OPENSSL_STRING_error(lh) LHM_lh_error(OPENSSL_STRING,lh)
+#define lh_OPENSSL_STRING_num_items(lh) LHM_lh_num_items(OPENSSL_STRING,lh)
+#define lh_OPENSSL_STRING_down_load(lh) LHM_lh_down_load(OPENSSL_STRING,lh)
+#define lh_OPENSSL_STRING_node_stats_bio(lh,out) \
+  LHM_lh_node_stats_bio(OPENSSL_STRING,lh,out)
+#define lh_OPENSSL_STRING_node_usage_stats_bio(lh,out) \
+  LHM_lh_node_usage_stats_bio(OPENSSL_STRING,lh,out)
+#define lh_OPENSSL_STRING_stats_bio(lh,out) \
+  LHM_lh_stats_bio(OPENSSL_STRING,lh,out)
+#define lh_OPENSSL_STRING_free(lh) LHM_lh_free(OPENSSL_STRING,lh)
+
 #define lh_SSL_SESSION_new() LHM_lh_new(SSL_SESSION,ssl_session)
 #define lh_SSL_SESSION_insert(lh,inst) LHM_lh_insert(SSL_SESSION,lh,inst)
 #define lh_SSL_SESSION_retrieve(lh,inst) LHM_lh_retrieve(SSL_SESSION,lh,inst)
@@ -2551,24 +2569,6 @@ DECLARE_SPECIAL_STACK_OF(BLOCK, void)
 #define lh_SSL_SESSION_stats_bio(lh,out) \
   LHM_lh_stats_bio(SSL_SESSION,lh,out)
 #define lh_SSL_SESSION_free(lh) LHM_lh_free(SSL_SESSION,lh)
-
-#define lh_STRING_new() LHM_lh_new(STRING,string)
-#define lh_STRING_insert(lh,inst) LHM_lh_insert(STRING,lh,inst)
-#define lh_STRING_retrieve(lh,inst) LHM_lh_retrieve(STRING,lh,inst)
-#define lh_STRING_delete(lh,inst) LHM_lh_delete(STRING,lh,inst)
-#define lh_STRING_doall(lh,fn) LHM_lh_doall(STRING,lh,fn)
-#define lh_STRING_doall_arg(lh,fn,arg_type,arg) \
-  LHM_lh_doall_arg(STRING,lh,fn,arg_type,arg)
-#define lh_STRING_error(lh) LHM_lh_error(STRING,lh)
-#define lh_STRING_num_items(lh) LHM_lh_num_items(STRING,lh)
-#define lh_STRING_down_load(lh) LHM_lh_down_load(STRING,lh)
-#define lh_STRING_node_stats_bio(lh,out) \
-  LHM_lh_node_stats_bio(STRING,lh,out)
-#define lh_STRING_node_usage_stats_bio(lh,out) \
-  LHM_lh_node_usage_stats_bio(STRING,lh,out)
-#define lh_STRING_stats_bio(lh,out) \
-  LHM_lh_stats_bio(STRING,lh,out)
-#define lh_STRING_free(lh) LHM_lh_free(STRING,lh)
 /* End of util/mkstack.pl block, you may now edit :-) */
 
 #endif /* !defined HEADER_SAFESTACK_H */
index 7e33f14..6f2ce3b 100644 (file)
@@ -78,7 +78,7 @@ TXT_DB *TXT_DB_read(BIO *in, int num)
        int size=BUFSIZE;
        int offset=0;
        char *p,*f;
-       STRING *pp;
+       OPENSSL_STRING *pp;
        BUF_MEM *buf=NULL;
 
        if ((buf=BUF_MEM_new()) == NULL) goto err;
@@ -89,7 +89,7 @@ TXT_DB *TXT_DB_read(BIO *in, int num)
        ret->num_fields=num;
        ret->index=NULL;
        ret->qual=NULL;
-       if ((ret->data=sk_PSTRING_new_null()) == NULL)
+       if ((ret->data=sk_OPENSSL_PSTRING_new_null()) == NULL)
                goto err;
        if ((ret->index=OPENSSL_malloc(sizeof(*ret->index)*num)) == NULL)
                goto err;
@@ -163,7 +163,7 @@ TXT_DB *TXT_DB_read(BIO *in, int num)
                        goto err;
                        }
                pp[n]=p;
-               if (!sk_PSTRING_push(ret->data,pp))
+               if (!sk_OPENSSL_PSTRING_push(ret->data,pp))
                        {
 #if !defined(OPENSSL_NO_STDIO) && !defined(OPENSSL_SYS_WIN16)  /* temporary fix :-( */
                        fprintf(stderr,"failure in sk_push\n");
@@ -182,7 +182,7 @@ err:
 #endif
                if (ret != NULL)
                        {
-                       if (ret->data != NULL) sk_PSTRING_free(ret->data);
+                       if (ret->data != NULL) sk_OPENSSL_PSTRING_free(ret->data);
                        if (ret->index != NULL) OPENSSL_free(ret->index);
                        if (ret->qual != NULL) OPENSSL_free(ret->qual);
                        if (ret != NULL) OPENSSL_free(ret);
@@ -193,10 +193,10 @@ err:
                return(ret);
        }
 
-STRING *TXT_DB_get_by_index(TXT_DB *db, int idx, STRING *value)
+OPENSSL_STRING *TXT_DB_get_by_index(TXT_DB *db, int idx, OPENSSL_STRING *value)
        {
-       STRING *ret;
-       LHASH_OF(STRING) *lh;
+       OPENSSL_STRING *ret;
+       LHASH_OF(OPENSSL_STRING) *lh;
 
        if (idx >= db->num_fields)
                {
@@ -209,16 +209,16 @@ STRING *TXT_DB_get_by_index(TXT_DB *db, int idx, STRING *value)
                db->error=DB_ERROR_NO_INDEX;
                return(NULL);
                }
-       ret=lh_STRING_retrieve(lh,value);
+       ret=lh_OPENSSL_STRING_retrieve(lh,value);
        db->error=DB_ERROR_OK;
        return(ret);
        }
 
-int TXT_DB_create_index(TXT_DB *db, int field, int (*qual)(STRING *),
+int TXT_DB_create_index(TXT_DB *db, int field, int (*qual)(OPENSSL_STRING *),
                        LHASH_HASH_FN_TYPE hash, LHASH_COMP_FN_TYPE cmp)
        {
-       LHASH_OF(STRING) *idx;
-       STRING *r;
+       LHASH_OF(OPENSSL_STRING) *idx;
+       OPENSSL_STRING *r;
        int i,n;
 
        if (field >= db->num_fields)
@@ -227,26 +227,26 @@ int TXT_DB_create_index(TXT_DB *db, int field, int (*qual)(STRING *),
                return(0);
                }
        /* FIXME: we lose type checking at this point */
-       if ((idx=(LHASH_OF(STRING) *)lh_new(hash,cmp)) == NULL)
+       if ((idx=(LHASH_OF(OPENSSL_STRING) *)lh_new(hash,cmp)) == NULL)
                {
                db->error=DB_ERROR_MALLOC;
                return(0);
                }
-       n=sk_PSTRING_num(db->data);
+       n=sk_OPENSSL_PSTRING_num(db->data);
        for (i=0; i<n; i++)
                {
-               r=sk_PSTRING_value(db->data,i);
+               r=sk_OPENSSL_PSTRING_value(db->data,i);
                if ((qual != NULL) && (qual(r) == 0)) continue;
-               if ((r=lh_STRING_insert(idx,r)) != NULL)
+               if ((r=lh_OPENSSL_STRING_insert(idx,r)) != NULL)
                        {
                        db->error=DB_ERROR_INDEX_CLASH;
-                       db->arg1=sk_PSTRING_find(db->data,r);
+                       db->arg1=sk_OPENSSL_PSTRING_find(db->data,r);
                        db->arg2=i;
-                       lh_STRING_free(idx);
+                       lh_OPENSSL_STRING_free(idx);
                        return(0);
                        }
                }
-       if (db->index[field] != NULL) lh_STRING_free(db->index[field]);
+       if (db->index[field] != NULL) lh_OPENSSL_STRING_free(db->index[field]);
        db->index[field]=idx;
        db->qual[field]=qual;
        return(1);
@@ -261,11 +261,11 @@ long TXT_DB_write(BIO *out, TXT_DB *db)
 
        if ((buf=BUF_MEM_new()) == NULL)
                goto err;
-       n=sk_PSTRING_num(db->data);
+       n=sk_OPENSSL_PSTRING_num(db->data);
        nn=db->num_fields;
        for (i=0; i<n; i++)
                {
-               pp=sk_PSTRING_value(db->data,i);
+               pp=sk_OPENSSL_PSTRING_value(db->data,i);
 
                l=0;
                for (j=0; j<nn; j++)
@@ -300,10 +300,10 @@ err:
        return(ret);
        }
 
-int TXT_DB_insert(TXT_DB *db, STRING *row)
+int TXT_DB_insert(TXT_DB *db, OPENSSL_STRING *row)
        {
        int i;
-       STRING *r;
+       OPENSSL_STRING *r;
 
        for (i=0; i<db->num_fields; i++)
                {
@@ -311,7 +311,7 @@ int TXT_DB_insert(TXT_DB *db, STRING *row)
                        {
                        if ((db->qual[i] != NULL) &&
                                (db->qual[i](row) == 0)) continue;
-                       r=lh_STRING_retrieve(db->index[i],row);
+                       r=lh_OPENSSL_STRING_retrieve(db->index[i],row);
                        if (r != NULL)
                                {
                                db->error=DB_ERROR_INDEX_CLASH;
@@ -322,7 +322,7 @@ int TXT_DB_insert(TXT_DB *db, STRING *row)
                        }
                }
        /* We have passed the index checks, now just append and insert */
-       if (!sk_PSTRING_push(db->data,row))
+       if (!sk_OPENSSL_PSTRING_push(db->data,row))
                {
                db->error=DB_ERROR_MALLOC;
                goto err;
@@ -334,7 +334,7 @@ int TXT_DB_insert(TXT_DB *db, STRING *row)
                        {
                        if ((db->qual[i] != NULL) &&
                                (db->qual[i](row) == 0)) continue;
-                       (void)lh_STRING_insert(db->index[i],row);
+                       (void)lh_OPENSSL_STRING_insert(db->index[i],row);
                        }
                }
        return(1);
@@ -353,18 +353,18 @@ void TXT_DB_free(TXT_DB *db)
        if (db->index != NULL)
                {
                for (i=db->num_fields-1; i>=0; i--)
-                       if (db->index[i] != NULL) lh_STRING_free(db->index[i]);
+                       if (db->index[i] != NULL) lh_OPENSSL_STRING_free(db->index[i]);
                OPENSSL_free(db->index);
                }
        if (db->qual != NULL)
                OPENSSL_free(db->qual);
        if (db->data != NULL)
                {
-               for (i=sk_PSTRING_num(db->data)-1; i>=0; i--)
+               for (i=sk_OPENSSL_PSTRING_num(db->data)-1; i>=0; i--)
                        {
                        /* check if any 'fields' have been allocated
                         * from outside of the initial block */
-                       p=sk_PSTRING_value(db->data,i);
+                       p=sk_OPENSSL_PSTRING_value(db->data,i);
                        max=p[db->num_fields]; /* last address */
                        if (max == NULL) /* new row */
                                {
@@ -380,9 +380,9 @@ void TXT_DB_free(TXT_DB *db)
                                                OPENSSL_free(p[n]);
                                        }
                                }
-                       OPENSSL_free(sk_PSTRING_value(db->data,i));
+                       OPENSSL_free(sk_OPENSSL_PSTRING_value(db->data,i));
                        }
-               sk_PSTRING_free(db->data);
+               sk_OPENSSL_PSTRING_free(db->data);
                }
        OPENSSL_free(db);
        }
index 4076493..6abe435 100644 (file)
 extern "C" {
 #endif
 
-typedef STRING *PSTRING;
-DECLARE_SPECIAL_STACK_OF(PSTRING, STRING)
+typedef OPENSSL_STRING *OPENSSL_PSTRING;
+DECLARE_SPECIAL_STACK_OF(OPENSSL_PSTRING, OPENSSL_STRING)
 
 typedef struct txt_db_st
        {
        int num_fields;
-       STACK_OF(PSTRING) *data;
-       LHASH_OF(STRING) **index;
-       int (**qual)(STRING *);
+       STACK_OF(OPENSSL_PSTRING) *data;
+       LHASH_OF(OPENSSL_STRING) **index;
+       int (**qual)(OPENSSL_STRING *);
        long error;
        long arg1;
        long arg2;
-       STRING *arg_row;
+       OPENSSL_STRING *arg_row;
        } TXT_DB;
 
 #ifndef OPENSSL_NO_BIO
@@ -99,11 +99,11 @@ long TXT_DB_write(BIO *out, TXT_DB *db);
 TXT_DB *TXT_DB_read(char *in, int num);
 long TXT_DB_write(char *out, TXT_DB *db);
 #endif
-int TXT_DB_create_index(TXT_DB *db,int field,int (*qual)(STRING *),
+int TXT_DB_create_index(TXT_DB *db,int field,int (*qual)(OPENSSL_STRING *),
                        LHASH_HASH_FN_TYPE hash, LHASH_COMP_FN_TYPE cmp);
 void TXT_DB_free(TXT_DB *db);
-STRING *TXT_DB_get_by_index(TXT_DB *db, int idx, STRING *value);
-int TXT_DB_insert(TXT_DB *db, STRING *value);
+OPENSSL_STRING *TXT_DB_get_by_index(TXT_DB *db, int idx, OPENSSL_STRING *value);
+int TXT_DB_insert(TXT_DB *db, OPENSSL_STRING *value);
 
 #ifdef  __cplusplus
 }
index 4a87517..e030234 100644 (file)
@@ -67,9 +67,9 @@
 
 static char *strip_spaces(char *name);
 static int sk_strcmp(const char * const *a, const char * const *b);
-static STACK_OF(STRING) *get_email(X509_NAME *name, GENERAL_NAMES *gens);
-static void str_free(STRING str);
-static int append_ia5(STACK_OF(STRING) **sk, ASN1_IA5STRING *email);
+static STACK_OF(OPENSSL_STRING) *get_email(X509_NAME *name, GENERAL_NAMES *gens);
+static void str_free(OPENSSL_STRING str);
+static int append_ia5(STACK_OF(OPENSSL_STRING) **sk, ASN1_IA5STRING *email);
 
 static int ipv4_from_asc(unsigned char *v4, const char *in);
 static int ipv6_from_asc(unsigned char *v6, const char *in);
@@ -463,10 +463,10 @@ static int sk_strcmp(const char * const *a, const char * const *b)
        return strcmp(*a, *b);
 }
 
-STACK_OF(STRING) *X509_get1_email(X509 *x)
+STACK_OF(OPENSSL_STRING) *X509_get1_email(X509 *x)
 {
        GENERAL_NAMES *gens;
-       STACK_OF(STRING) *ret;
+       STACK_OF(OPENSSL_STRING) *ret;
 
        gens = X509_get_ext_d2i(x, NID_subject_alt_name, NULL, NULL);
        ret = get_email(X509_get_subject_name(x), gens);
@@ -474,10 +474,10 @@ STACK_OF(STRING) *X509_get1_email(X509 *x)
        return ret;
 }
 
-STACK_OF(STRING) *X509_get1_ocsp(X509 *x)
+STACK_OF(OPENSSL_STRING) *X509_get1_ocsp(X509 *x)
 {
        AUTHORITY_INFO_ACCESS *info;
-       STACK_OF(STRING) *ret = NULL;
+       STACK_OF(OPENSSL_STRING) *ret = NULL;
        int i;
 
        info = X509_get_ext_d2i(x, NID_info_access, NULL, NULL);
@@ -499,11 +499,11 @@ STACK_OF(STRING) *X509_get1_ocsp(X509 *x)
        return ret;
 }
 
-STACK_OF(STRING) *X509_REQ_get1_email(X509_REQ *x)
+STACK_OF(OPENSSL_STRING) *X509_REQ_get1_email(X509_REQ *x)
 {
        GENERAL_NAMES *gens;
        STACK_OF(X509_EXTENSION) *exts;
-       STACK_OF(STRING) *ret;
+       STACK_OF(OPENSSL_STRING) *ret;
 
        exts = X509_REQ_get_extensions(x);
        gens = X509V3_get_d2i(exts, NID_subject_alt_name, NULL, NULL);
@@ -514,9 +514,9 @@ STACK_OF(STRING) *X509_REQ_get1_email(X509_REQ *x)
 }
 
 
-static STACK_OF(STRING) *get_email(X509_NAME *name, GENERAL_NAMES *gens)
+static STACK_OF(OPENSSL_STRING) *get_email(X509_NAME *name, GENERAL_NAMES *gens)
 {
-       STACK_OF(STRING) *ret = NULL;
+       STACK_OF(OPENSSL_STRING) *ret = NULL;
        X509_NAME_ENTRY *ne;
        ASN1_IA5STRING *email;
        GENERAL_NAME *gen;
@@ -539,23 +539,23 @@ static STACK_OF(STRING) *get_email(X509_NAME *name, GENERAL_NAMES *gens)
        return ret;
 }
 
-static void str_free(STRING str)
+static void str_free(OPENSSL_STRING str)
 {
        OPENSSL_free(str);
 }
 
-static int append_ia5(STACK_OF(STRING) **sk, ASN1_IA5STRING *email)
+static int append_ia5(STACK_OF(OPENSSL_STRING) **sk, ASN1_IA5STRING *email)
 {
        char *emtmp;
        /* First some sanity checks */
        if(email->type != V_ASN1_IA5STRING) return 1;
        if(!email->data || !email->length) return 1;
-       if(!*sk) *sk = sk_STRING_new(sk_strcmp);
+       if(!*sk) *sk = sk_OPENSSL_STRING_new(sk_strcmp);
        if(!*sk) return 0;
        /* Don't add duplicates */
-       if(sk_STRING_find(*sk, (char *)email->data) != -1) return 1;
+       if(sk_OPENSSL_STRING_find(*sk, (char *)email->data) != -1) return 1;
        emtmp = BUF_strdup((char *)email->data);
-       if(!emtmp || !sk_STRING_push(*sk, emtmp)) {
+       if(!emtmp || !sk_OPENSSL_STRING_push(*sk, emtmp)) {
                X509_email_free(*sk);
                *sk = NULL;
                return 0;
@@ -563,9 +563,9 @@ static int append_ia5(STACK_OF(STRING) **sk, ASN1_IA5STRING *email)
        return 1;
 }
 
-void X509_email_free(STACK_OF(STRING) *sk)
+void X509_email_free(STACK_OF(OPENSSL_STRING) *sk)
 {
-       sk_STRING_pop_free(sk, str_free);
+       sk_OPENSSL_STRING_pop_free(sk, str_free);
 }
 
 /* Convert IP addresses both IPv4 and IPv6 into an 
index f9bacb6..b308abe 100644 (file)
@@ -693,10 +693,10 @@ int X509_PURPOSE_get_trust(X509_PURPOSE *xp);
 void X509_PURPOSE_cleanup(void);
 int X509_PURPOSE_get_id(X509_PURPOSE *);
 
-STACK_OF(STRING) *X509_get1_email(X509 *x);
-STACK_OF(STRING) *X509_REQ_get1_email(X509_REQ *x);
-void X509_email_free(STACK_OF(STRING) *sk);
-STACK_OF(STRING) *X509_get1_ocsp(X509 *x);
+STACK_OF(OPENSSL_STRING) *X509_get1_email(X509 *x);
+STACK_OF(OPENSSL_STRING) *X509_REQ_get1_email(X509_REQ *x);
+void X509_email_free(STACK_OF(OPENSSL_STRING) *sk);
+STACK_OF(OPENSSL_STRING) *X509_get1_ocsp(X509 *x);
 
 ASN1_OCTET_STRING *a2i_IPADDRESS(const char *ipasc);
 ASN1_OCTET_STRING *a2i_IPADDRESS_NC(const char *ipasc);