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

openssl/util/mkerr.pl

 #!/usr/local/bin/perl -w
 
 my $config = "crypto/err/openssl.ec";
+my $hprefix = "openssl/";
 my $debug = 0;
 my $rebuild = 0;
 my $static = 1;
 my $recurse = 0;
 my $reindex = 0;
 my $dowrite = 0;
 my $staticloader = "";
 
 my $pack_errcode;
 my $load_errcode;
 
+my $errcount;
+
 while (@ARGV) {
         my $arg = $ARGV[0];
         if($arg eq "-conf") {
                 shift @ARGV;
                 $config = shift @ARGV;
+        } elsif($arg eq "-hprefix") {
+                shift @ARGV;
+                $hprefix = shift @ARGV;
         } elsif($arg eq "-debug") {
                 $debug = 1;
                 shift @ARGV;
         } elsif($arg eq "-rebuild") {
                 $rebuild = 1;
                 shift @ARGV;
         } elsif($arg eq "-recurse") {
                 $recurse = 1;
                 shift @ARGV;
         } elsif($arg eq "-reindex") {
                 $reindex = 1;
                 shift @ARGV;
         } elsif($arg eq "-nostatic") {
                 $static = 0;
                 shift @ARGV;
         } elsif($arg eq "-staticloader") {
                 $staticloader = "static ";
                 shift @ARGV;
         } elsif($arg eq "-write") {
                 $dowrite = 1;
                 shift @ARGV;
+        } elsif($arg eq "-help" || $arg eq "-h" || $arg eq "-?" || $arg eq "--help") {
+                print STDERR <<"EOF";
+mkerr.pl [options] ...
+
+Options:
+
+  -conf F       Use the config file F instead of the default one:
+                  crypto/err/openssl.ec
+
+  -hprefix P    Prepend the filenames in generated #include <header>
+                statements with prefix P. Default: 'openssl/' (without
+                the quotes, naturally)
+
+  -debug        Turn on debugging verbose output on stderr.
+
+  -rebuild      Rebuild all header and C source files, irrespective of the
+                fact if any error or function codes have been added/removed.
+                Default: only update files for libraries which saw change
+                         (of course, this requires '-write' as well, or no
+                          files will be touched!)
+
+  -recurse      scan a preconfigured set of directories / files for error and
+                function codes:
+                  (<crypto/*.c>, <crypto/*/*.c>, <ssl/*.c>, <apps/*.c>)
+                When this option is NOT specified, the filelist is taken from
+                the commandline instead. Here, wildcards may be embedded. (Be
+                sure to escape those to prevent the shell from expanding them
+                for you when you wish mkerr.pl to do so instead.)
+                Default: take file list to scan from the command line.
+
+  -reindex      Discard the numeric values previously assigned to the error
+                and function codes as extracted from the scanned header files;
+                instead renumber all of them starting from 100. (Note that
+                the numbers assigned through 'R' records in the config file
+                remain intact.)
+                Default: keep previously assigned numbers. (You are warned
+                         when collisions are detected.)
+
+  -nostatic     Generates a different source code, where these additional 
+                functions are generated for each library specified in the
+                config file:
+                  void ERR_load_<LIB>_strings(void);
+                  void ERR_unload_<LIB>_strings(void);
+                  void ERR_<LIB>_error(int f, int r, char *fn, int ln);
+                  #define <LIB>err(f,r) ERR_<LIB>_error(f,r,__FILE__,__LINE__)
+                while the code facilitates the use of these in an environment
+                where the error support routines are dynamically loaded at 
+                runtime.
+                Default: 'static' code generation.
+
+  -staticloader Prefix generated functions with the 'static' scope modifier.
+                Default: don't write any scope modifier prefix.
+
+  -write        Actually (over)write the generated code to the header and C 
+                source files as assigned to each library through the config 
+                file.
+                Default: don't write.
+
+  -help / -h / -? / --help            Show this help text.
+
+  ...           Additional arguments are added to the file list to scan,
+                assuming '-recurse' was NOT specified on the command line.
+
+EOF
+                exit 1;
         } else {
                 last;
         }
 }
 
 if($recurse) {
-        @source = ( <crypto/*.c>, <crypto/*/*.c>, <ssl/*.c>,
-                        <fips/*.c>, <fips/*/*.c>);
+        @source = (<crypto/*.c>, <crypto/*/*.c>, <ssl/*.c>);
 } else {
         @source = @ARGV;
 }
 
 # Read in the config file
 
 open(IN, "<$config") || die "Can't open config file $config";
 
 # Parse config file
 
 while(<IN>)
 {
         if(/^L\s+(\S+)\s+(\S+)\s+(\S+)/) {
                 $hinc{$1} = $2;
                 $libinc{$2} = $1;
                 $cskip{$3} = $1;
                 if($3 ne "NONE") {
                         $csrc{$1} = $3;
-                        $fmax{$1} = 99;
-                        $rmax{$1} = 99;
+                        $fmax{$1} = 100;
+                        $rmax{$1} = 100;
                         $fassigned{$1} = ":";
                         $rassigned{$1} = ":";
                         $fnew{$1} = 0;
                         $rnew{$1} = 0;
                 }
         } elsif (/^F\s+(\S+)/) {
         # Add extra function with $1
         } elsif (/^R\s+(\S+)\s+(\S+)/) {
                 $rextra{$1} = $2;
                 $rcodes{$1} = $2;
@@ skipping 105 matching lines @@
                         $name = $1;
                         $code = $2;
                         next if $name =~ /^${lib}err/;
                         unless($name =~ /^${lib}_([RF])_(\w+)$/) {
                                 print STDERR "Invalid error code $name\n";
                                 next;
                         }
                         if($1 eq "R") {
                                 $rcodes{$name} = $code;
                                 if ($rassigned{$lib} =~ /:$code:/) {
-                                        print STDERR "!! ERROR: $lib reason code $code assigned twice\n";
+                                        print STDERR "!! ERROR: $lib reason code $code assigned twice (collision at $name)\n";
+                                        ++$errcount;
                                 }
                                 $rassigned{$lib} .= "$code:";
                                 if(!(exists $rextra{$name}) &&
                                          ($code > $rmax{$lib}) ) {
                                         $rmax{$lib} = $code;
                                 }
                         } else {
                                 if ($fassigned{$lib} =~ /:$code:/) {
-                                        print STDERR "!! ERROR: $lib function code $code assigned twice\n";
+                                        print STDERR "!! ERROR: $lib function code $code assigned twice (collision at $name)\n";
+                                        ++$errcount;
                                 }
                                 $fassigned{$lib} .= "$code:";
                                 if($code > $fmax{$lib}) {
                                         $fmax{$lib} = $code;
                                 }
                                 $fcodes{$name} = $code;
                         }
                 }
           }
         }
@@ skipping 10 matching lines @@
                         $rassigned{$lib} =~ m/^:(.*):$/;
                         @rassigned = sort {$a <=> $b} split(":", $1);
                         print STDERR "  @rassigned\n";
                 }
         }
 
         if ($lib eq "SSL") {
                 if ($rmax{$lib} >= 1000) {
                         print STDERR "!! ERROR: SSL error codes 1000+ are reserved for alerts.\n";
                         print STDERR "!!        Any new alerts must be added to $config.\n";
+                        ++$errcount;
                         print STDERR "\n";
                 }
         }
         close IN;
 }
 
 # Scan each C source file and look for function and reason codes
 # This is done by looking for strings that "look like" function or
 # reason codes: basically anything consisting of all upper case and
 # numerics which has _F_ or _R_ in it and which has the name of an
 # error library at the start. This seems to work fine except for the
 # oddly named structure BIO_F_CTX which needs to be ignored.
 # If a code doesn't exist in list compiled from headers then mark it
 # with the value "X" as a place holder to give it a value later.
 # Store all function and reason codes found in %ufcodes and %urcodes
 # so all those unreferenced can be printed out.
 
 
 foreach $file (@source) {
         # Don't parse the error source file.
         next if exists $cskip{$file};
         print STDERR "File loaded: ".$file."\r" if $debug;
         open(IN, "<$file") || die "Can't open source file $file\n";
         while(<IN>) {
+                # skip obsoleted source files entirely!
+                last if(/^#error\s+obsolete/);
+
                 if(/(([A-Z0-9]+)_F_([A-Z0-9_]+))/) {
                         next unless exists $csrc{$2};
                         next if($1 eq "BIO_F_BUFFER_CTX");
                         $ufcodes{$1} = 1;
                         if(!exists $fcodes{$1}) {
                                 $fcodes{$1} = "X";
                                 $fnew{$2}++;
                         }
                         $notrans{$1} = 1 unless exists $ftrans{$3};
+                        print STDERR "Function: $1\t= $fcodes{$1} (lib: $2, name: $3)\n" if $debug; 
                 }
                 if(/(([A-Z0-9]+)_R_[A-Z0-9_]+)/) {
                         next unless exists $csrc{$2};
                         $urcodes{$1} = 1;
                         if(!exists $rcodes{$1}) {
                                 $rcodes{$1} = "X";
                                 $rnew{$2}++;
                         }
+                        print STDERR "Reason: $1\t= $rcodes{$1} (lib: $2)\n" if $debug; 
                 } 
         }
         close IN;
 }
 print STDERR "                                  \n" if $debug;
 
 # Now process each library in turn.
 
 foreach $lib (keys %csrc)
 {
@@ skipping 21 matching lines @@
         if (open(IN, "<$hfile")) {
             # Copy across the old file
             while(<IN>) {
                 push @out, $_;
                 last if (/BEGIN ERROR CODES/);
             }
             close IN;
         } else {
             push @out,
 "/* ====================================================================\n",
-" * Copyright (c) 2001-2010 The OpenSSL Project.  All rights reserved.\n",
+" * Copyright (c) 2001-2011 The OpenSSL Project.  All rights reserved.\n",
 " *\n",
 " * Redistribution and use in source and binary forms, with or without\n",
 " * modification, are permitted provided that the following conditions\n",
 " * are met:\n",
 " *\n",
 " * 1. Redistributions of source code must retain the above copyright\n",
 " *    notice, this list of conditions and the following disclaimer. \n",
 " *\n",
 " * 2. Redistributions in binary form must reproduce the above copyright\n",
 " *    notice, this list of conditions and the following disclaimer in\n",
@@ skipping 35 matching lines @@
 " *\n",
 " * This product includes cryptographic software written by Eric Young\n",
 " * (eay\@cryptsoft.com).  This product includes software written by Tim\n",
 " * Hudson (tjh\@cryptsoft.com).\n",
 " *\n",
 " */\n",
 "\n",
 "#ifndef HEADER_${lib}_ERR_H\n",
 "#define HEADER_${lib}_ERR_H\n",
 "\n",
+"#ifdef  __cplusplus\n",
+"extern \"C\" {\n",
+"#endif\n",
+"\n",
 "/* BEGIN ERROR CODES */\n";
         }
         open (OUT, ">$hfile") || die "Can't Open File $hfile for writing\n";
 
         print OUT @out;
         undef @out;
         print OUT <<"EOF";
 /* The following lines are auto generated by the script mkerr.pl. Any changes
  * made after this point may be overwritten when the script is next run.
  */
@@ skipping 66 matching lines @@
 
         # Rewrite the C source file containing the error details.
 
         # First, read any existing reason string definitions:
         my %err_reason_strings;
         if (open(IN,"<$cfile")) {
                 while (<IN>) {
                         if (/\b(${lib}_R_\w*)\b.*\"(.*)\"/) {
                                 $err_reason_strings{$1} = $2;
                         }
+                        if (/\b${lib}_F_(\w*)\b.*\"(.*)\"/) {
+                                if (!exists $ftrans{$1} && ($1 ne $2)) {
+                                        print STDERR "WARNING: Mismatched function string $2\n";
+                                        $ftrans{$1} = $2;
+                                }
+                        }
                 }
                 close(IN);
         }
 
+
         my $hincf;
         if($static) {
                 $hfile =~ /([^\/]+)$/;
-                $hincf = "<openssl/$1>";
+                $hincf = "<${hprefix}$1>";
         } else {
                 $hincf = "\"$hfile\"";
         }
 
         # If static we know the error code at compile time so use it
         # in error definitions.
 
         if ($static)
                 {
                 $pack_errcode = "ERR_LIB_${lib}";
                 $load_errcode = "0";
                 }
         else
                 {
                 $pack_errcode = "0";
                 $load_errcode = "ERR_LIB_${lib}";
                 }
 
 
         open (OUT,">$cfile") || die "Can't open $cfile for writing";
 
         print OUT <<"EOF";
 /* $cfile */
 /* ====================================================================
- * Copyright (c) 1999-2010 The OpenSSL Project.  All rights reserved.
+ * Copyright (c) 1999-2011 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:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer. 
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
@@ skipping 172 matching lines @@
         ERR_PUT_error(${lib}_lib_error_code,function,reason,file,line);
         }
 EOF
 
 }
 
         close OUT;
         undef %err_reason_strings;
 }
 
-if($debug && defined(%notrans)) {
+if($debug && %notrans) {
         print STDERR "The following function codes were not translated:\n";
         foreach(sort keys %notrans)
         {
                 print STDERR "$_\n";
         }
 }
 
 # Make a list of unreferenced function and reason codes
 
 foreach (keys %fcodes) {
@@ skipping 12 matching lines @@
         }
 }
 
 if($debug && defined(@runref) ) {
         print STDERR "The following reason codes were not referenced:\n";
         foreach(sort @runref)
         {
                 print STDERR "$_\n";
         }
 }
+
+if($errcount) {
+        print STDERR "There were errors, failing...\n\n";
+        exit $errcount;
+}
+