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

openssl/apps/engine.c

 /* apps/engine.c -*- mode: C; c-file-style: "eay" -*- */
 /* Written by Richard Levitte <richard@levitte.org> for the OpenSSL
  * project 2000.
  */
 /* ====================================================================
  * Copyright (c) 2000 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ skipping 74 matching lines @@
 "               to load it (if -t is used)\n",
 " -post <cmd> - runs command 'cmd' against the ENGINE after loading it\n",
 "               (only used if -t is also provided)\n",
 " NB: -pre and -post will be applied to all ENGINEs supplied on the command\n",
 " line, or all supported ENGINEs if none are specified.\n",
 " Eg. '-pre \"SO_PATH:/lib/libdriver.so\"' calls command \"SO_PATH\" with\n",
 " argument \"/lib/libdriver.so\".\n",
 NULL
 };
 
-static void identity(void *ptr)
+static void identity(char *ptr)
         {
         return;
         }
 
 static int append_buf(char **buf, const char *s, int *size, int step)
         {
         int l = strlen(s);
 
         if (*buf == NULL)
                 {
@@ skipping 35 matching lines @@
                 }
         /* If the object is internal, mark it in a way that shows instead of
          * having it part of all the other flags, even if it really is. */
         if(flags & ENGINE_CMD_FLAG_INTERNAL)
                 {
                 BIO_printf(bio_out, "[Internal] ");
                 }
 
         if(flags & ENGINE_CMD_FLAG_NUMERIC)
                 {
-                if(started)
-                        {
-                        BIO_printf(bio_out, "|");
-                        err = 1;
-                        }
                 BIO_printf(bio_out, "NUMERIC");
                 started = 1;
                 }
         /* Now we check that no combinations of the mutually exclusive NUMERIC,
          * STRING, and NO_INPUT flags have been used. Future flags that can be
          * OR'd together with these would need to added after these to preserve
          * the testing logic. */
         if(flags & ENGINE_CMD_FLAG_STRING)
                 {
                 if(started)
@@ skipping 32 matching lines @@
 
 static int util_verbose(ENGINE *e, int verbose, BIO *bio_out, const char *indent)
         {
         static const int line_wrap = 78;
         int num;
         int ret = 0;
         char *name = NULL;
         char *desc = NULL;
         int flags;
         int xpos = 0;
-        STACK *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))
                 {
 #if 0
                 BIO_printf(bio_out, "%s<no control commands>\n", indent);
 #endif
                 return 1;
                 }
 
-        cmds = sk_new_null();
+        cmds = sk_OPENSSL_STRING_new_null();
 
         if(!cmds)
                 goto err;
         do {
                 int len;
                 /* Get the command input flags */
                 if((flags = ENGINE_ctrl(e, ENGINE_CTRL_GET_CMD_FLAGS, num,
                                         NULL, NULL)) < 0)
                         goto err;
                 if (!(flags & ENGINE_CMD_FLAG_INTERNAL) || verbose >= 4)
@@ skipping 52 matching lines @@
                 OPENSSL_free(name); name = NULL;
                 if(desc) { OPENSSL_free(desc); desc = NULL; }
                 /* Move to the next command */
                 num = ENGINE_ctrl(e, ENGINE_CTRL_GET_NEXT_CMD_TYPE,
                                         num, NULL, NULL);
                 } while(num > 0);
         if(xpos > 0)
                 BIO_printf(bio_out, "\n");
         ret = 1;
 err:
-        if(cmds) sk_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 *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_num(cmds);
+        int loop, res, num = sk_OPENSSL_STRING_num(cmds);
+
         if(num < 0)
                 {
                 BIO_printf(bio_out, "[Error]: internal stack error\n");
                 return;
                 }
         for(loop = 0; loop < num; loop++)
                 {
                 char buf[256];
                 const char *cmd, *arg;
-                cmd = sk_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)
                         {
                         if(!ENGINE_ctrl_cmd_string(e, cmd, NULL, 0))
                                 res = 0;
                         }
                 else
                         {
                         if((int)(arg - cmd) > 254)
@@ skipping 19 matching lines @@
         }
 
 int MAIN(int, char **);
 
 int MAIN(int argc, char **argv)
         {
         int ret=1,i;
         const char **pp;
         int verbose=0, list_cap=0, test_avail=0, test_avail_noise = 0;
         ENGINE *e;
-        STACK *engines = sk_new_null();
-        STACK *pre_cmds = sk_new_null();
-        STACK *post_cmds = sk_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 = "     ";
 
         apps_startup();
         SSL_load_error_strings();
 
         if (bio_err == NULL)
                 bio_err=BIO_new_fp(stderr,BIO_NOCLOSE);
 
@@ skipping 26 matching lines @@
                         if(strspn(*argv + 1, "t") < strlen(*argv + 1))
                                 goto skip_arg_loop;
                         if((test_avail_noise = strlen(*argv + 1) - 1) > 1)
                                 goto skip_arg_loop;
                         }
                 else if (strcmp(*argv,"-pre") == 0)
                         {
                         argc--; argv++;
                         if (argc == 0)
                                 goto skip_arg_loop;
-                        sk_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_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_push(engines,*argv);
+                        sk_OPENSSL_STRING_push(engines,*argv);
                 argc--;
                 argv++;
                 }
         /* Looks like everything went OK */
         badops = 0;
 skip_arg_loop:
 
         if (badops)
                 {
                 for (pp=engine_usage; (*pp != NULL); pp++)
                         BIO_printf(bio_err,"%s",*pp);
                 goto end;
                 }
 
