2 # Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved.
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
12 my $config = "crypto/err/openssl.ec";
24 my $YEAR = $t[5] + 1900;
29 print STDERR "\n---\n$text\n" if $debug;
35 mkerr.pl [options] [files...]
39 -conf FILE Use the named config file FILE instead of the default.
41 -debug Verbose output debugging on stderr.
43 -internal Generate code that is to be built as part of OpenSSL itself.
44 Also scans internal list of files.
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
50 Note: this option is cumulative. If not given at all, all
51 internal modules will be considered.
53 -nowrite Do not write the header/source files, even if changed.
55 -rebuild Rebuild all header and C source files, even if there
58 -reindex Ignore previously assigned values (except for R records in
59 the config file) and renumber everything starting at 100.
61 -static Make the load/unload functions static.
63 -unref List all unreferenced function and reason codes on stderr;
66 -help Show this help text.
68 ... Additional arguments are added to the file list to scan,
69 if '-internal' was NOT specified on the command line.
76 last unless $arg =~ /-.*/;
77 $arg = $1 if $arg =~ /-(-.*)/;
78 if ( $arg eq "-conf" ) {
81 } elsif ( $arg eq "-debug" ) {
84 } elsif ( $arg eq "-internal" ) {
86 } elsif ( $arg eq "-nowrite" ) {
88 } elsif ( $arg eq "-rebuild" ) {
90 } elsif ( $arg eq "-reindex" ) {
92 } elsif ( $arg eq "-static" ) {
94 } elsif ( $arg eq "-unref" ) {
97 } elsif ( $arg eq "-module" ) {
99 $modules{uc $ARGV[0]} = 1;
100 } elsif ( $arg =~ /-*h(elp)?/ ) {
103 } elsif ( $arg =~ /-.*/ ) {
104 die "Unknown option $arg; use -h for help.\n";
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') );
116 die "-module isn't useful without -internal\n" if scalar keys %modules > 0;
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
138 # Read and parse the config file
139 open(IN, "$config") || die "Can't open config file $config, $!,";
141 next if /^#/ || /^$/;
142 if ( /^L\s+(\S+)\s+(\S+)\s+(\S+)/ ) {
147 $libinc{$hdr} = $lib;
149 next if $err eq 'NONE';
150 $errorfile{$lib} = $err;
153 $fassigned{$lib} = ":";
154 $rassigned{$lib} = ":";
157 } elsif ( /^R\s+(\S+)\s+(\S+)/ ) {
160 } elsif ( /^S\s+(\S+)/ ) {
163 die "Illegal config line $_\n";
168 if ( ! $statefile ) {
169 $statefile = $config;
170 $statefile =~ s/.ec/.txt/;
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, $!";
179 # Scan function and reason codes and store them: keep a note of the
182 next if /^#/ || /^$/;
185 if ( /^(.+):(\d+):\\$/ ) {
189 $next =~ s/^\s*(.*)\s*$/$1/;
190 die "Duplicate define $name" if exists $strings{$name};
191 $strings{$name} = $next;
192 } elsif ( /^(\S+):(\d+):(.*)$/ ) {
195 die "Duplicate define $name" if exists $strings{$name};
196 $strings{$name} = $3;
198 die "Bad line in $statefile:\n$_\n";
201 $lib =~ s/^((?:OSSL_|OPENSSL_)?[^_]{2,}).*$/$1/;
202 $lib = "SSL" if $lib =~ /TLS/;
203 if ( !defined $errorfile{$lib} ) {
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};
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;
223 die "Bad line in $statefile:\n$_\n";
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";
235 print STDERR " --none--\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";
245 print STDERR " --none--\n";
251 # Scan each header file and make a list of error codes
253 &phase("Scanning headers");
254 while ( ( my $hdr, my $lib ) = each %libinc ) {
255 next if $hdr eq "NONE";
256 print STDERR " ." if $debug;
262 open(IN, "<$hdr") || die "Can't open $hdr, $!,";
277 if ( not /\*\// ) { # multiline comment...
278 $line = $_; # ... just accumulate
281 s/\/\*.*?\*\///gs; # wipe it
287 $cpp-- if /^#\s*endif/;
290 $cpp = 1 if /^#.*ifdef.*cplusplus/; # skip "C" declaration
292 next if /^\#/; # skip preprocessor directives
294 s/{[^{}]*}//gs; # ignore {} blocks
296 if ( /\{|\/\*/ ) { # Add a so editor works...
303 # Delete any DECLARE_ macros
305 $def =~ s/DECLARE_\w+\([\w,\s]+\)//gs;
306 foreach ( split /;/, $def ) {
308 # The goal is to collect function names from function declarations.
313 # Skip over recognized non-function declarations
314 next if /typedef\W/ or /DECLARE_STACK_OF/ or /TYPEDEF_.*_OF/;
316 # Remove STACK_OF(foo)
317 s/STACK_OF\(\w+\)/void/;
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
326 # pretend as we didn't use curly braces: {} -> ()
329 # Last token just before the first () is a function name.
330 if ( /(\w+)\s*\(\).*/s ) {
332 $name =~ tr/[a-z]/[A-Z]/;
334 } elsif ( /[\(\)]/ and not(/=/) ) {
335 print STDERR "Header $hdr: cannot parse: $_;\n";
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";
348 print STDERR "\n" if $debug;
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");
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, $!,";
369 print STDERR "$file:\n" if $debug;
372 # skip obsoleted source files entirely!
373 last if /^#error\s+obsolete/;
375 if ( !/;$/ && /^\**([a-zA-Z_].*[\s*])?([A-Za-z_0-9]+)\(.*([),]|$)/ ) {
376 /^([^()]*(\([^()]*\)[^()]*)*)\(/;
377 $1 =~ /([A-Za-z_0-9]*)$/;
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";
385 if ( !exists $fcodes{$1} ) {
386 print STDERR " New function $1\n" if $debug;
390 $ftrans{$3} = $func unless exists $ftrans{$3};
391 if ( uc($func) ne $3 ) {
392 print STDERR "ERROR: mismatch $file:$linenr $func:$3\n";
395 print STDERR " Function $1 = $fcodes{$1}\n"
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;
406 print STDERR " Reason $1 = $rcodes{$1}\n" if $debug;
411 print STDERR "\n" if $debug;
413 # Now process each library in turn.
414 &phase("Writing files");
416 foreach my $lib ( keys %errorfile ) {
417 if ( ! $fnew{$lib} && ! $rnew{$lib} ) {
418 next unless $rebuild;
420 next if scalar keys %modules > 0 && !$modules{$lib};
422 print STDERR "$lib: $fnew{$lib} new functions\n" if $fnew{$lib};
423 print STDERR "$lib: $rnew{$lib} new reasons\n" if $rnew{$lib};
426 # If we get here then we have some new error codes so we
427 # need to rebuild the header file and C file.
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 );
433 # Rewrite the header file
435 my $hfile = $hinc{$lib};
436 $hfile =~ s/.h$/err.h/ if $internal;
437 open( OUT, ">$hfile" ) || die "Can't write to $hfile, $!,";
440 * Generated by util/mkerr.pl DO NOT EDIT
441 * Copyright 1995-$YEAR The OpenSSL Project Authors. All Rights Reserved.
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
449 #ifndef HEADER_${lib}ERR_H
450 # define HEADER_${lib}ERR_H
454 # Declare the load function because the generate C file
455 # includes "fooerr.h" not "foo.h"
460 int ERR_load_${lib}_strings(void);
467 # define ${lib}err(f, r) ERR_${lib}_error((f), (r), OPENSSL_FILE, OPENSSL_LINE)
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);
486 print OUT "\n/*\n * $lib function codes.\n */\n";
487 foreach my $i ( @function ) {
488 my $z = 48 - length($i);
490 if ( $fcodes{$i} eq "X" ) {
491 $fassigned{$lib} =~ m/^:([^:]*):/;
493 $findcode = $fmax{$lib} if !defined $findcode;
494 while ( $fassigned{$lib} =~ m/:$findcode:/ ) {
497 $fcodes{$i} = $findcode;
498 $fassigned{$lib} .= "$findcode:";
499 print STDERR "New Function code $i\n" if $debug;
501 printf OUT "# define $i%s $fcodes{$i}\n", " " x $z;
504 print OUT "\n/*\n * $lib reason codes.\n */\n";
505 foreach my $i ( @reasons ) {
506 my $z = 48 - length($i);
508 if ( $rcodes{$i} eq "X" ) {
509 $rassigned{$lib} =~ m/^:([^:]*):/;
511 $findcode = $rmax{$lib} if !defined $findcode;
512 while ( $rassigned{$lib} =~ m/:$findcode:/ ) {
515 $rcodes{$i} = $findcode;
516 $rassigned{$lib} .= "$findcode:";
517 print STDERR "New Reason code $i\n" if $debug;
519 printf OUT "# define $i%s $rcodes{$i}\n", " " x $z;
523 print OUT "#endif\n";
525 # Rewrite the C source file containing the error details.
527 # First, read any existing reason string definitions:
528 my $cfile = $errorfile{$lib};
529 my $pack_lib = $internal ? "ERR_LIB_${lib}" : "0";
531 $hincf =~ s|.*include/||;
532 if ( $hincf =~ m|^openssl/| ) {
533 $hincf = "<${hincf}>";
535 $hincf = "\"${hincf}\"";
538 open( OUT, ">$cfile" )
539 || die "Can't open $cfile for writing, $!, stopped";
541 my $const = $internal ? 'const ' : '';
545 * Generated by util/mkerr.pl DO NOT EDIT
546 * Copyright 1995-$YEAR The OpenSSL Project Authors. All Rights Reserved.
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
554 #include <openssl/err.h>
557 #ifndef OPENSSL_NO_ERR
559 static ${const}ERR_STRING_DATA ${lib}_str_functs[] = {
562 # Add each function code: if a function name is found then use it.
563 foreach my $i ( @function ) {
565 if ( exists $strings{$i} and $strings{$i} ne '' ) {
567 $fn = "" if $fn eq '*';
569 $i =~ /^${lib}_F_(\S+)$/;
571 $fn = $ftrans{$fn} if exists $ftrans{$fn};
574 my $short = " {ERR_PACK($pack_lib, $i, 0), \"$fn\"},";
575 if ( length($short) <= 80 ) {
576 print OUT "$short\n";
578 print OUT " {ERR_PACK($pack_lib, $i, 0),\n \"$fn\"},\n";
585 static ${const}ERR_STRING_DATA ${lib}_str_reasons[] = {
588 # Add each reason code.
589 foreach my $i ( @reasons ) {
591 if ( exists $strings{$i} ) {
593 $rn = "" if $rn eq '*';
595 $i =~ /^${lib}_R_(\S+)$/;
597 $rn =~ tr/_[A-Z]/ [a-z]/;
600 my $short = " {ERR_PACK($pack_lib, 0, $i), \"$rn\"},";
601 if ( length($short) <= 80 ) {
602 print OUT "$short\n";
604 print OUT " {ERR_PACK($pack_lib, 0, $i),\n \"$rn\"},\n";
616 int ERR_load_${lib}_strings(void)
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);
628 my $st = $static ? "static " : "";
631 static int lib_code = 0;
632 static int error_loaded = 0;
634 ${st}int ERR_load_${lib}_strings(void)
637 lib_code = ERR_get_next_error_library();
640 #ifndef OPENSSL_NO_ERR
641 ERR_load_strings(lib_code, ${lib}_str_functs);
642 ERR_load_strings(lib_code, ${lib}_str_reasons);
649 ${st}void ERR_unload_${lib}_strings(void)
652 #ifndef OPENSSL_NO_ERR
653 ERR_unload_strings(lib_code, ${lib}_str_functs);
654 ERR_unload_strings(lib_code, ${lib}_str_reasons);
660 ${st}void ERR_${lib}_error(int function, int reason, char *file, int line)
663 lib_code = ERR_get_next_error_library();
664 ERR_PUT_error(lib_code, function, reason, file, line);
674 # Make a list of unreferenced function and reason codes
677 foreach ( keys %fcodes ) {
678 push( @funref, $_ ) unless exists $usedfuncs{$_};
681 foreach ( keys %rcodes ) {
682 push( @runref, $_ ) unless exists $usedreasons{$_};
685 print STDERR "The following function codes were not referenced:\n";
686 foreach ( sort @funref ) {
687 print STDERR " $_\n";
691 print STDERR "The following reason codes were not referenced:\n";
692 foreach ( sort @runref ) {
693 print STDERR " $_\n";
698 die "Found $errors errors, quitting" if $errors;
700 # Update the state file
702 open(OUT, ">$statefile.new")
703 || die "Can't write $statefile.new, $!";
705 # Copyright 1999-2017 The OpenSSL Project Authors. All Rights Reserved.
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
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";
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};
727 if ( $skippedstate ) {
728 print "Skipped state, leaving update in $statefile.new";
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, $!";