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