-        if (sk_num(engines) == 0)
+        if (sk_OPENSSL_STRING_num(engines) == 0)
                 {
                 for(e = ENGINE_get_first(); e != NULL; e = ENGINE_get_next(e))
                         {
-                        sk_push(engines,(char *)ENGINE_get_id(e));
+                        sk_OPENSSL_STRING_push(engines,(char *)ENGINE_get_id(e));
                         }
                 }
 
-        for (i=0; i<sk_num(engines); i++)
+        for (i=0; i<sk_OPENSSL_STRING_num(engines); i++)
                 {
-                const char *id = sk_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);
                         /* Do "id" first, then "name". Easier to auto-parse. */
                         BIO_printf(bio_out, "(%s) %s\n", id, name);
                         util_do_cmds(e, pre_cmds, bio_out, indent);
                         if (strcmp(ENGINE_get_id(e), id) != 0)
                                 {
                                 BIO_printf(bio_out, "Loaded: (%s) %s\n",
                                         ENGINE_get_id(e), ENGINE_get_name(e));
                                 }
                         if (list_cap)
                                 {
                                 int cap_size = 256;
                                 char *cap_buf = NULL;
                                 int k,n;
                                 const int *nids;
                                 ENGINE_CIPHERS_PTR fn_c;
                                 ENGINE_DIGESTS_PTR fn_d;
+                                ENGINE_PKEY_METHS_PTR fn_pk;
 
                                 if (ENGINE_get_RSA(e) != NULL
                                         && !append_buf(&cap_buf, "RSA",
                                                 &cap_size, 256))
                                         goto end;
                                 if (ENGINE_get_DSA(e) != NULL
                                         && !append_buf(&cap_buf, "DSA",
                                                 &cap_size, 256))
                                         goto end;
                                 if (ENGINE_get_DH(e) != NULL
@@ skipping 18 matching lines @@
                                 fn_d = ENGINE_get_digests(e);
                                 if(!fn_d) goto skip_digests;
                                 n = fn_d(e, NULL, &nids, 0);
                                 for(k=0 ; k < n ; ++k)
                                         if(!append_buf(&cap_buf,
                                                        OBJ_nid2sn(nids[k]),
                                                        &cap_size, 256))
                                                 goto end;
 
 skip_digests:
+                                fn_pk = ENGINE_get_pkey_meths(e);
+                                if(!fn_pk) goto skip_pmeths;
+                                n = fn_pk(e, NULL, &nids, 0);
+                                for(k=0 ; k < n ; ++k)
+                                        if(!append_buf(&cap_buf,
+                                                       OBJ_nid2sn(nids[k]),
+                                                       &cap_size, 256))
+                                                goto end;
+skip_pmeths:
                                 if (cap_buf && (*cap_buf != '\0'))
                                         BIO_printf(bio_out, " [%s]\n", cap_buf);
 
                                 OPENSSL_free(cap_buf);
                                 }
                         if(test_avail)
                                 {
                                 BIO_printf(bio_out, "%s", indent);
                                 if (ENGINE_init(e))
                                         {
@@ skipping 14 matching lines @@
                         ENGINE_free(e);
                         }
                 else
                         ERR_print_errors(bio_err);
                 }
 
         ret=0;
 end:
 
         ERR_print_errors(bio_err);
-        sk_pop_free(engines, identity);
-        sk_pop_free(pre_cmds, identity);
-        sk_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);
         }
 #else
 
 # if PEDANTIC
 static void *dummy=&dummy;
 # endif
 
 #endif