]>
git.ipfire.org Git - thirdparty/openssl.git/blob - util/mkerr.pl
2 # Copyright 1999-2018 The OpenSSL Project Authors. All Rights Reserved.
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
15 my $config = "crypto/err/openssl.ec";
27 my $YEAR = $t[5] + 1900;
32 print STDERR
"\n---\n$text\n" if $debug;
38 mkerr.pl [options] [files...]
42 -conf FILE Use the named config file FILE instead of the default.
44 -debug Verbose output debugging on stderr.
46 -internal Generate code that is to be built as part of OpenSSL itself.
47 Also scans internal list of files.
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
53 Note: this option is cumulative. If not given at all, all
54 internal modules will be considered.
56 -nowrite Do not write the header/source files, even if changed.
58 -rebuild Rebuild all header and C source files, even if there
61 -reindex Ignore previously assigned values (except for R records in
62 the config file) and renumber everything starting at 100.
64 -static Make the load/unload functions static.
66 -unref List all unreferenced function and reason codes on stderr;
69 -help Show this help text.
71 ... Additional arguments are added to the file list to scan,
72 if '-internal' was NOT specified on the command line.
79 last unless $arg =~ /-.*/;
80 $arg = $1 if $arg =~ /-(-.*)/;
81 if ( $arg eq "-conf" ) {
84 } elsif ( $arg eq "-debug" ) {
87 } elsif ( $arg eq "-internal" ) {
89 } elsif ( $arg eq "-nowrite" ) {
91 } elsif ( $arg eq "-rebuild" ) {
93 } elsif ( $arg eq "-reindex" ) {
95 } elsif ( $arg eq "-static" ) {
97 } elsif ( $arg eq "-unref" ) {
100 } elsif ( $arg eq "-module" ) {
102 $modules{uc $ARGV[0]} = 1;
103 } elsif ( $arg =~ /-*h(elp)?/ ) {
106 } elsif ( $arg =~ /-.*/ ) {
107 die "Unknown option $arg; use -h for help.\n";
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') );
120 die "-module isn't useful without -internal\n" if scalar keys %modules > 0;
124 # Data parsed out of the config and state files.
125 my %hinc; # lib -> header
126 my %libinc; # header -> lib
127 my %cskip; # error_file -> lib
128 my %errorfile; # lib -> error file name
129 my %fmax; # lib -> max assigned function code
130 my %rmax; # lib -> max assigned reason code
131 my %fassigned; # lib -> colon-separated list of assigned function codes
132 my %rassigned; # lib -> colon-separated list of assigned reason codes
133 my %fnew; # lib -> count of new function codes
134 my %rnew; # lib -> count of new reason codes
135 my %rextra; # "extra" reason code -> lib
136 my %rcodes; # reason-name -> value
137 my %ftrans; # old name -> #define-friendly name (all caps)
138 my %fcodes; # function-name -> value
139 my $statefile; # state file with assigned reason and function codes
140 my %strings; # define -> text
142 # Read and parse the config file
143 open(IN
, "$config") || die "Can't open config file $config, $!,";
145 next if /^#/ || /^$/;
146 if ( /^L\s+(\S+)\s+(\S+)\s+(\S+)/ ) {
151 $libinc{$hdr} = $lib;
153 next if $err eq 'NONE';
154 $errorfile{$lib} = $err;
157 $fassigned{$lib} = ":";
158 $rassigned{$lib} = ":";
161 } elsif ( /^R\s+(\S+)\s+(\S+)/ ) {
164 } elsif ( /^S\s+(\S+)/ ) {
167 die "Illegal config line $_\n";
172 if ( ! $statefile ) {
173 $statefile = $config;
174 $statefile =~ s/.ec/.txt/;
177 # The statefile has all the previous assignments.
178 &phase
("Reading state");
179 my $skippedstate = 0;
180 if ( ! $reindex && $statefile ) {
181 open(STATE
, "<$statefile") || die "Can't open $statefile, $!";
183 # Scan function and reason codes and store them: keep a note of the
186 next if /^#/ || /^$/;
189 if ( /^(.+):(\d+):\\$/ ) {
193 $next =~ s/^\s*(.*)\s*$/$1/;
194 die "Duplicate define $name" if exists $strings{$name};
195 $strings{$name} = $next;
196 } elsif ( /^(\S+):(\d+):(.*)$/ ) {
199 die "Duplicate define $name" if exists $strings{$name};
200 $strings{$name} = $3;
202 die "Bad line in $statefile:\n$_\n";
205 $lib =~ s/^((?:OSSL_|OPENSSL_)?[^_]{2,}).*$/$1/;
206 $lib = "SSL" if $lib =~ /TLS/;
207 if ( !defined $errorfile{$lib} ) {
212 if ( $name =~ /^(?:OSSL_|OPENSSL_)?[A-Z0-9]{2,}_R_/ ) {
213 die "$lib reason code $code collision at $name\n"
214 if $rassigned{$lib} =~ /:$code:/;
215 $rassigned{$lib} .= "$code:";
216 if ( !exists $rextra{$name} ) {
217 $rmax{$lib} = $code if $code > $rmax{$lib};
219 $rcodes{$name} = $code;
220 } elsif ( $name =~ /^(?:OSSL_|OPENSSL_)?[A-Z0-9]{2,}_F_/ ) {
221 die "$lib function code $code collision at $name\n"
222 if $fassigned{$lib} =~ /:$code:/;
223 $fassigned{$lib} .= "$code:";
224 $fmax{$lib} = $code if $code > $fmax{$lib};
225 $fcodes{$name} = $code;
227 die "Bad line in $statefile:\n$_\n";
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";
239 print STDERR
" --none--\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";
249 print STDERR
" --none--\n";
255 # Scan each header file and make a list of error codes
257 &phase
("Scanning headers");
258 while ( ( my $hdr, my $lib ) = each %libinc ) {
259 next if $hdr eq "NONE";
260 print STDERR
" ." if $debug;
266 open(IN
, "<$hdr") || die "Can't open $hdr, $!,";
281 if ( not /\*\// ) { # multiline comment...
282 $line = $_; # ... just accumulate
285 s/\/\*.*?\*\///gs; # wipe it
291 $cpp-- if /^#\s*endif/;
294 $cpp = 1 if /^#.*ifdef.*cplusplus/; # skip "C" declaration
296 next if /^\#/; # skip preprocessor directives
298 s/{[^{}]*}//gs; # ignore {} blocks
300 if ( /\{|\/\
*/ ) { # Add a so editor works...
307 # Delete any DECLARE_ macros
309 $def =~ s/DECLARE_\w+\([\w,\s]+\)//gs;
310 foreach ( split /;/, $def ) {
312 # The goal is to collect function names from function declarations.
317 # Skip over recognized non-function declarations
318 next if /typedef\W/ or /DECLARE_STACK_OF/ or /TYPEDEF_.*_OF/;
320 # Remove STACK_OF(foo)
321 s/STACK_OF\(\w+\)/void/;
323 # Reduce argument lists to empty ()
324 # fold round brackets recursively: (t(*v)(t),t) -> (t{}{},t) -> {}
325 while ( /\(.*\)/s ) {
326 s/\([^\(\)]+\)/\{\}/gs;
327 s/\(\s*\*\s*(\w+)\s*\{\}\s*\)/$1/gs; #(*f{}) -> f
330 # pretend as we didn't use curly braces: {} -> ()
333 # Last token just before the first () is a function name.
334 if ( /(\w+)\s*\(\).*/s ) {
336 $name =~ tr/[a-z]/[A-Z]/;
338 } elsif ( /[\(\)]/ and not(/=/) ) {
339 print STDERR
"Header $hdr: cannot parse: $_;\n";
345 if ( $lib eq "SSL" && $rmax{$lib} >= 1000 ) {
346 print STDERR
"SSL error codes 1000+ are reserved for alerts.\n";
347 print STDERR
"Any new alerts must be added to $config.\n";
352 print STDERR
"\n" if $debug;
354 # Scan each C source file and look for function and reason codes
355 # This is done by looking for strings that "look like" function or
356 # reason codes: basically anything consisting of all upper case and
357 # numerics which has _F_ or _R_ in it and which has the name of an
358 # error library at the start. This seems to work fine except for the
359 # oddly named structure BIO_F_CTX which needs to be ignored.
360 # If a code doesn't exist in list compiled from headers then mark it
361 # with the value "X" as a place holder to give it a value later.
362 # Store all function and reason codes found in %usedfuncs and %usedreasons
363 # so all those unreferenced can be printed out.
364 &phase
("Scanning source");
367 foreach my $file ( @source ) {
368 # Don't parse the error source file.
369 next if exists $cskip{$file};
370 open( IN
, "<$file" ) || die "Can't open $file, $!,";
373 print STDERR
"$file:\n" if $debug;
376 # skip obsoleted source files entirely!
377 last if /^#error\s+obsolete/;
379 if ( !/;$/ && /^\**([a-zA-Z_].*[\s*])?([A-Za-z_0-9]+)\(.*([),]|$)/ ) {
380 /^([^()]*(\([^()]*\)[^()]*)*)\(/;
381 $1 =~ /([A-Za-z_0-9]*)$/;
385 if ( /(((?:OSSL_|OPENSSL_)?[A-Z0-9]{2,})_F_([A-Z0-9_]+))/ ) {
386 next unless exists $errorfile{$2};
387 next if $1 eq "BIO_F_BUFFER_CTX";
389 if ( !exists $fcodes{$1} ) {
390 print STDERR
" New function $1\n" if $debug;
394 $ftrans{$3} = $func unless exists $ftrans{$3};
395 if ( uc($func) ne $3 ) {
396 print STDERR
"ERROR: mismatch $file:$linenr $func:$3\n";
399 print STDERR
" Function $1 = $fcodes{$1}\n"
402 if ( /(((?:OSSL_|OPENSSL_)?[A-Z0-9]{2,})_R_[A-Z0-9_]+)/ ) {
403 next unless exists $errorfile{$2};
404 $usedreasons{$1} = 1;
405 if ( !exists $rcodes{$1} ) {
406 print STDERR
" New reason $1\n" if $debug;
410 print STDERR
" Reason $1 = $rcodes{$1}\n" if $debug;
415 print STDERR
"\n" if $debug;
417 # Now process each library in turn.
418 &phase
("Writing files");
420 foreach my $lib ( keys %errorfile ) {
421 next if ! $fnew{$lib} && ! $rnew{$lib} && ! $rebuild;
422 next if scalar keys %modules > 0 && !$modules{$lib};
424 print STDERR
"$lib: $fnew{$lib} new functions\n" if $fnew{$lib};
425 print STDERR
"$lib: $rnew{$lib} new reasons\n" if $rnew{$lib};
428 # If we get here then we have some new error codes so we
429 # need to rebuild the header file and C file.
431 # Make a sorted list of error and reason codes for later use.
432 my @function = sort grep( /^${lib}_/, keys %fcodes );
433 my @reasons = sort grep( /^${lib}_/, keys %rcodes );
435 # indent level for innermost preprocessor lines
438 # Rewrite the header file
440 my $hfile = $hinc{$lib};
441 $hfile =~ s/.h$/err.h/ if $internal;
442 open( OUT
, ">$hfile" ) || die "Can't write to $hfile, $!,";
445 * Generated by util/mkerr.pl DO NOT EDIT
446 * Copyright 1995-$YEAR The OpenSSL Project Authors. All Rights Reserved.
448 * Licensed under the Apache License 2.0 (the \"License\"). You may not use
449 * this file except in compliance with the License. You can obtain a copy
450 * in the file LICENSE in the source distribution or at
451 * https://www.openssl.org/source/license.html
454 #ifndef HEADER_${lib}ERR_H
455 # define HEADER_${lib}ERR_H
457 # ifndef HEADER_SYMHACKS_H
458 # include <openssl/symhacks.h>
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)) {
468 # include <openssl/opensslconf.h>
470 # ifndef OPENSSL_NO_${lib}
476 #${indent}ifdef __cplusplus
479 int ERR_load_${lib}_strings(void);
483 # define ${lib}err(f, r) ERR_${lib}_error((f), (r), OPENSSL_FILE, OPENSSL_LINE)
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);
502 print OUT
"\n/*\n * $lib function codes.\n */\n";
503 foreach my $i ( @function ) {
504 my $z = 48 - length($i);
506 if ( $fcodes{$i} eq "X" ) {
507 $fassigned{$lib} =~ m/^:([^:]*):/;
509 $findcode = $fmax{$lib} if !defined $findcode;
510 while ( $fassigned{$lib} =~ m/:$findcode:/ ) {
513 $fcodes{$i} = $findcode;
514 $fassigned{$lib} .= "$findcode:";
515 print STDERR
"New Function code $i\n" if $debug;
517 printf OUT
"#${indent}define $i%s $fcodes{$i}\n", " " x
$z;
520 print OUT
"\n/*\n * $lib reason codes.\n */\n";
521 foreach my $i ( @reasons ) {
522 my $z = 48 - length($i);
524 if ( $rcodes{$i} eq "X" ) {
525 $rassigned{$lib} =~ m/^:([^:]*):/;
527 $findcode = $rmax{$lib} if !defined $findcode;
528 while ( $rassigned{$lib} =~ m/:$findcode:/ ) {
531 $rcodes{$i} = $findcode;
532 $rassigned{$lib} .= "$findcode:";
533 print STDERR
"New Reason code $i\n" if $debug;
535 printf OUT
"#${indent}define $i%s $rcodes{$i}\n", " " x
$z;
539 while (length($indent) > 0) {
540 $indent = substr $indent, 0, -1;
541 print OUT
"#${indent}endif\n";
544 # Rewrite the C source file containing the error details.
546 # First, read any existing reason string definitions:
547 my $cfile = $errorfile{$lib};
548 my $pack_lib = $internal ?
"ERR_LIB_${lib}" : "0";
550 $hincf =~ s
|.*include
/||;
551 if ( $hincf =~ m
|^openssl
/| ) {
552 $hincf = "<${hincf}>";
554 $hincf = "\"${hincf}\"";
557 open( OUT
, ">$cfile" )
558 || die "Can't open $cfile for writing, $!, stopped";
560 my $const = $internal ?
'const ' : '';
564 * Generated by util/mkerr.pl DO NOT EDIT
565 * Copyright 1995-$YEAR The OpenSSL Project Authors. All Rights Reserved.
567 * Licensed under the Apache License 2.0 (the "License"). You may not use
568 * this file except in compliance with the License. You can obtain a copy
569 * in the file LICENSE in the source distribution or at
570 * https://www.openssl.org/source/license.html
573 #include <openssl/err.h>
576 #ifndef OPENSSL_NO_ERR
578 static ${const}ERR_STRING_DATA ${lib}_str_functs[] = {
581 # Add each function code: if a function name is found then use it.
582 foreach my $i ( @function ) {
584 if ( exists $strings{$i} and $strings{$i} ne '' ) {
586 $fn = "" if $fn eq '*';
588 $i =~ /^${lib}_F_(\S+)$/;
590 $fn = $ftrans{$fn} if exists $ftrans{$fn};
593 my $short = " {ERR_PACK($pack_lib, $i, 0), \"$fn\"},";
594 if ( length($short) <= 80 ) {
595 print OUT
"$short\n";
597 print OUT
" {ERR_PACK($pack_lib, $i, 0),\n \"$fn\"},\n";
604 static ${const}ERR_STRING_DATA ${lib}_str_reasons[] = {
607 # Add each reason code.
608 foreach my $i ( @reasons ) {
610 if ( exists $strings{$i} ) {
612 $rn = "" if $rn eq '*';
614 $i =~ /^${lib}_R_(\S+)$/;
616 $rn =~ tr/_[A-Z]/ [a-z]/;
619 my $short = " {ERR_PACK($pack_lib, 0, $i), \"$rn\"},";
620 if ( length($short) <= 80 ) {
621 print OUT
"$short\n";
623 print OUT
" {ERR_PACK($pack_lib, 0, $i),\n \"$rn\"},\n";
635 int ERR_load_${lib}_strings(void)
637 #ifndef OPENSSL_NO_ERR
638 if (ERR_func_error_string(${lib}_str_functs[0].error) == NULL) {
639 ERR_load_strings_const(${lib}_str_functs);
640 ERR_load_strings_const(${lib}_str_reasons);
647 my $st = $static ?
"static " : "";
650 static int lib_code = 0;
651 static int error_loaded = 0;
653 ${st}int ERR_load_${lib}_strings(void)
656 lib_code = ERR_get_next_error_library();
659 #ifndef OPENSSL_NO_ERR
660 ERR_load_strings(lib_code, ${lib}_str_functs);
661 ERR_load_strings(lib_code, ${lib}_str_reasons);
668 ${st}void ERR_unload_${lib}_strings(void)
671 #ifndef OPENSSL_NO_ERR
672 ERR_unload_strings(lib_code, ${lib}_str_functs);
673 ERR_unload_strings(lib_code, ${lib}_str_reasons);
679 ${st}void ERR_${lib}_error(int function, int reason, char *file, int line)
682 lib_code = ERR_get_next_error_library();
683 ERR_PUT_error(lib_code, function, reason, file, line);
693 # Make a list of unreferenced function and reason codes
696 foreach ( keys %fcodes ) {
697 push( @funref, $_ ) unless exists $usedfuncs{$_};
700 foreach ( keys %rcodes ) {
701 push( @runref, $_ ) unless exists $usedreasons{$_};
704 print STDERR
"The following function codes were not referenced:\n";
705 foreach ( sort @funref ) {
706 print STDERR
" $_\n";
710 print STDERR
"The following reason codes were not referenced:\n";
711 foreach ( sort @runref ) {
712 print STDERR
" $_\n";
717 die "Found $errors errors, quitting" if $errors;
719 # Update the state file
721 open(OUT
, ">$statefile.new")
722 || die "Can't write $statefile.new, $!";
724 # Copyright 1999-$YEAR The OpenSSL Project Authors. All Rights Reserved.
726 # Licensed under the Apache License 2.0 (the "License"). You may not use
727 # this file except in compliance with the License. You can obtain a copy
728 # in the file LICENSE in the source distribution or at
729 # https://www.openssl.org/source/license.html
731 print OUT
"\n# Function codes\n";
732 foreach my $i ( sort keys %fcodes ) {
733 my $short = "$i:$fcodes{$i}:";
734 my $t = exists $strings{$i} ?
$strings{$i} : "";
735 $t = "\\\n\t" . $t if length($short) + length($t) > 80;
736 print OUT
"$short$t\n";
738 print OUT
"\n#Reason codes\n";
739 foreach my $i ( sort keys %rcodes ) {
740 my $short = "$i:$rcodes{$i}:";
741 my $t = exists $strings{$i} ?
"$strings{$i}" : "";
742 $t = "\\\n\t" . $t if length($short) + length($t) > 80;
743 print OUT
"$short$t\n" if !exists $rextra{$i};
746 if ( $skippedstate ) {
747 print "Skipped state, leaving update in $statefile.new";
749 rename "$statefile", "$statefile.old"
750 || die "Can't backup $statefile to $statefile.old, $!";
751 rename "$statefile.new", "$statefile"
752 || die "Can't rename $statefile to $statefile.new, $!";