Fix util/perl/OpenSSL/Test.pm input variable overwrite
[openssl.git] / util / mkerr.pl
1 #! /usr/bin/env perl
2 # Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved.
3 #
4 # Licensed under the OpenSSL license (the "License").  You may not use
5 # this file except in compliance with the License.  You can obtain a copy
6 # in the file LICENSE in the source distribution or at
7 # https://www.openssl.org/source/license.html
8
9 use strict;
10 use warnings;
11
12 my $config       = "crypto/err/openssl.ec";
13 my $debug        = 0;
14 my $internal     = 0;
15 my $nowrite      = 0;
16 my $rebuild      = 0;
17 my $reindex      = 0;
18 my $static       = 0;
19 my $unref        = 0;
20 my %modules         = ();
21
22 my $errors       = 0;
23 my @t            = localtime();
24 my $YEAR         = $t[5] + 1900;
25
26 sub phase
27 {
28     my $text = uc(shift);
29     print STDERR "\n---\n$text\n" if $debug;
30 }
31
32 sub help
33 {
34     print STDERR <<"EOF";
35 mkerr.pl [options] [files...]
36
37 Options:
38
39     -conf FILE  Use the named config file FILE instead of the default.
40
41     -debug      Verbose output debugging on stderr.
42
43     -internal   Generate code that is to be built as part of OpenSSL itself.
44                 Also scans internal list of files.
45
46     -module M   Only useful with -internal!
47                 Only write files for library module M.  Whether files are
48                 actually written or not depends on other options, such as
49                 -rebuild.
50                 Note: this option is cumulative.  If not given at all, all
51                 internal modules will be considered.
52
53     -nowrite    Do not write the header/source files, even if changed.
54
55     -rebuild    Rebuild all header and C source files, even if there
56                 were no changes.
57
58     -reindex    Ignore previously assigned values (except for R records in
59                 the config file) and renumber everything starting at 100.
60
61     -static     Make the load/unload functions static.
62
63     -unref      List all unreferenced function and reason codes on stderr;
64                 implies -nowrite.
65
66     -help       Show this help text.
67
68     ...         Additional arguments are added to the file list to scan,
69                 if '-internal' was NOT specified on the command line.
70
71 EOF
72 }
73
74 while ( @ARGV ) {
75     my $arg = $ARGV[0];
76     last unless $arg =~ /-.*/;
77     $arg = $1 if $arg =~ /-(-.*)/;
78     if ( $arg eq "-conf" ) {
79         $config = $ARGV[1];
80         shift @ARGV;
81     } elsif ( $arg eq "-debug" ) {
82         $debug = 1;
83         $unref = 1;
84     } elsif ( $arg eq "-internal" ) {
85         $internal = 1;
86     } elsif ( $arg eq "-nowrite" ) {
87         $nowrite = 1;
88     } elsif ( $arg eq "-rebuild" ) {
89         $rebuild = 1;
90     } elsif ( $arg eq "-reindex" ) {
91         $reindex = 1;
92     } elsif ( $arg eq "-static" ) {
93         $static = 1;
94     } elsif ( $arg eq "-unref" ) {
95         $unref = 1;
96         $nowrite = 1;
97     } elsif ( $arg eq "-module" ) {
98         shift @ARGV;
99         $modules{uc $ARGV[0]} = 1;
100     } elsif ( $arg =~ /-*h(elp)?/ ) {
101         &help();
102         exit;
103     } elsif ( $arg =~ /-.*/ ) {
104         die "Unknown option $arg; use -h for help.\n";
105     }
106     shift @ARGV;
107 }
108
109 my @source;
110 if ( $internal ) {
111     die "Cannot mix -internal and -static\n" if $static;
112     die "Extra parameters given.\n" if @ARGV;
113     @source = ( glob('crypto/*.c'), glob('crypto/*/*.c'),
114                 glob('ssl/*.c'), glob('ssl/*/*.c') );
115 } else {
116     die "-module isn't useful without -internal\n" if scalar keys %modules > 0;
117     @source = @ARGV;
118 }
119
120 # Data parsed out of the config and state files.
121 my %hinc;       # lib -> header
122 my %libinc;     # header -> lib
123 my %cskip;      # error_file -> lib
124 my %errorfile;  # lib -> error file name
125 my %fmax;       # lib -> max assigned function code
126 my %rmax;       # lib -> max assigned reason code
127 my %fassigned;  # lib -> colon-separated list of assigned function codes
128 my %rassigned;  # lib -> colon-separated list of assigned reason codes
129 my %fnew;       # lib -> count of new function codes
130 my %rnew;       # lib -> count of new reason codes
131 my %rextra;     # "extra" reason code -> lib
132 my %rcodes;     # reason-name -> value
133 my %ftrans;     # old name -> #define-friendly name (all caps)
134 my %fcodes;     # function-name -> value
135 my $statefile;  # state file with assigned reason and function codes
136 my %strings;    # define -> text
137
138 # Read and parse the config file
139 open(IN, "$config") || die "Can't open config file $config, $!,";
140 while ( <IN> ) {
141     next if /^#/ || /^$/;
142     if ( /^L\s+(\S+)\s+(\S+)\s+(\S+)/ ) {
143         my $lib = $1;
144         my $hdr = $2;
145         my $err = $3;
146         $hinc{$lib}   = $hdr;
147         $libinc{$hdr} = $lib;
148         $cskip{$err}  = $lib;
149         next if $err eq 'NONE';
150         $errorfile{$lib} = $err;
151         $fmax{$lib}      = 100;
152         $rmax{$lib}      = 100;
153         $fassigned{$lib} = ":";
154         $rassigned{$lib} = ":";
155         $fnew{$lib}      = 0;
156         $rnew{$lib}      = 0;
157     } elsif ( /^R\s+(\S+)\s+(\S+)/ ) {
158         $rextra{$1} = $2;
159         $rcodes{$1} = $2;
160     } elsif ( /^S\s+(\S+)/ ) {
161         $statefile = $1;
162     } else {
163         die "Illegal config line $_\n";
164     }
165 }
166 close IN;
167
168 if ( ! $statefile ) {
169     $statefile = $config;
170     $statefile =~ s/.ec/.txt/;
171 }
172
173 # The statefile has all the previous assignments.
174 &phase("Reading state");
175 my $skippedstate = 0;
176 if ( ! $reindex && $statefile ) {
177     open(STATE, "<$statefile") || die "Can't open $statefile, $!";
178
179     # Scan function and reason codes and store them: keep a note of the
180     # maximum code used.
181     while ( <STATE> ) {
182         next if /^#/ || /^$/;
183         my $name;
184         my $code;
185         if ( /^(.+):(\d+):\\$/ ) {
186             $name = $1;
187             $code = $2;
188             my $next = <STATE>;
189             $next =~ s/^\s*(.*)\s*$/$1/;
190             die "Duplicate define $name" if exists $strings{$name};
191             $strings{$name} = $next;
192         } elsif ( /^(\S+):(\d+):(.*)$/ ) {
193             $name = $1;
194             $code = $2;
195             die "Duplicate define $name" if exists $strings{$name};
196             $strings{$name} = $3;
197         } else {
198             die "Bad line in $statefile:\n$_\n";
199         }
200         my $lib = $name;
201         $lib =~ s/^((?:OSSL_|OPENSSL_)?[^_]{2,}).*$/$1/;
202         $lib = "SSL" if $lib =~ /TLS/;
203         if ( !defined $errorfile{$lib} ) {
204             print "Skipping $_";
205             $skippedstate++;
206             next;
207         }
208         if ( $name =~ /^(?:OSSL_|OPENSSL_)?[A-Z0-9]{2,}_R_/ ) {
209             die "$lib reason code $code collision at $name\n"
210                 if $rassigned{$lib} =~ /:$code:/;
211             $rassigned{$lib} .= "$code:";
212             if ( !exists $rextra{$name} ) {
213                 $rmax{$lib} = $code if $code > $rmax{$lib};
214             }
215             $rcodes{$name} = $code;
216         } elsif ( $name =~ /^(?:OSSL_|OPENSSL_)?[A-Z0-9]{2,}_F_/ ) {
217             die "$lib function code $code collision at $name\n"
218                 if $fassigned{$lib} =~ /:$code:/;
219             $fassigned{$lib} .= "$code:";
220             $fmax{$lib} = $code if $code > $fmax{$lib};
221             $fcodes{$name} = $code;
222         } else {
223             die "Bad line in $statefile:\n$_\n";
224         }
225     }
226     close(STATE);
227
228     if ( $debug ) {
229         foreach my $lib ( sort keys %rmax ) {
230             print STDERR "Reason codes for ${lib}:\n";
231             if ( $rassigned{$lib} =~ m/^:(.*):$/ ) {
232                 my @rassigned = sort { $a <=> $b } split( ":", $1 );
233                 print STDERR "  ", join(' ', @rassigned), "\n";
234             } else {
235                 print STDERR "  --none--\n";
236             }
237         }
238         print STDERR "\n";
239         foreach my $lib ( sort keys %fmax ) {
240             print STDERR "Function codes for ${lib}:\n";
241             if ( $fassigned{$lib} =~ m/^:(.*):$/ ) {
242                 my @fassigned = sort { $a <=> $b } split( ":", $1 );
243                 print STDERR "  ", join(' ', @fassigned), "\n";
244             } else {
245                 print STDERR "  --none--\n";
246             }
247         }
248     }
249 }
250
251 # Scan each header file and make a list of error codes
252 # and function names
253 &phase("Scanning headers");
254 while ( ( my $hdr, my $lib ) = each %libinc ) {
255     next if $hdr eq "NONE";
256     print STDERR " ." if $debug;
257     my $line = "";
258     my $def = "";
259     my $linenr = 0;
260     my $cpp = 0;
261
262     open(IN, "<$hdr") || die "Can't open $hdr, $!,";
263     while ( <IN> ) {
264         $linenr++;
265
266         if ( $line ne '' ) {
267             $_    = $line . $_;
268             $line = '';
269         }
270
271         if ( /\\$/ ) {
272             $line = $_;
273             next;
274         }
275
276         if ( /\/\*/ ) {
277             if ( not /\*\// ) {    # multiline comment...
278                 $line = $_;        # ... just accumulate
279                 next;
280             } else {
281                 s/\/\*.*?\*\///gs;    # wipe it
282             }
283         }
284
285         if ( $cpp ) {
286             $cpp++ if /^#\s*if/;
287             $cpp-- if /^#\s*endif/;
288             next;
289         }
290         $cpp = 1 if /^#.*ifdef.*cplusplus/;    # skip "C" declaration
291
292         next if /^\#/;    # skip preprocessor directives
293
294         s/{[^{}]*}//gs;     # ignore {} blocks
295
296         if ( /\{|\/\*/ ) {    # Add a so editor works...
297             $line = $_;
298         } else {
299             $def .= $_;
300         }
301     }
302
303     # Delete any DECLARE_ macros
304     my $defnr = 0;
305     $def =~ s/DECLARE_\w+\([\w,\s]+\)//gs;
306     foreach ( split /;/, $def ) {
307         $defnr++;
308         # The goal is to collect function names from function declarations.
309
310         s/^[\n\s]*//g;
311         s/[\n\s]*$//g;
312
313         # Skip over recognized non-function declarations
314         next if /typedef\W/ or /DECLARE_STACK_OF/ or /TYPEDEF_.*_OF/;
315
316         # Remove STACK_OF(foo)
317         s/STACK_OF\(\w+\)/void/;
318
319         # Reduce argument lists to empty ()
320         # fold round brackets recursively: (t(*v)(t),t) -> (t{}{},t) -> {}
321         while ( /\(.*\)/s ) {
322             s/\([^\(\)]+\)/\{\}/gs;
323             s/\(\s*\*\s*(\w+)\s*\{\}\s*\)/$1/gs;    #(*f{}) -> f
324         }
325
326         # pretend as we didn't use curly braces: {} -> ()
327         s/\{\}/\(\)/gs;
328
329         # Last token just before the first () is a function name.
330         if ( /(\w+)\s*\(\).*/s ) {
331             my $name = $1;
332             $name =~ tr/[a-z]/[A-Z]/;
333             $ftrans{$name} = $1;
334         } elsif ( /[\(\)]/ and not(/=/) ) {
335             print STDERR "Header $hdr: cannot parse: $_;\n";
336         }
337     }
338
339     next if $reindex;
340
341     if ( $lib eq "SSL" && $rmax{$lib} >= 1000 ) {
342         print STDERR "SSL error codes 1000+ are reserved for alerts.\n";
343         print STDERR "Any new alerts must be added to $config.\n";
344         $errors++;
345     }
346     close IN;
347 }
348 print STDERR "\n" if $debug;
349
350 # Scan each C source file and look for function and reason codes
351 # This is done by looking for strings that "look like" function or
352 # reason codes: basically anything consisting of all upper case and
353 # numerics which has _F_ or _R_ in it and which has the name of an
354 # error library at the start.  This seems to work fine except for the
355 # oddly named structure BIO_F_CTX which needs to be ignored.
356 # If a code doesn't exist in list compiled from headers then mark it
357 # with the value "X" as a place holder to give it a value later.
358 # Store all function and reason codes found in %usedfuncs and %usedreasons
359 # so all those unreferenced can be printed out.
360 &phase("Scanning source");
361 my %usedfuncs;
362 my %usedreasons;
363 foreach my $file ( @source ) {
364     # Don't parse the error source file.
365     next if exists $cskip{$file};
366     open( IN, "<$file" ) || die "Can't open $file, $!,";
367     my $func;
368     my $linenr = 0;
369     print STDERR "$file:\n" if $debug;
370     while ( <IN> ) {
371
372         # skip obsoleted source files entirely!
373         last if /^#error\s+obsolete/;
374         $linenr++;
375         if ( !/;$/ && /^\**([a-zA-Z_].*[\s*])?([A-Za-z_0-9]+)\(.*([),]|$)/ ) {
376             /^([^()]*(\([^()]*\)[^()]*)*)\(/;
377             $1 =~ /([A-Za-z_0-9]*)$/;
378             $func = $1;
379         }
380
381         if ( /(((?:OSSL_|OPENSSL_)?[A-Z0-9]{2,})_F_([A-Z0-9_]+))/ ) {
382             next unless exists $errorfile{$2};
383             next if $1 eq "BIO_F_BUFFER_CTX";
384             $usedfuncs{$1} = 1;
385             if ( !exists $fcodes{$1} ) {
386                 print STDERR "  New function $1\n" if $debug;
387                 $fcodes{$1} = "X";
388                 $fnew{$2}++;
389             }
390             $ftrans{$3} = $func unless exists $ftrans{$3};
391             if ( uc($func) ne $3 ) {
392                 print STDERR "ERROR: mismatch $file:$linenr $func:$3\n";
393                 $errors++;
394             }
395             print STDERR "  Function $1 = $fcodes{$1}\n"
396               if $debug;
397         }
398         if ( /(((?:OSSL_|OPENSSL_)?[A-Z0-9]{2,})_R_[A-Z0-9_]+)/ ) {
399             next unless exists $errorfile{$2};
400             $usedreasons{$1} = 1;
401             if ( !exists $rcodes{$1} ) {
402                 print STDERR "  New reason $1\n" if $debug;
403                 $rcodes{$1} = "X";
404                 $rnew{$2}++;
405             }
406             print STDERR "  Reason $1 = $rcodes{$1}\n" if $debug;
407         }
408     }
409     close IN;
410 }
411 print STDERR "\n" if $debug;
412
413 # Now process each library in turn.
414 &phase("Writing files");
415 my $newstate = 0;
416 foreach my $lib ( keys %errorfile ) {
417     if ( ! $fnew{$lib} && ! $rnew{$lib} ) {
418         next unless $rebuild;
419     }
420     next if scalar keys %modules > 0 && !$modules{$lib};
421     next if $nowrite;
422     print STDERR "$lib: $fnew{$lib} new functions\n" if $fnew{$lib};
423     print STDERR "$lib: $rnew{$lib} new reasons\n" if $rnew{$lib};
424     $newstate = 1;
425
426     # If we get here then we have some new error codes so we
427     # need to rebuild the header file and C file.
428
429     # Make a sorted list of error and reason codes for later use.
430     my @function = sort grep( /^${lib}_/, keys %fcodes );
431     my @reasons  = sort grep( /^${lib}_/, keys %rcodes );
432
433     # Rewrite the header file
434
435     my $hfile = $hinc{$lib};
436     $hfile =~ s/.h$/err.h/ if $internal;
437     open( OUT, ">$hfile" ) || die "Can't write to $hfile, $!,";
438     print OUT <<"EOF";
439 /*
440  * Generated by util/mkerr.pl DO NOT EDIT
441  * Copyright 1995-$YEAR The OpenSSL Project Authors. All Rights Reserved.
442  *
443  * Licensed under the OpenSSL license (the \"License\").  You may not use
444  * this file except in compliance with the License.  You can obtain a copy
445  * in the file LICENSE in the source distribution or at
446  * https://www.openssl.org/source/license.html
447  */
448
449 #ifndef HEADER_${lib}ERR_H
450 # define HEADER_${lib}ERR_H
451
452 EOF
453     if ( $internal ) {
454         # Declare the load function because the generate C file
455         # includes "fooerr.h" not "foo.h"
456         print OUT <<"EOF";
457 # ifdef  __cplusplus
458 extern \"C\" {
459 # endif
460 int ERR_load_${lib}_strings(void);
461 # ifdef  __cplusplus
462 }
463 # endif
464 EOF
465     } else {
466         print OUT <<"EOF";
467 # define ${lib}err(f, r) ERR_${lib}_error((f), (r), OPENSSL_FILE, OPENSSL_LINE)
468
469 EOF
470         if ( ! $static ) {
471             print OUT <<"EOF";
472
473 # ifdef  __cplusplus
474 extern \"C\" {
475 # endif
476 int ERR_load_${lib}_strings(void);
477 void ERR_unload_${lib}_strings(void);
478 void ERR_${lib}_error(int function, int reason, char *file, int line);
479 # ifdef  __cplusplus
480 }
481 # endif
482 EOF
483         }
484     }
485
486     print OUT "\n/*\n * $lib function codes.\n */\n";
487     foreach my $i ( @function ) {
488         my $z = 48 - length($i);
489         $z = 0 if $z < 0;
490         if ( $fcodes{$i} eq "X" ) {
491             $fassigned{$lib} =~ m/^:([^:]*):/;
492             my $findcode = $1;
493             $findcode = $fmax{$lib} if !defined $findcode;
494             while ( $fassigned{$lib} =~ m/:$findcode:/ ) {
495                 $findcode++;
496             }
497             $fcodes{$i} = $findcode;
498             $fassigned{$lib} .= "$findcode:";
499             print STDERR "New Function code $i\n" if $debug;
500         }
501         printf OUT "# define $i%s $fcodes{$i}\n", " " x $z;
502     }
503
504     print OUT "\n/*\n * $lib reason codes.\n */\n";
505     foreach my $i ( @reasons ) {
506         my $z = 48 - length($i);
507         $z = 0 if $z < 0;
508         if ( $rcodes{$i} eq "X" ) {
509             $rassigned{$lib} =~ m/^:([^:]*):/;
510             my $findcode = $1;
511             $findcode = $rmax{$lib} if !defined $findcode;
512             while ( $rassigned{$lib} =~ m/:$findcode:/ ) {
513                 $findcode++;
514             }
515             $rcodes{$i} = $findcode;
516             $rassigned{$lib} .= "$findcode:";
517             print STDERR "New Reason code $i\n" if $debug;
518         }
519         printf OUT "# define $i%s $rcodes{$i}\n", " " x $z;
520     }
521     print OUT "\n";
522
523     print OUT "#endif\n";
524
525     # Rewrite the C source file containing the error details.
526
527     # First, read any existing reason string definitions:
528     my $cfile = $errorfile{$lib};
529     my $pack_lib = $internal ? "ERR_LIB_${lib}" : "0";
530     my $hincf = $hfile;
531     $hincf =~ s|.*include/||;
532     if ( $hincf =~ m|^openssl/| ) {
533         $hincf = "<${hincf}>";
534     } else {
535         $hincf = "\"${hincf}\"";
536     }
537
538     open( OUT, ">$cfile" )
539         || die "Can't open $cfile for writing, $!, stopped";
540
541     my $const = $internal ? 'const ' : '';
542
543     print OUT <<"EOF";
544 /*
545  * Generated by util/mkerr.pl DO NOT EDIT
546  * Copyright 1995-$YEAR The OpenSSL Project Authors. All Rights Reserved.
547  *
548  * Licensed under the OpenSSL license (the "License").  You may not use
549  * this file except in compliance with the License.  You can obtain a copy
550  * in the file LICENSE in the source distribution or at
551  * https://www.openssl.org/source/license.html
552  */
553
554 #include <openssl/err.h>
555 #include $hincf
556
557 #ifndef OPENSSL_NO_ERR
558
559 static ${const}ERR_STRING_DATA ${lib}_str_functs[] = {
560 EOF
561
562     # Add each function code: if a function name is found then use it.
563     foreach my $i ( @function ) {
564         my $fn;
565         if ( exists $strings{$i} and $strings{$i} ne '' ) {
566             $fn = $strings{$i};
567             $fn = "" if $fn eq '*';
568         } else {
569             $i =~ /^${lib}_F_(\S+)$/;
570             $fn = $1;
571             $fn = $ftrans{$fn} if exists $ftrans{$fn};
572             $strings{$i} = $fn;
573         }
574         my $short = "    {ERR_PACK($pack_lib, $i, 0), \"$fn\"},";
575         if ( length($short) <= 80 ) {
576             print OUT "$short\n";
577         } else {
578             print OUT "    {ERR_PACK($pack_lib, $i, 0),\n     \"$fn\"},\n";
579         }
580     }
581     print OUT <<"EOF";
582     {0, NULL}
583 };
584
585 static ${const}ERR_STRING_DATA ${lib}_str_reasons[] = {
586 EOF
587
588     # Add each reason code.
589     foreach my $i ( @reasons ) {
590         my $rn;
591         if ( exists $strings{$i} ) {
592             $rn = $strings{$i};
593             $rn = "" if $rn eq '*';
594         } else {
595             $i =~ /^${lib}_R_(\S+)$/;
596             $rn = $1;
597             $rn =~ tr/_[A-Z]/ [a-z]/;
598             $strings{$i} = $rn;
599         }
600         my $short = "    {ERR_PACK($pack_lib, 0, $i), \"$rn\"},";
601         if ( length($short) <= 80 ) {
602             print OUT "$short\n";
603         } else {
604             print OUT "    {ERR_PACK($pack_lib, 0, $i),\n    \"$rn\"},\n";
605         }
606     }
607     print OUT <<"EOF";
608     {0, NULL}
609 };
610
611 #endif
612 EOF
613     if ( $internal ) {
614         print OUT <<"EOF";
615
616 int ERR_load_${lib}_strings(void)
617 {
618 #ifndef OPENSSL_NO_ERR
619     if (ERR_func_error_string(${lib}_str_functs[0].error) == NULL) {
620         ERR_load_strings_const(${lib}_str_functs);
621         ERR_load_strings_const(${lib}_str_reasons);
622     }
623 #endif
624     return 1;
625 }
626 EOF
627     } else {
628         my $st = $static ? "static " : "";
629         print OUT <<"EOF";
630
631 static int lib_code = 0;
632 static int error_loaded = 0;
633
634 ${st}int ERR_load_${lib}_strings(void)
635 {
636     if (lib_code == 0)
637         lib_code = ERR_get_next_error_library();
638
639     if (!error_loaded) {
640 #ifndef OPENSSL_NO_ERR
641         ERR_load_strings(lib_code, ${lib}_str_functs);
642         ERR_load_strings(lib_code, ${lib}_str_reasons);
643 #endif
644         error_loaded = 1;
645     }
646     return 1;
647 }
648
649 ${st}void ERR_unload_${lib}_strings(void)
650 {
651     if (error_loaded) {
652 #ifndef OPENSSL_NO_ERR
653         ERR_unload_strings(lib_code, ${lib}_str_functs);
654         ERR_unload_strings(lib_code, ${lib}_str_reasons);
655 #endif
656         error_loaded = 0;
657     }
658 }
659
660 ${st}void ERR_${lib}_error(int function, int reason, char *file, int line)
661 {
662     if (lib_code == 0)
663         lib_code = ERR_get_next_error_library();
664     ERR_PUT_error(lib_code, function, reason, file, line);
665 }
666 EOF
667
668     }
669
670     close OUT;
671 }
672
673 &phase("Ending");
674 # Make a list of unreferenced function and reason codes
675 if ( $unref ) {
676     my @funref;
677     foreach ( keys %fcodes ) {
678         push( @funref, $_ ) unless exists $usedfuncs{$_};
679     }
680     my @runref;
681     foreach ( keys %rcodes ) {
682         push( @runref, $_ ) unless exists $usedreasons{$_};
683     }
684     if ( @funref ) {
685         print STDERR "The following function codes were not referenced:\n";
686         foreach ( sort @funref ) {
687             print STDERR "  $_\n";
688         }
689     }
690     if ( @runref ) {
691         print STDERR "The following reason codes were not referenced:\n";
692         foreach ( sort @runref ) {
693             print STDERR "  $_\n";
694         }
695     }
696 }
697
698 die "Found $errors errors, quitting" if $errors;
699
700 # Update the state file
701 if ( $newstate )  {
702     open(OUT, ">$statefile.new")
703         || die "Can't write $statefile.new, $!";
704     print OUT <<"EOF";
705 # Copyright 1999-2017 The OpenSSL Project Authors. All Rights Reserved.
706 #
707 # Licensed under the OpenSSL license (the "License").  You may not use
708 # this file except in compliance with the License.  You can obtain a copy
709 # in the file LICENSE in the source distribution or at
710 # https://www.openssl.org/source/license.html
711 EOF
712     print OUT "\n# Function codes\n";
713     foreach my $i ( sort keys %fcodes ) {
714         my $short = "$i:$fcodes{$i}:";
715         my $t = exists $strings{$i} ? $strings{$i} : "";
716         $t = "\\\n\t" . $t if length($short) + length($t) > 80;
717         print OUT "$short$t\n";
718     }
719     print OUT "\n#Reason codes\n";
720     foreach my $i ( sort keys %rcodes ) {
721         my $short = "$i:$rcodes{$i}:";
722         my $t = exists $strings{$i} ? "$strings{$i}" : "";
723         $t = "\\\n\t" . $t if length($short) + length($t) > 80;
724         print OUT "$short$t\n" if !exists $rextra{$i};
725     }
726     close(OUT);
727     if ( $skippedstate ) {
728         print "Skipped state, leaving update in $statefile.new";
729     } else {
730         rename "$statefile", "$statefile.old"
731             || die "Can't backup $statefile to $statefile.old, $!";
732         rename "$statefile.new", "$statefile"
733             || die "Can't rename $statefile to $statefile.new, $!";
734     }
735 }
736
737 exit;