Synv ordinals with 1.0.1-stable.
[openssl.git] / util / mkerr.pl
1 #!/usr/local/bin/perl -w
2
3 my $config = "crypto/err/openssl.ec";
4 my $hprefix = "openssl/";
5 my $debug = 0;
6 my $rebuild = 0;
7 my $static = 1;
8 my $recurse = 0;
9 my $reindex = 0;
10 my $dowrite = 0;
11 my $staticloader = "";
12
13 my $pack_errcode;
14 my $load_errcode;
15
16 my $errcount;
17
18 while (@ARGV) {
19         my $arg = $ARGV[0];
20         if($arg eq "-conf") {
21                 shift @ARGV;
22                 $config = shift @ARGV;
23         } elsif($arg eq "-hprefix") {
24                 shift @ARGV;
25                 $hprefix = shift @ARGV;
26         } elsif($arg eq "-debug") {
27                 $debug = 1;
28                 shift @ARGV;
29         } elsif($arg eq "-rebuild") {
30                 $rebuild = 1;
31                 shift @ARGV;
32         } elsif($arg eq "-recurse") {
33                 $recurse = 1;
34                 shift @ARGV;
35         } elsif($arg eq "-reindex") {
36                 $reindex = 1;
37                 shift @ARGV;
38         } elsif($arg eq "-nostatic") {
39                 $static = 0;
40                 shift @ARGV;
41         } elsif($arg eq "-staticloader") {
42                 $staticloader = "static ";
43                 shift @ARGV;
44         } elsif($arg eq "-write") {
45                 $dowrite = 1;
46                 shift @ARGV;
47         } elsif($arg eq "-help" || $arg eq "-h" || $arg eq "-?" || $arg eq "--help") {
48                 print STDERR <<"EOF";
49 mkerr.pl [options] ...
50
51 Options:
52
53   -conf F       Use the config file F instead of the default one:
54                   crypto/err/openssl.ec
55
56   -hprefix P    Prepend the filenames in generated #include <header>
57                 statements with prefix P. Default: 'openssl/' (without
58                 the quotes, naturally)
59
60   -debug        Turn on debugging verbose output on stderr.
61
62   -rebuild      Rebuild all header and C source files, irrespective of the
63                 fact if any error or function codes have been added/removed.
64                 Default: only update files for libraries which saw change
65                          (of course, this requires '-write' as well, or no
66                           files will be touched!)
67
68   -recurse      scan a preconfigured set of directories / files for error and
69                 function codes:
70                   (<crypto/*.c>, <crypto/*/*.c>, <ssl/*.c>, <apps/*.c>)
71                 When this option is NOT specified, the filelist is taken from
72                 the commandline instead. Here, wildcards may be embedded. (Be
73                 sure to escape those to prevent the shell from expanding them
74                 for you when you wish mkerr.pl to do so instead.)
75                 Default: take file list to scan from the command line.
76
77   -reindex      Discard the numeric values previously assigned to the error
78                 and function codes as extracted from the scanned header files;
79                 instead renumber all of them starting from 100. (Note that
80                 the numbers assigned through 'R' records in the config file
81                 remain intact.)
82                 Default: keep previously assigned numbers. (You are warned
83                          when collisions are detected.)
84
85   -nostatic     Generates a different source code, where these additional 
86                 functions are generated for each library specified in the
87                 config file:
88                   void ERR_load_<LIB>_strings(void);
89                   void ERR_unload_<LIB>_strings(void);
90                   void ERR_<LIB>_error(int f, int r, char *fn, int ln);
91                   #define <LIB>err(f,r) ERR_<LIB>_error(f,r,__FILE__,__LINE__)
92                 while the code facilitates the use of these in an environment
93                 where the error support routines are dynamically loaded at 
94                 runtime.
95                 Default: 'static' code generation.
96
97   -staticloader Prefix generated functions with the 'static' scope modifier.
98                 Default: don't write any scope modifier prefix.
99
100   -write        Actually (over)write the generated code to the header and C 
101                 source files as assigned to each library through the config 
102                 file.
103                 Default: don't write.
104
105   -help / -h / -? / --help            Show this help text.
106
107   ...           Additional arguments are added to the file list to scan,
108                 assuming '-recurse' was NOT specified on the command line.
109
110 EOF
111                 exit 1;
112         } else {
113                 last;
114         }
115 }
116
117 if($recurse) {
118         @source = ( <crypto/*.c>, <crypto/*/*.c>, <ssl/*.c>,
119                         <fips/*.c>, <fips/*/*.c>);
120 } else {
121         @source = @ARGV;
122 }
123
124 # Read in the config file
125
126 open(IN, "<$config") || die "Can't open config file $config";
127
128 # Parse config file
129
130 while(<IN>)
131 {
132         if(/^L\s+(\S+)\s+(\S+)\s+(\S+)/) {
133                 $hinc{$1} = $2;
134                 $libinc{$2} = $1;
135                 $cskip{$3} = $1;
136                 if($3 ne "NONE") {
137                         $csrc{$1} = $3;
138                         $fmax{$1} = 100;
139                         $rmax{$1} = 100;
140                         $fassigned{$1} = ":";
141                         $rassigned{$1} = ":";
142                         $fnew{$1} = 0;
143                         $rnew{$1} = 0;
144                 }
145         } elsif (/^F\s+(\S+)/) {
146         # Add extra function with $1
147         } elsif (/^R\s+(\S+)\s+(\S+)/) {
148                 $rextra{$1} = $2;
149                 $rcodes{$1} = $2;
150         }
151 }
152
153 close IN;
154
155 # Scan each header file in turn and make a list of error codes
156 # and function names
157
158 while (($hdr, $lib) = each %libinc)
159 {
160         next if($hdr eq "NONE");
161         print STDERR "Scanning header file $hdr\n" if $debug; 
162         my $line = "", $def= "", $linenr = 0, $gotfile = 0;
163         if (open(IN, "<$hdr")) {
164             $gotfile = 1;
165             while(<IN>) {
166                 $linenr++;
167                 print STDERR "line: $linenr\r" if $debug;
168
169                 last if(/BEGIN\s+ERROR\s+CODES/);
170                 if ($line ne '') {
171                     $_ = $line . $_;
172                     $line = '';
173                 }
174
175                 if (/\\$/) {
176                     $line = $_;
177                     next;
178                 }
179
180                 if(/\/\*/) {
181                     if (not /\*\//) {           # multiline comment...
182                         $line = $_;             # ... just accumulate
183                         next; 
184                     } else {
185                         s/\/\*.*?\*\///gs;      # wipe it
186                     }
187                 }
188
189                 if ($cpp) {
190                     $cpp++ if /^#\s*if/;
191                     $cpp-- if /^#\s*endif/;
192                     next;
193                 }
194                 $cpp = 1 if /^#.*ifdef.*cplusplus/;  # skip "C" declaration
195
196                 next if (/^\#/);                      # skip preprocessor directives
197
198                 s/{[^{}]*}//gs;                      # ignore {} blocks
199
200                 if (/\{|\/\*/) { # Add a } so editor works...
201                     $line = $_;
202                 } else {
203                     $def .= $_;
204                 }
205             }
206         }
207
208         print STDERR "                                  \r" if $debug;
209         $defnr = 0;
210         # Delete any DECLARE_ macros
211         $def =~ s/DECLARE_\w+\([\w,\s]+\)//gs;
212         foreach (split /;/, $def) {
213             $defnr++;
214             print STDERR "def: $defnr\r" if $debug;
215
216             # The goal is to collect function names from function declarations.
217
218             s/^[\n\s]*//g;
219             s/[\n\s]*$//g;
220
221             # Skip over recognized non-function declarations
222             next if(/typedef\W/ or /DECLARE_STACK_OF/ or /TYPEDEF_.*_OF/);
223
224             # Remove STACK_OF(foo)
225             s/STACK_OF\(\w+\)/void/;
226
227             # Reduce argument lists to empty ()
228             # fold round brackets recursively: (t(*v)(t),t) -> (t{}{},t) -> {}
229             while(/\(.*\)/s) {
230                 s/\([^\(\)]+\)/\{\}/gs;
231                 s/\(\s*\*\s*(\w+)\s*\{\}\s*\)/$1/gs;    #(*f{}) -> f
232             }
233             # pretend as we didn't use curly braces: {} -> ()
234             s/\{\}/\(\)/gs;
235
236             if (/(\w+)\s*\(\).*/s) {    # first token prior [first] () is
237                 my $name = $1;          # a function name!
238                 $name =~ tr/[a-z]/[A-Z]/;
239                 $ftrans{$name} = $1;
240             } elsif (/[\(\)]/ and not (/=/)) {
241                 print STDERR "Header $hdr: cannot parse: $_;\n";
242             }
243         }
244
245         print STDERR "                                  \r" if $debug;
246
247         next if $reindex;
248
249         # Scan function and reason codes and store them: keep a note of the
250         # maximum code used.
251
252         if ($gotfile) {
253           while(<IN>) {
254                 if(/^\#define\s+(\S+)\s+(\S+)/) {
255                         $name = $1;
256                         $code = $2;
257                         next if $name =~ /^${lib}err/;
258                         unless($name =~ /^${lib}_([RF])_(\w+)$/) {
259                                 print STDERR "Invalid error code $name\n";
260                                 next;
261                         }
262                         if($1 eq "R") {
263                                 $rcodes{$name} = $code;
264                                 if ($rassigned{$lib} =~ /:$code:/) {
265                                         print STDERR "!! ERROR: $lib reason code $code assigned twice (collision at $name)\n";
266                                         ++$errcount;
267                                 }
268                                 $rassigned{$lib} .= "$code:";
269                                 if(!(exists $rextra{$name}) &&
270                                          ($code > $rmax{$lib}) ) {
271                                         $rmax{$lib} = $code;
272                                 }
273                         } else {
274                                 if ($fassigned{$lib} =~ /:$code:/) {
275                                         print STDERR "!! ERROR: $lib function code $code assigned twice (collision at $name)\n";
276                                         ++$errcount;
277                                 }
278                                 $fassigned{$lib} .= "$code:";
279                                 if($code > $fmax{$lib}) {
280                                         $fmax{$lib} = $code;
281                                 }
282                                 $fcodes{$name} = $code;
283                         }
284                 }
285           }
286         }
287
288         if ($debug) {
289                 if (defined($fmax{$lib})) {
290                         print STDERR "Max function code fmax" . "{" . "$lib" . "} = $fmax{$lib}\n";
291                         $fassigned{$lib} =~ m/^:(.*):$/;
292                         @fassigned = sort {$a <=> $b} split(":", $1);
293                         print STDERR "  @fassigned\n";
294                 }
295                 if (defined($rmax{$lib})) {
296                         print STDERR "Max reason code rmax" . "{" . "$lib" . "} = $rmax{$lib}\n";
297                         $rassigned{$lib} =~ m/^:(.*):$/;
298                         @rassigned = sort {$a <=> $b} split(":", $1);
299                         print STDERR "  @rassigned\n";
300                 }
301         }
302
303         if ($lib eq "SSL") {
304                 if ($rmax{$lib} >= 1000) {
305                         print STDERR "!! ERROR: SSL error codes 1000+ are reserved for alerts.\n";
306                         print STDERR "!!        Any new alerts must be added to $config.\n";
307                         ++$errcount;
308                         print STDERR "\n";
309                 }
310         }
311         close IN;
312 }
313
314 # Scan each C source file and look for function and reason codes
315 # This is done by looking for strings that "look like" function or
316 # reason codes: basically anything consisting of all upper case and
317 # numerics which has _F_ or _R_ in it and which has the name of an
318 # error library at the start. This seems to work fine except for the
319 # oddly named structure BIO_F_CTX which needs to be ignored.
320 # If a code doesn't exist in list compiled from headers then mark it
321 # with the value "X" as a place holder to give it a value later.
322 # Store all function and reason codes found in %ufcodes and %urcodes
323 # so all those unreferenced can be printed out.
324
325
326 foreach $file (@source) {
327         # Don't parse the error source file.
328         next if exists $cskip{$file};
329         print STDERR "File loaded: ".$file."\r" if $debug;
330         open(IN, "<$file") || die "Can't open source file $file\n";
331         while(<IN>) {
332                 # skip obsoleted source files entirely!
333                 last if(/^#error\s+obsolete/);
334
335                 if(/(([A-Z0-9]+)_F_([A-Z0-9_]+))/) {
336                         next unless exists $csrc{$2};
337                         next if($1 eq "BIO_F_BUFFER_CTX");
338                         $ufcodes{$1} = 1;
339                         if(!exists $fcodes{$1}) {
340                                 $fcodes{$1} = "X";
341                                 $fnew{$2}++;
342                         }
343                         $notrans{$1} = 1 unless exists $ftrans{$3};
344                         print STDERR "Function: $1\t= $fcodes{$1} (lib: $2, name: $3)\n" if $debug; 
345                 }
346                 if(/(([A-Z0-9]+)_R_[A-Z0-9_]+)/) {
347                         next unless exists $csrc{$2};
348                         $urcodes{$1} = 1;
349                         if(!exists $rcodes{$1}) {
350                                 $rcodes{$1} = "X";
351                                 $rnew{$2}++;
352                         }
353                         print STDERR "Reason: $1\t= $rcodes{$1} (lib: $2)\n" if $debug; 
354                 } 
355         }
356         close IN;
357 }
358 print STDERR "                                  \n" if $debug;
359
360 # Now process each library in turn.
361
362 foreach $lib (keys %csrc)
363 {
364         my $hfile = $hinc{$lib};
365         my $cfile = $csrc{$lib};
366         if(!$fnew{$lib} && !$rnew{$lib}) {
367                 print STDERR "$lib:\t\tNo new error codes\n";
368                 next unless $rebuild;
369         } else {
370                 print STDERR "$lib:\t\t$fnew{$lib} New Functions,";
371                 print STDERR " $rnew{$lib} New Reasons.\n";
372                 next unless $dowrite;
373         }
374
375         # If we get here then we have some new error codes so we
376         # need to rebuild the header file and C file.
377
378         # Make a sorted list of error and reason codes for later use.
379
380         my @function = sort grep(/^${lib}_/,keys %fcodes);
381         my @reasons = sort grep(/^${lib}_/,keys %rcodes);
382
383         # Rewrite the header file
384
385         if (open(IN, "<$hfile")) {
386             # Copy across the old file
387             while(<IN>) {
388                 push @out, $_;
389                 last if (/BEGIN ERROR CODES/);
390             }
391             close IN;
392         } else {
393             push @out,
394 "/* ====================================================================\n",
395 " * Copyright (c) 2001-2011 The OpenSSL Project.  All rights reserved.\n",
396 " *\n",
397 " * Redistribution and use in source and binary forms, with or without\n",
398 " * modification, are permitted provided that the following conditions\n",
399 " * are met:\n",
400 " *\n",
401 " * 1. Redistributions of source code must retain the above copyright\n",
402 " *    notice, this list of conditions and the following disclaimer. \n",
403 " *\n",
404 " * 2. Redistributions in binary form must reproduce the above copyright\n",
405 " *    notice, this list of conditions and the following disclaimer in\n",
406 " *    the documentation and/or other materials provided with the\n",
407 " *    distribution.\n",
408 " *\n",
409 " * 3. All advertising materials mentioning features or use of this\n",
410 " *    software must display the following acknowledgment:\n",
411 " *    \"This product includes software developed by the OpenSSL Project\n",
412 " *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)\"\n",
413 " *\n",
414 " * 4. The names \"OpenSSL Toolkit\" and \"OpenSSL Project\" must not be used to\n",
415 " *    endorse or promote products derived from this software without\n",
416 " *    prior written permission. For written permission, please contact\n",
417 " *    openssl-core\@openssl.org.\n",
418 " *\n",
419 " * 5. Products derived from this software may not be called \"OpenSSL\"\n",
420 " *    nor may \"OpenSSL\" appear in their names without prior written\n",
421 " *    permission of the OpenSSL Project.\n",
422 " *\n",
423 " * 6. Redistributions of any form whatsoever must retain the following\n",
424 " *    acknowledgment:\n",
425 " *    \"This product includes software developed by the OpenSSL Project\n",
426 " *    for use in the OpenSSL Toolkit (http://www.openssl.org/)\"\n",
427 " *\n",
428 " * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY\n",
429 " * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n",
430 " * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n",
431 " * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR\n",
432 " * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n",
433 " * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n",
434 " * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n",
435 " * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n",
436 " * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\n",
437 " * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n",
438 " * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED\n",
439 " * OF THE POSSIBILITY OF SUCH DAMAGE.\n",
440 " * ====================================================================\n",
441 " *\n",
442 " * This product includes cryptographic software written by Eric Young\n",
443 " * (eay\@cryptsoft.com).  This product includes software written by Tim\n",
444 " * Hudson (tjh\@cryptsoft.com).\n",
445 " *\n",
446 " */\n",
447 "\n",
448 "#ifndef HEADER_${lib}_ERR_H\n",
449 "#define HEADER_${lib}_ERR_H\n",
450 "\n",
451 "#ifdef  __cplusplus\n",
452 "extern \"C\" {\n",
453 "#endif\n",
454 "\n",
455 "/* BEGIN ERROR CODES */\n";
456         }
457         open (OUT, ">$hfile") || die "Can't Open File $hfile for writing\n";
458
459         print OUT @out;
460         undef @out;
461         print OUT <<"EOF";
462 /* The following lines are auto generated by the script mkerr.pl. Any changes
463  * made after this point may be overwritten when the script is next run.
464  */
465 EOF
466         if($static) {
467                 print OUT <<"EOF";
468 ${staticloader}void ERR_load_${lib}_strings(void);
469
470 EOF
471         } else {
472                 print OUT <<"EOF";
473 ${staticloader}void ERR_load_${lib}_strings(void);
474 ${staticloader}void ERR_unload_${lib}_strings(void);
475 ${staticloader}void ERR_${lib}_error(int function, int reason, char *file, int line);
476 #define ${lib}err(f,r) ERR_${lib}_error((f),(r),__FILE__,__LINE__)
477
478 EOF
479         }
480         print OUT <<"EOF";
481 /* Error codes for the $lib functions. */
482
483 /* Function codes. */
484 EOF
485
486         foreach $i (@function) {
487                 $z=6-int(length($i)/8);
488                 if($fcodes{$i} eq "X") {
489                         $fassigned{$lib} =~ m/^:([^:]*):/;
490                         $findcode = $1;
491                         if (!defined($findcode)) {
492                                 $findcode = $fmax{$lib};
493                         }
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","\t" x $z;
502         }
503
504         print OUT "\n/* Reason codes. */\n";
505
506         foreach $i (@reasons) {
507                 $z=6-int(length($i)/8);
508                 if($rcodes{$i} eq "X") {
509                         $rassigned{$lib} =~ m/^:([^:]*):/;
510                         $findcode = $1;
511                         if (!defined($findcode)) {
512                                 $findcode = $rmax{$lib};
513                         }
514                         while ($rassigned{$lib} =~ m/:$findcode:/) {
515                                 $findcode++;
516                         }
517                         $rcodes{$i} = $findcode;
518                         $rassigned{$lib} .= "$findcode:";
519                         print STDERR "New Reason code   $i\n" if $debug;
520                 }
521                 printf OUT "#define $i%s $rcodes{$i}\n","\t" x $z;
522         }
523         print OUT <<"EOF";
524
525 #ifdef  __cplusplus
526 }
527 #endif
528 #endif
529 EOF
530         close OUT;
531
532         # Rewrite the C source file containing the error details.
533
534         # First, read any existing reason string definitions:
535         my %err_reason_strings;
536         if (open(IN,"<$cfile")) {
537                 while (<IN>) {
538                         if (/\b(${lib}_R_\w*)\b.*\"(.*)\"/) {
539                                 $err_reason_strings{$1} = $2;
540                         }
541                         if (/\b${lib}_F_(\w*)\b.*\"(.*)\"/) {
542                                 if (!exists $ftrans{$1} && ($1 ne $2)) {
543                                         print STDERR "WARNING: Mismatched function string $2\n";
544                                         $ftrans{$1} = $2;
545                                 }
546                         }
547                 }
548                 close(IN);
549         }
550
551
552         my $hincf;
553         if($static) {
554                 $hfile =~ /([^\/]+)$/;
555                 $hincf = "<${hprefix}$1>";
556         } else {
557                 $hincf = "\"$hfile\"";
558         }
559
560         # If static we know the error code at compile time so use it
561         # in error definitions.
562
563         if ($static)
564                 {
565                 $pack_errcode = "ERR_LIB_${lib}";
566                 $load_errcode = "0";
567                 }
568         else
569                 {
570                 $pack_errcode = "0";
571                 $load_errcode = "ERR_LIB_${lib}";
572                 }
573
574
575         open (OUT,">$cfile") || die "Can't open $cfile for writing";
576
577         print OUT <<"EOF";
578 /* $cfile */
579 /* ====================================================================
580  * Copyright (c) 1999-2011 The OpenSSL Project.  All rights reserved.
581  *
582  * Redistribution and use in source and binary forms, with or without
583  * modification, are permitted provided that the following conditions
584  * are met:
585  *
586  * 1. Redistributions of source code must retain the above copyright
587  *    notice, this list of conditions and the following disclaimer. 
588  *
589  * 2. Redistributions in binary form must reproduce the above copyright
590  *    notice, this list of conditions and the following disclaimer in
591  *    the documentation and/or other materials provided with the
592  *    distribution.
593  *
594  * 3. All advertising materials mentioning features or use of this
595  *    software must display the following acknowledgment:
596  *    "This product includes software developed by the OpenSSL Project
597  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
598  *
599  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
600  *    endorse or promote products derived from this software without
601  *    prior written permission. For written permission, please contact
602  *    openssl-core\@OpenSSL.org.
603  *
604  * 5. Products derived from this software may not be called "OpenSSL"
605  *    nor may "OpenSSL" appear in their names without prior written
606  *    permission of the OpenSSL Project.
607  *
608  * 6. Redistributions of any form whatsoever must retain the following
609  *    acknowledgment:
610  *    "This product includes software developed by the OpenSSL Project
611  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
612  *
613  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
614  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
615  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
616  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
617  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
618  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
619  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
620  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
621  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
622  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
623  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
624  * OF THE POSSIBILITY OF SUCH DAMAGE.
625  * ====================================================================
626  *
627  * This product includes cryptographic software written by Eric Young
628  * (eay\@cryptsoft.com).  This product includes software written by Tim
629  * Hudson (tjh\@cryptsoft.com).
630  *
631  */
632
633 /* NOTE: this file was auto generated by the mkerr.pl script: any changes
634  * made to it will be overwritten when the script next updates this file,
635  * only reason strings will be preserved.
636  */
637
638 #include <stdio.h>
639 #include <openssl/err.h>
640 #include $hincf
641
642 /* BEGIN ERROR CODES */
643 #ifndef OPENSSL_NO_ERR
644
645 #define ERR_FUNC(func) ERR_PACK($pack_errcode,func,0)
646 #define ERR_REASON(reason) ERR_PACK($pack_errcode,0,reason)
647
648 static ERR_STRING_DATA ${lib}_str_functs[]=
649         {
650 EOF
651         # Add each function code: if a function name is found then use it.
652         foreach $i (@function) {
653                 my $fn;
654                 $i =~ /^${lib}_F_(\S+)$/;
655                 $fn = $1;
656                 if(exists $ftrans{$fn}) {
657                         $fn = $ftrans{$fn};
658                 }
659 #               print OUT "{ERR_PACK($pack_errcode,$i,0),\t\"$fn\"},\n";
660                 print OUT "{ERR_FUNC($i),\t\"$fn\"},\n";
661         }
662         print OUT <<"EOF";
663 {0,NULL}
664         };
665
666 static ERR_STRING_DATA ${lib}_str_reasons[]=
667         {
668 EOF
669         # Add each reason code.
670         foreach $i (@reasons) {
671                 my $rn;
672                 my $rstr = "ERR_REASON($i)";
673                 my $nspc = 0;
674                 if (exists $err_reason_strings{$i}) {
675                         $rn = $err_reason_strings{$i};
676                 } else {
677                         $i =~ /^${lib}_R_(\S+)$/;
678                         $rn = $1;
679                         $rn =~ tr/_[A-Z]/ [a-z]/;
680                 }
681                 $nspc = 40 - length($rstr) unless length($rstr) > 40;
682                 $nspc = " " x $nspc;
683                 print OUT "{${rstr}${nspc},\"$rn\"},\n";
684         }
685 if($static) {
686         print OUT <<"EOF";
687 {0,NULL}
688         };
689
690 #endif
691
692 ${staticloader}void ERR_load_${lib}_strings(void)
693         {
694 #ifndef OPENSSL_NO_ERR
695
696         if (ERR_func_error_string(${lib}_str_functs[0].error) == NULL)
697                 {
698                 ERR_load_strings($load_errcode,${lib}_str_functs);
699                 ERR_load_strings($load_errcode,${lib}_str_reasons);
700                 }
701 #endif
702         }
703 EOF
704 } else {
705         print OUT <<"EOF";
706 {0,NULL}
707         };
708
709 #endif
710
711 #ifdef ${lib}_LIB_NAME
712 static ERR_STRING_DATA ${lib}_lib_name[]=
713         {
714 {0      ,${lib}_LIB_NAME},
715 {0,NULL}
716         };
717 #endif
718
719
720 static int ${lib}_lib_error_code=0;
721 static int ${lib}_error_init=1;
722
723 ${staticloader}void ERR_load_${lib}_strings(void)
724         {
725         if (${lib}_lib_error_code == 0)
726                 ${lib}_lib_error_code=ERR_get_next_error_library();
727
728         if (${lib}_error_init)
729                 {
730                 ${lib}_error_init=0;
731 #ifndef OPENSSL_NO_ERR
732                 ERR_load_strings(${lib}_lib_error_code,${lib}_str_functs);
733                 ERR_load_strings(${lib}_lib_error_code,${lib}_str_reasons);
734 #endif
735
736 #ifdef ${lib}_LIB_NAME
737                 ${lib}_lib_name->error = ERR_PACK(${lib}_lib_error_code,0,0);
738                 ERR_load_strings(0,${lib}_lib_name);
739 #endif
740                 }
741         }
742
743 ${staticloader}void ERR_unload_${lib}_strings(void)
744         {
745         if (${lib}_error_init == 0)
746                 {
747 #ifndef OPENSSL_NO_ERR
748                 ERR_unload_strings(${lib}_lib_error_code,${lib}_str_functs);
749                 ERR_unload_strings(${lib}_lib_error_code,${lib}_str_reasons);
750 #endif
751
752 #ifdef ${lib}_LIB_NAME
753                 ERR_unload_strings(0,${lib}_lib_name);
754 #endif
755                 ${lib}_error_init=1;
756                 }
757         }
758
759 ${staticloader}void ERR_${lib}_error(int function, int reason, char *file, int line)
760         {
761         if (${lib}_lib_error_code == 0)
762                 ${lib}_lib_error_code=ERR_get_next_error_library();
763         ERR_PUT_error(${lib}_lib_error_code,function,reason,file,line);
764         }
765 EOF
766
767 }
768
769         close OUT;
770         undef %err_reason_strings;
771 }
772
773 if($debug && defined(%notrans)) {
774         print STDERR "The following function codes were not translated:\n";
775         foreach(sort keys %notrans)
776         {
777                 print STDERR "$_\n";
778         }
779 }
780
781 # Make a list of unreferenced function and reason codes
782
783 foreach (keys %fcodes) {
784         push (@funref, $_) unless exists $ufcodes{$_};
785 }
786
787 foreach (keys %rcodes) {
788         push (@runref, $_) unless exists $urcodes{$_};
789 }
790
791 if($debug && defined(@funref) ) {
792         print STDERR "The following function codes were not referenced:\n";
793         foreach(sort @funref)
794         {
795                 print STDERR "$_\n";
796         }
797 }
798
799 if($debug && defined(@runref) ) {
800         print STDERR "The following reason codes were not referenced:\n";
801         foreach(sort @runref)
802         {
803                 print STDERR "$_\n";
804         }
805 }
806
807 if($errcount) {
808         print STDERR "There were errors, failing...\n\n";
809         exit $errcount;
810 }
811