" +
" "
+ "" +
% slides
+ "" +
+ " " +
+ "" +
+ " " +
% letters
+ "" +
+ " " +
+ "" +
+ " " +
+ ""
" " +
+ ""
+ " " +
+ ""
+ " " +
% first end definition of name
+ "" +
+ " " +
+ ""
" " +
+ ""
" " +
+ ""
" " +
+ ""
" " +
+ ""
" " +
+ ""
" " +
+ ""
" " +
+ ""
" " +
+ ""
" " +
+ ""
" " +
+ "" +
+ " " +
% end of html replacement file
bird2-2.17.5/doc/sbase/dist/birddoc/latex2e/ 0000775 0000000 0000000 00000000000 15211753245 0020374 5 ustar 00root root 0000000 0000000 bird2-2.17.5/doc/sbase/dist/birddoc/latex2e/mapping 0000664 0000000 0000000 00000015254 15211753245 0021761 0 ustar 00root root 0000000 0000000
% birddoc to LaTeX replacement file
% The \relax is there to avoid sgml2latex rewriting the class
+ "\\relax\\documentclass\[a4paper,10pt,openany,oneside\]{book}\n"
"\\def\\stabledate#1{\\date{}\\pdfinfo{/CreationDate (#1) /ModDate (#1)}}\n"
"\\pdfsuppressptexinfo=-1"
"\\usepackage\[colorlinks=true,linkcolor=blue,pdftitle={BIRD User's Guide}\]{hyperref}\n"
"\\usepackage{enumitem}\n"
"\\usepackage{birddoc}\n"
"\\usepackage{qwertz}\n"
"\\usepackage{url}\n"
"\\usepackage\[latin1\]{inputenc}\n"
"\\usepackage{epsfig}\n"
"\\usepackage{[OPTS]}\n"
"\\pagestyle{headings}%end-preamble\n" +
+ "\\end{document}" +
% Manual Pages are expected to be formatted using nroff (or groff), unless
% they are included as sections of other qwertz documents.
"\\progdoc"
+ "\n\n\\begin{document}\n"
"\\maketitle\n" +
+ "\\title{"
"}" +
"\\\\\n"
"{\\large "
"}" +
+ "\\author{"
"}" +
"\\and " +
"\\thanks{"
"}"
" \\\\\n\\\\" +
+ "\\stabledate{"
"}" +
+ "\\pdftrailerid{"
"}" +
"\\\\ "
"\\label{[ID]}"
"{"
"}"
"{"
"}" +
% + "\n\n\\begin{verbatim}" +
% + "\\end{verbatim}\n\n" +
"{\\tt "
"}"
% Hacked by mdw to use linuxdoc-sgml \abstract{...}
+ "\\abstract{"
"}" +
+ "\n \\appendix \n" +
+ "\\tableofcontents" +
+ "\\listoffigures" +
+ "\\listoftables" +
+ "\n\\chapter"
+ "\n\\section"
+ "\n\\subsection"
+ "\n\\subsubsection"
+ "\n\\paragraph"
+ "\n\\subparagraph"
"{"
"}\n\n"
"\\phantomsection{}"
"\n\n"
+ "\\begin{itemize}" +
+ "\\end{itemize}" +
+ "\\begin{enumerate}" +
+ "\\end{enumerate}" +
+ "\\begin{list}{}{}\n" +
+ "\\end{list}" +
+ "\\begin{description}\[style=unboxed\]" +
+ "\\end{description}" +
- + "\\item "
+ "\\phantomsection\\item\[{\\ttfamily "
"}\] \\hfil\\break\n" +
+ "\\item\[ "
"\] \\hfil\\break\n" +
"\\cite{[ID]"
"}"
"\\cite\[[NOTE]\]{[ID]"
"}"
"\\idx{"
"}"
"\\cdx{"
"}"
"\\nidx{"
"}"
"\\ncdx{"
"}"
% The idea here is to automatically insert soft hyphens after every slash in
% the filename, so long filenames will break naturally. The url{} macro is
% a kluge but it works,
"{\\tt "
"}"
"\\footnote{"
"}"
"``"
"''"
+ "\\begin{quotation}\n" +
+ "\n\\end{quotation}\n\n" +
"{\\it "
"\\/}"
"{\\it "
"\\/}"
"{\\bf "
"}"
"{\\it "
"\\/}"
"{\\sf "
"}"
"{\\sl "
"}"
"{\\rm "
"}"
"{\\tt "
"}"
"{\\tt "
"}"
"{\\tt "
"}"
"{\\it "
"\\/}"
"{\\tt "
"}"
"{\\rm "
"}"
"{\\it "
"\\/}"
"{\\function "
"}\n\n"
"\n\\funcsect{"
"}"
"\\hrule"
% Added by mdw
"\\cparam{"
"}"
[ "\\hyperref\[[ID]\]{[NAME]} (p.\\,\\getpagerefnumber{[ID]})"
]
"\\pageref{[ID]}"
%url added by HG
"\\href{[URL]}{[NAME]}"
"\\href{[URL]}{[NAME]}"
"\\href{http://www.rfc-editor.org/info/rfc[ID]}{RFC [ID]}"
+ "\\bibliographystyle{[STYLE]}\n"
"\\bibliography{[FILES]}\n"
"\\addbibtoc{}" +
% + "\\macro{[ID]}{\\qw[ID]}"
%
% + "\\macro{qwmain}{\\qwmain}"
%
% + "\\par\n"
% "\\medbreak\\hrule\\nopagebreak\n"
% "\\begin{verbatim}" +
%
% + "\\end{verbatim}\n"
% "\\nopagebreak\\hrule\\medbreak\n" +
+ "\\par\n"
"\\goodbreak{\\birdnarrow\n"
"\\begin{verbatim}" +
+ "\\end{verbatim}\n"
"}\\smallbreak\n" +
+ "\\begin{verbatim}" +
+ "\\end{verbatim}" +
% tscreen added by mdw
+ "\\begin{tscreen}" +
+ "\\end{tscreen}" +
+ "\\begin{quotation}" +
+ "\\end{quotation}" +
% theorems and such
+ "\\begin{definition}"
+ "\\end{definition}\n\n" +
+ "\\begin{proposition}" +
+ "\\end{proposition}" +
+ "\\begin{lemma}"
+ "\\end{lemma}\n\n" +
+ "\\begin{corollary}"
+ "\\end{corollary}\n\n" +
+ "\n{\\noindent{\\bf Proof.} " +
+ "}"
+ "\\begin{theorem}"
+ "\\end{theorem}\n\n" +
"\["
"\]" +
% mathematics
"$"
"$"
+ "\\\["
"\\\]" +
+ "\\begin{equation}" +
+ "\\end{equation}\n" +
"\\frac"
"{"
"}"
"{"
"}"
"_{"
"}"
"}"
"\\prod"
"\\int"
"\\sum"
"\\sqrt\[[n]\]{"
"}"
+ "\\begin{array}{[ca]}" +
+ "\\end{array}" +
" \\\\ " +
" & "
"^{"
"}"
"_{"
"}"
"\\underline{"
"}"
"\\overline{"
"}"
"\\mbox{\\tt "
"}"
"\\vec{"
"}"
"{\\cal "
"}"
"{\\rm "
"}"
"\\\\ \n"
% figures
+ "\\begin{figure}\[[LOC]\]" +
+ "\\end{figure}\n" +
+ "\\centerline{\\epsfig{file=[FILE],height=[HEIGHT],angle=[ANGLE]}}" +
+ "\\vspace{[VSPACE]}\n\\par" +
+ "\\caption{"
"}" +
% tables
+ "\\begin{table}\[[LOC]\]" +
+ "\\end{table}" +
+ "\\begin{center}\n"
"\\begin{tabular}{[ca]}" +
+ "\\end{tabular}\n"
"\\end{center}" +
"\\\\ " +
"& "
+ "\\hline" +
% end of latex replacement file
bird2-2.17.5/doc/sbase/dist/fmt_html.pl 0000664 0000000 0000000 00000010136 15211753245 0017572 0 ustar 00root root 0000000 0000000 #
# fmt_html.pl
#
# $Id$
#
# HTML-specific driver stuff
#
# Copyright 1996, Cees de Groot
#
package LinuxDocTools::fmt_html;
use strict;
use LinuxDocTools::CharEnts;
use LinuxDocTools::Vars;
use LinuxDocTools::FixRef;
my $fixref = $LinuxDocTools::FixRef::fixref;
use LinuxDocTools::Html2Html;
my $html2html = $LinuxDocTools::Html2Html::html2html;
my $html = {};
$html->{NAME} = "html";
$html->{HELP} = "";
$html->{OPTIONS} = [
{ option => "split", type => "l",
'values' => [ "0", "1", "2" ], short => "s" },
{ option => "toc", type => "l",
'values' => [ "0", "1", "2" ], short => "T" },
{ option => "dosnames", type => "f", short => "h" },
{ option => "imagebuttons", type => "f", short => "I"},
{ option => "header", type => "s", short => "H"},
{ option => "footer", type => "s", short => "F"}
];
$html->{'split'} = 1;
$html->{'toc'} = -1;
$html->{dosnames} = 0;
$html->{imagebuttons} = 0;
$html->{header} = "";
$html->{footer} = "";
$html->{preNSGMLS} = sub {
$global->{NsgmlsOpts} .= " -ifmthtml ";
$global->{NsgmlsPrePipe} = "cat $global->{file}";
};
$Formats{$html->{NAME}} = $html;
# HTML escape sub. this is called-back by `parse_data' below in
# `html_preASP' to properly escape `<' and `&' characters coming from
# the SGML source.
my %html_escapes;
$html_escapes{'&'} = '&';
$html_escapes{'<'} = '<';
my $html_escape = sub {
my ($data) = @_;
# replace the char with it's HTML equivalent
$data =~ s|([&<])|$html_escapes{$1}|ge;
return ($data);
};
#
# Translate character entities and escape HTML special chars.
#
$html->{preASP} = sub
{
my ($infile, $outfile) = @_;
# note the conversion of `sdata_dirs' list to an anonymous array to
# make a single argument
my $char_maps = load_char_maps ('.2html', [ Text::EntityMap::sdata_dirs() ]);
while (<$infile>)
{
if (/^-/)
{
my ($str) = $';
chop ($str);
print $outfile "-" . parse_data ($str, $char_maps, $html_escape) . "\n";
}
elsif (/^A/)
{
/^A(\S+) (IMPLIED|CDATA|NOTATION|ENTITY|TOKEN)( (.*))?$/
|| die "bad attribute data: $_\n";
my ($name,$type,$value) = ($1,$2,$4);
if ($type eq "CDATA")
{
# CDATA attributes get translated also
$value = parse_data ($value, $char_maps, $html_escape);
}
print $outfile "A$name $type $value\n";
}
else
{
print $outfile $_;
}
}
return 0;
};
#
# Take the sgmlsasp output, and make something
# useful from it.
#
$html->{postASP} = sub
{
my $infile = shift;
my $filename = $global->{filename};
#
# Set various stuff as a result of option processing.
#
my $ext = "html";
$ext = "htm" if $html->{dosnames};
my $img = 0;
$img = 1 if $html->{imagebuttons};
#
# Bring in file
#
my @file = <$infile>;
#
# Find references
#
&{$fixref->{init}}($html->{'split'});
LINE: foreach (@file) {
foreach my $pat (keys %{$fixref->{rules}}) {
if (/$pat/) {
# Call rule function then skip to next line
&{$fixref->{rules}->{$pat}}; next LINE;
}
}
&{$fixref->{defaultrule}};
}
&{$fixref->{finish}};
#
# Run through html2html, preserving stdout
# Also, handle prehtml.sed's tasks
#
my $filter = "";
# $filter = "|$main::progs->{NKF} -e" if ($global->{language} eq "ja");
open SAVEOUT, ">&STDOUT";
open STDOUT, "$filter>$filename.$ext" or die qq(Cannot open "$filename.$ext");
&{$html2html->{init}}($html->{'split'}, $ext, $img, $filename,
$fixref->{filenum}, $fixref->{lrec},
$html->{'header'}, $html->{'footer'}, $html->{'toc'},
$global->{tmpbase}, $global->{debug});
LINE: foreach (@file) {
s,
,,g; # remove empty
containers
foreach my $pat (keys %{$html2html->{rules}}) {
if (/$pat/) {
# Call rule function then skip to next line
&{$html2html->{rules}->{$pat}}; next LINE;
}
}
&{$html2html->{defaultrule}};
}
&{$html2html->{finish}};
close STDOUT;
open STDOUT, ">&SAVEOUT";
return 0;
};
1;
bird2-2.17.5/doc/sbase/dist/fmt_latex2e.pl 0000664 0000000 0000000 00000036172 15211753245 0020202 0 ustar 00root root 0000000 0000000 #
# fmt_latex2e.pl
#
# $Id$
#
# LaTeX-specific driver stuff
#
# Copyright 1996, Cees de Groot
#
# Support for PDF files: added by Juan Jose Amor, January 2000
# Copyright 2000, Juan Jose Amor
#
package LinuxDocTools::fmt_latex2e;
use strict;
use LinuxDocTools::CharEnts;
use LinuxDocTools::Vars;
use LinuxDocTools::Lang;
use File::Copy;
my $latex2e = {};
$latex2e->{NAME} = "latex2e";
$latex2e->{HELP} = <{OPTIONS} = [
{ option => "output", type => "l",
'values' => [ "dvi", "tex", "ps", "pdf" ], short => "o" },
{ option => "bibtex", type => "f", short => "b" },
{ option => "makeindex", type => "f", short => "m" },
{ option => "pagenumber", type => "i", short => "n" },
{ option => "quick", type => "f", short => "q" },
{ option => "dvips", type => "l",
'values' => [ "dvips", "dvi2ps", "jdvi2kps" ], short => "s" },
{ option => "latex", type => "l",
'values' => [ "latex", "hlatexp", "platex", "jlatex" ], short => "x" }
];
$latex2e->{output} = "tex";
$latex2e->{pagenumber} = 1;
$latex2e->{quick} = 0;
$latex2e->{bibtex} = 0;
$latex2e->{makeindex} = 0;
$latex2e->{latex} = "unknown";
$latex2e->{dvips} = "unknown";
$Formats{$latex2e->{NAME}} = $latex2e;
$latex2e->{preNSGMLS} = sub {
$global->{NsgmlsOpts} .= " -ifmttex ";
# for Japanese jlatex users
if ($global->{language} eq "ja" && $latex2e->{latex} eq "unknown") {
$latex2e->{latex} = "jlatex";
$latex2e->{dvips} = "dvi2ps";
# for Japanese platex users
# $latex2e->{latex} = "platex";
# $latex2e->{dvips} = "dvips";
}
# for Korean users
if ($global->{language} eq "ko" && $latex2e->{latex} eq "unknown") {
$latex2e->{latex} = "hlatexp";
}
# default process command
$latex2e->{latex} = "latex" if ($latex2e->{latex} eq "unknown");
$latex2e->{dvips} = "dvips" if ($latex2e->{dvips} eq "unknown");
$global->{NsgmlsPrePipe} = "cat $global->{file} ";
};
# extra `\\' here for standard `nsgmls' output
my %latex2e_escapes;
$latex2e_escapes{'#'} = '\\\\#';
$latex2e_escapes{'$'} = '\\\\$';
$latex2e_escapes{'%'} = '\\\\%';
$latex2e_escapes{'&'} = '\\\\&';
$latex2e_escapes{'~'} = '\\\\~{}';
$latex2e_escapes{'_'} = '\\\\_';
$latex2e_escapes{'^'} = '\\\\^{}';
$latex2e_escapes{'\\'} = '\\verb+\\+';
$latex2e_escapes{'{'} = '\\\\{';
$latex2e_escapes{'}'} = '\\\\}';
$latex2e_escapes{'>'} = '{$>$}';
$latex2e_escapes{'<'} = '{$<$}'; # wouldn't happen, but that's what'd be
$latex2e_escapes{'|'} = '{$|$}';
my $in_verb;
my $remove_comment; # added 2000 Jan 25 by t.sano
# passed to `parse_data' below in latex2e_preASP
my $latex2e_escape = sub {
my ($data) = @_;
if (!$in_verb) {
# escape special characters
$data =~ s|([#\$%&~_^\\{}<>\|])|$latex2e_escapes{$1}|ge;
}
return ($data);
};
#
# Translate character entities and escape LaTeX special chars.
#
$latex2e->{preASP} = sub
{
my ($infile, $outfile) = @_;
# note the conversion of `sdata_dirs' list to an anonymous array to
# make a single argument
my $tex_char_maps = load_char_maps ('.2tex', [ Text::EntityMap::sdata_dirs() ]);
# ASCII char maps are used in the verbatim environment because TeX
# ignores all the escapes
my $ascii_char_maps = load_char_maps ('.2ab', [ Text::EntityMap::sdata_dirs() ]);
$ascii_char_maps = load_char_maps ('.2l1b', [ Text::EntityMap::sdata_dirs() ]) if $global->{charset} eq "latin";
my $char_maps = $tex_char_maps;
# used in `latex2e_escape' anonymous sub to switch between escaping
# characters from SGML source or not, depending on whether we're in
# a VERB or CODE environment or not
$in_verb = 0;
# switch to remove empty line from TeX source or not, depending
# on whether we're in a HEADING or ABSTRACT environment or not
$remove_comment = 0;
while (<$infile>)
{
if (/^-/)
{
my ($str) = $';
chop ($str);
$_ = parse_data ($str, $char_maps, $latex2e_escape);
if ($remove_comment)
{
s/(\s+\\n)+//;
}
print $outfile "-" . $_ . "\n";
}
elsif (/^A/)
{
/^A(\S+) (IMPLIED|CDATA|NOTATION|ENTITY|TOKEN)( (.*))?$/
|| die "bad attribute data: $_\n";
my ($name,$type,$value) = ($1,$2,$4);
if ($type eq "CDATA")
{
# CDATA attributes get translated also
if ($name eq "URL" or $name eq "ID" or $name eq "CA")
{
# URL for url.sty is a kind of verbatim...
# CA is used in "tabular" element.
# Thanks to Evgeny Stambulchik, he posted this fix
# on sgml-tools list. 2000 May 17, t.sano
my $old_verb = $in_verb;
$in_verb = 1;
$value = parse_data ($value, $ascii_char_maps,
$latex2e_escape);
$in_verb = $old_verb;
}
else
{
$value = parse_data ($value, $char_maps, $latex2e_escape);
}
}
print $outfile "A$name $type $value\n";
}
elsif (/^\((VERB|CODE)/)
{
print $outfile $_;
# going into VERB/CODE section
$in_verb = 1;
$char_maps = $ascii_char_maps;
}
elsif (/^\)(VERB|CODE)/)
{
print $outfile $_;
# leaving VERB/CODE section
$in_verb = 0;
$char_maps = $tex_char_maps;
}
elsif (/^\((HEADING|ABSTRACT)/)
{
print $outfile $_;
# empty lines (comment in sgml source) do harm
# in HEADING or ABSTRACT
$remove_comment = 1;
}
elsif (/^\)(HEADING|ABSTRACT)/)
{
print $outfile $_;
# leaving HEADING or ABSTRACT section
$remove_comment = 0;
}
else
{
print $outfile $_;
}
}
};
# return the string of the name of the macro for urldef
sub latex2e_defnam($)
{
my ($num) = @_;
if ($num > 26*26*26) {
die "Too many URLs!\n";
}
my $anum = ord("a");
my $defnam = chr ($anum + ($num / 26 / 26)) .
chr ($anum + ($num / 26 % 26)) .
chr ($anum + ($num % 26));
return ($defnam);
};
#
# Take the sgmlsasp output, and make something
# useful from it.
#
$latex2e->{postASP} = sub
{
my $infile = shift;
my $filename = $global->{filename};
my $tmplatexdir = $global->{tmpbase} . "-latex-" . $$ . ".dir";
my $tmplatexnam = $tmplatexdir . "/" . $filename;
my @epsfiles = ();
my @texlines = ();
my @urldefines = ();
my @urlnames = ();
my $urlnum = 0;
my $tmpepsf;
my $saved_umask = umask;
$ENV{TEXINPUTS} .= ":$main::DataDir";
umask 0077;
mkdir ($tmplatexdir, 0700) || return -1;
#
# check epsfile is specified in source file
# check nameurl specified in source file
#
{
my $epsf;
open SGMLFILE, "<$filename.sgml";
while ()
{
# for epsfile
if ( s/^\s*/$1/ )
{
s/\s+angle=.*//;
s/\s+height=.*//;
s/\"//g;
$epsf = $_;
chop ( $epsf );
push @epsfiles, $epsf;
}
if ($latex2e->{output} eq "pdf")
{
if ( s/^\s*/$1/ )
{
s/\"//g;
$epsf = $_;
chop ( $epsf );
push @epsfiles, $epsf;
}
}
}
close SGMLFILE;
}
{
my $urlid;
my $urlnam;
my $urldef;
while (<$infile>)
{
push @texlines, $_;
# for nameurl
if ( /\\nameurl/ )
{
($urlid, $urlnam) = ($_ =~ /\\nameurl\{(.*)\}\{(.*)\}/);
print $urlnum . ": " . $urlid . "\n" if ( $global->{debug} );
$urldef = latex2e_defnam($urlnum) . "url";
s/\\nameurl\{.*\}\{.*\}/{\\em $urlnam} {\\tt \\$urldef}/;
push @urlnames, $_;
push @urldefines, "\\urldef{\\$urldef} \\url{$urlid}\n";
$urlnum++;
}
}
close $infile;
}
open OUTFILE, ">$tmplatexnam.tex";
#
# Set the correct \documentclass options.
#
{
my $langlit = ISO2English ($global->{language});
$langlit = ($langlit eq 'english') ? "" : ",$langlit";
my $replace = $global->{papersize} . 'paper' . $langlit;
my $hlatexopt = "";
$global->{charset} = "nippon" if ($global->{language} eq "ja");
$global->{charset} = "euc-kr" if ($global->{language} eq "ko");
$replace = $global->{papersize} . 'paper' if ($global->{charset} eq "nippon") || ($global->{charset} eq "euc-kr");
while (defined($texlines[0]))
{
$_ = shift @texlines;
if (/^\\documentclass/)
{
if ($global->{language} ne "en" ||
$global->{papersize} ne "a4")
{
s/\\documentclass\[.*\]/\\documentclass\[$replace\]/;
}
if ($global->{charset} eq "nippon") {
if ($latex2e->{latex} eq "platex") {
s/{article}/{jarticle}/;
} elsif ($latex2e->{latex} eq "jlatex") {
s/{article}/{j-article}/;
}
}
$_ = $_ . "\\makeindex\n" if ($latex2e->{makeindex});
}
if (/^\\usepackage.epsfig/ && ($global->{charset} eq "euc-kr"))
{
$hlatexopt = "[noautojosa]" if ($latex2e->{latex} eq "hlatexp");
$_ = $_ . "\\usepackage" . "$hlatexopt" . "{hangul}\n"
}
if ((/\\usepackage.t1enc/) &&
(($global->{charset} eq "nippon") ||
($global->{charset} eq "euc-kr")))
{
s/^/%%/;
}
if (/%end-preamble/)
{
if ($latex2e->{pagenumber})
{
$_ = $_ . '\setcounter{page}{'.
$latex2e->{pagenumber} . "}\n";
}
else
{
$_ = $_ . "\\pagestyle{empty}\n";
}
$_ = $_ . $global->{pass} . "\n" if ($global->{pass});
}
if (/\\nameurl/ && $latex2e->{output} ne "pdf")
{
$_ = shift @urlnames;
}
print OUTFILE;
if (/%end-preamble/)
{
if ($urlnum && $latex2e->{output} ne "pdf")
{
while (defined($urldefines[0]))
{
$_ = shift @urldefines;
print OUTFILE;
}
}
}
}
}
close OUTFILE;
#
# LaTeX, dvips, and assorted cleanups.
#
if ($latex2e->{output} eq "tex")
{
# comment out, because this backup action is not documented yet.
#
# if ( -e "$filename.tex" ) {
# rename ("$filename.tex", "$filename.tex.back");
# }
umask $saved_umask;
copy ("$tmplatexnam.tex", "$filename.tex");
if ( ! $global->{debug} )
{
unlink ("$tmplatexnam.tex");
rmdir ($tmplatexdir) || return -1;
}
return 0;
}
#
# Run LaTeX in nonstop mode so it won't prompt & hang on errors.
# Suppress the output of LaTeX on all but the last pass, after
# references have been resolved. This avoids large numbers of
# spurious warnings.
#
my $current_dir;
chop ($current_dir = `pwd`);
print $current_dir . "\n" if ( $global->{debug} );
#
# copy epsfiles specified in tex file
#
for my $epsf ( @epsfiles )
{
$tmpepsf = $tmplatexdir . "/" . $epsf;
print $epsf . " " . $tmpepsf . "\n" if ( $global->{debug} );
copy ("$epsf", "$tmpepsf") or die "can not copy graphics\n";
}
#
# go to the temporary directory
chdir ($tmplatexdir);
my ($latexcommand) = "$latex2e->{latex} '\\nonstopmode\\input{$filename.tex}'";
#
# We run pdflatex instead of latex if user selected pdf output
#
if ($latex2e->{output} eq "pdf")
{
$latexcommand = "pdflatex '\\nonstopmode\\input{$filename.tex}'";
}
#
# run hlatex if hlatexp is used
# for pdf: how about status?(for hlatex and hlatexp)
#
if ($latex2e->{latex} eq "hlatexp")
{
#$latex2e->{output} = "ps" if ($latex2e->{output} eq "pdf");
$latexcommand = "hlatex '\\nonstopmode\\input{$filename.tex}'";
}
#
# We use jlatex for Japanese encoded (euc-jp) characters.
# pdf support for Japanese are not yet. use ps for the time being.
#
if ($global->{charset} eq "nippon")
{
$latex2e->{output} = "ps" if ($latex2e->{output} eq "pdf");
$latexcommand = "$latex2e->{latex} '\\nonstopmode\\input{$filename.tex}'"
}
my ($suppress) = $latex2e->{quick} ? "" : ' >/dev/null';
system $latexcommand . $suppress || die "LaTeX problem\n";
$latex2e->{bibtex} && system "bibtex $filename.tex";
$latex2e->{quick} || system $latexcommand . ' >/dev/null';
$latex2e->{quick} || system $latexcommand;
if ( ! $global->{debug} )
{
my @suffixes = qw(log blg aux toc lof lot dlog bbl out);
for my $suf (@suffixes)
{
unlink "$tmplatexnam.$suf";
}
}
#
# go back to the working directory
chdir ($current_dir);
#
# output dvi file
if ($latex2e->{output} eq "dvi")
{
# comment out, because this backup action is not documented yet.
#
# if ( -e "$filename.dvi" )
# {
# rename ("$filename.dvi", "$filename.dvi.back");
# }
umask $saved_umask;
copy ("$tmplatexnam.dvi", "$filename.dvi");
if ( $global->{debug} )
{
print "Temporary files are in $tmplatexdir\n";
print "Please check there and remove them manually.\n";
} else {
unlink ("$tmplatexnam.tex", "$tmplatexnam.dvi");
for my $epsf ( @epsfiles )
{
$tmpepsf = $tmplatexdir . "/" . $epsf;
print $tmpepsf . "\n" if ( $global->{debug} );
unlink ("$tmpepsf");
}
rmdir ($tmplatexdir) || return -1;
}
return 0;
}
#
# output pdf file
if ($latex2e->{output} eq "pdf")
{
# comment out, because this backup action is not documented yet.
#
# if ( -e "$filename.pdf" )
# {
# rename ("$filename.pdf", "$filename.pdf.back");
# }
umask $saved_umask;
copy ("$tmplatexnam.pdf", "$filename.pdf");
if ( $global->{debug} )
{
print "Temporary files are in $tmplatexdir\n";
print "Please check there and remove them manually.\n";
} else {
unlink ("$tmplatexnam.tex", "$tmplatexnam.pdf");
for my $epsf ( @epsfiles )
{
$tmpepsf = $tmplatexdir . "/" . $epsf;
print $tmpepsf . "\n" if ( $global->{debug} );
unlink ("$tmpepsf");
}
rmdir ($tmplatexdir) || return -1;
}
return 0;
}
#
# convert dvi into ps using dvips command
chdir ($tmplatexdir);
if ($latex2e->{dvips} eq "dvi2ps")
{
`dvi2ps -q -o $global->{papersize} -c $tmplatexnam.ps $filename.dvi`;
}
elsif ($latex2e->{dvips} eq "jdvi2kps")
{
`jdvi2kps -q -pa $global->{papersize} -o $tmplatexnam.ps $filename.dvi`;
}
else
{
`dvips -R -q -t $global->{papersize} -o $tmplatexnam.ps $filename.dvi`;
}
chdir ($current_dir);
# comment out, because this backup action is not documented yet.
#
# if ( -e "$filename.ps" )
# {
# rename ("$filename.ps", "$filename.ps.back");
# }
umask $saved_umask;
copy ("$tmplatexnam.ps", "$filename.ps");
unlink ("$tmplatexnam.ps");
if ( $global->{debug} )
{
print "Temporary files are in $tmplatexdir\n";
print "Please check there and remove them manually.\n";
} else {
unlink ("$tmplatexnam.tex", "$tmplatexnam.dvi", "$tmplatexnam.ps");
for my $epsf ( @epsfiles )
{
$tmpepsf = $tmplatexdir . "/" . $epsf;
print $tmpepsf . "\n" if ( $global->{debug} );
unlink ("$tmpepsf");
}
rmdir ($tmplatexdir) || return -1;
}
return 0;
};
1;
bird2-2.17.5/doc/sbase/dist/fmt_txt.pl 0000664 0000000 0000000 00000021774 15211753245 0017457 0 ustar 00root root 0000000 0000000 #
# fmt_txt.pl
#
# $Id$
#
# TXT-specific driver stuff
#
# Copyright 1996, Cees de Groot
#
package LinuxDocTools::fmt_txt;
use strict;
use File::Copy;
use Text::EntityMap;
use LinuxDocTools::CharEnts;
use LinuxDocTools::Lang;
use LinuxDocTools::Vars;
use LinuxDocTools::Utils qw(create_temp);
my $txt = {};
$txt->{NAME} = "txt";
$txt->{HELP} = "";
$txt->{OPTIONS} = [
{ option => "manpage", type => "f", short => "m" },
{ option => "filter", type => "f", short => "f" },
{ option => "blanks", type => "i", short => "b" }
];
$txt->{manpage} = 0;
$txt->{filter} = 0;
$txt->{blanks} = 3;
$Formats{$txt->{NAME}} = $txt;
#
# Set correct NsgmlsOpts
#
$txt->{preNSGMLS} = sub
{
if ($txt->{manpage})
{
$global->{NsgmlsOpts} .= " -iman ";
$global->{charset} = "man";
}
else
{
$global->{NsgmlsOpts} .= " -ifmttxt ";
$global->{charset} = "latin1" if $global->{charset} eq "latin";
}
#
# Is there a cleaner solution than this? Can't do it earlier,
# would show up in the help messages...
#
# the language support ja.
# the charset support nippon.
#
$global->{format} = $global->{charset};
$global->{charset} = "nippon" if $global->{language} eq "ja";
$global->{format} = "groff" if $global->{format} eq "ascii";
$global->{format} = "groff" if $global->{format} eq "nippon";
$global->{format} = "groff" if $global->{format} eq "euc-kr";
$ENV{SGML_SEARCH_PATH} =~ s/txt/$global->{format}/;
$Formats{"groff"} = $txt;
$Formats{"latin1"} = $txt;
$Formats{"man"} = $txt;
$global->{NsgmlsPrePipe} = "cat $global->{file} " ;
};
# Ascii escape sub. this is called-back by `parse_data' below in
# `txt_preASP' to properly escape `\' characters coming from the SGML
# source.
my $txt_escape = sub {
my ($data) = @_;
$data =~ s|"|\\\&\"|g; # Insert zero-width space in front of "
$data =~ s|^\.|\\&.|; # ditto in front of . at start of line
$data =~ s|\\|\\\\|g; # Escape backslashes
return ($data);
};
#
# Run the file through the genertoc utility before sgmlsasp. Not necessary
# when producing a manpage. A lot of code from FJM, untested by me.
#
$txt->{preASP} = sub
{
my ($infile, $outfile) = @_;
my (@toc, @lines);
my $char_maps = load_char_maps ('.2tr', [ Text::EntityMap::sdata_dirs() ]);
if ( $global->{charset} eq "latin1" )
{
$char_maps = load_char_maps ('.2l1tr', [ Text::EntityMap::sdata_dirs() ]);
}
if ($txt->{manpage})
{
while (<$infile>)
{
if (/^-/)
{
my ($str) = $';
chop ($str);
print $outfile "-" .
parse_data ($str, $char_maps, $txt_escape) . "\n";
next;
}
elsif (/^A/)
{
/^A(\S+) (IMPLIED|CDATA|NOTATION|ENTITY|TOKEN)( (.*))?$/
|| die "bad attribute data: $_\n";
my ($name,$type,$value) = ($1,$2,$4);
if ($type eq "CDATA")
{
# CDATA attributes get translated also
$value = parse_data ($value, $char_maps, $txt_escape);
}
print $outfile "A$name $type $value\n";
next;
}
#
# Default action if not skipped over with next: copy in to out.
#
print $outfile $_;
}
return;
}
# note the conversion of `sdata_dirs' list to an anonymous array to
# make a single argument
#
# Build TOC. The file is read into @lines in the meantime, we need to
# traverse it twice.
#
push (@toc, "(HLINE\n");
push (@toc, ")HLINE\n");
push (@toc, "(P\n");
push (@toc, "-" . Xlat ("Table of Contents") . "\n");
push (@toc, ")P\n");
push (@toc, "(VERB\n");
my (@prevheader, @header);
my $appendix = 0;
my $nonprint = 0;
while (<$infile>)
{
push (@lines, $_);
if (/^\(SECT(.*)/)
{
@prevheader = @header;
@header = @header[0..$1];
if ($appendix == 1)
{
$header[$1] = "A";
$appendix = 0;
} else
{
$header[$1]++;
}
}
if (/^\(APPEND(.*)/)
{
$appendix = 1;
}
if (/^\(HEADING/)
{
$_ = <$infile>;
s/\\n/ /g;
push (@lines, $_);
chop;
s/^-//;
$_ = join(".",@header) . " " . $_;
s/\(\\[0-9][0-9][0-9]\)/\\\1/g;
if (!$#header)
{
# put a newline before top-level sections unless previous was also
# a top level section
$_ = "\\n" . $_ unless (!$#prevheader);
# put a . and a space after top level sections
s/ /. /;
##### $_ = "-" . $_ . "\\n";
$_ = "-" . $_;
}
else
{
# subsections get indentation matching hierarchy
$_ = "-" . " " x $#header . $_;
}
# remove tags from a toc
s/\)TT//g;
s/\(TT//g;
s/\)IT//g;
s/\(IT//g;
s/\)EM//g;
s/\(EM//g;
s/\)BF//g;
s/\(BF//g;
s/AID * CDATA.*$//g;
s/\)LABEL//g;
s/\(LABEL//g;
push(@toc, parse_data ($_, $char_maps, $txt_escape));
$_ = <$infile>;
while (!/^\)HEADING/) {
s/\\n/ /g; ####
push(@lines, $_);
chop;
s/^-//;
# remove tags from a toc
s/\)TT//g;
s/\(TT//g;
s/\)IT//g;
s/\(IT//g;
s/\)EM//g;
s/\(EM//g;
s/\)BF//g;
s/\(BF//g;
s/AID * CDATA.*$//g;
s/\)LABEL//g;
s/\(LABEL//g;
# remove NIDX, NCDX from a toc entry
if (/^\(NIDX$/ || /^\(NCDX$/) { $nonprint = 1; }
if (/^\)NIDX$/ || /^\)NCDX$/) { $nonprint = 1; }
# $_ = "-" . $_ . "\\n";
push(@toc, parse_data ($_, $char_maps, $txt_escape))
if (! $nonprint);
$_ = <$infile>;
}
s/\\n/ /g; ###
push(@lines, $_);
push(@toc, "\\n\n");
}
}
push (@toc, ")VERB\n");
push (@toc, "(HLINE\n");
push (@toc, ")HLINE\n");
my $inheading = 0;
my $tipo = '';
for (@lines)
{
if ($inheading)
{
next if (/^\)TT/ || /^\(TT/ || /^\)IT/ || /^\(IT/ ||
/^\)EM/ || /^\(EM/ || /^\)BF/ || /^\(BF/);
if (/^-/)
{
$tipo .= $' ;
chop ($tipo);
$tipo .= " " unless $tipo =~ / $/;
}
else
{
$tipo =~ s/ $//;
if ($tipo)
{
print $outfile "-"
. parse_data ($tipo, $char_maps, $txt_escape)
. "\n";
}
print $outfile $_;
$tipo = '';
}
if (/^\)HEADING/)
{
$inheading = 0;
}
next;
}
if (/^\(HEADING/)
{
#
# Go into heading processing mode.
#
$tipo = '';
$inheading = 1;
}
if (/^\(TOC/)
{
print $outfile @toc;
next;
}
if (/^-/)
{
my ($str) = $';
chop ($str);
print $outfile "-" . parse_data ($str, $char_maps, $txt_escape) . "\n";
next;
}
elsif (/^A/)
{
/^A(\S+) (IMPLIED|CDATA|NOTATION|ENTITY|TOKEN)( (.*))?$/
|| die "bad attribute data: $_\n";
my ($name,$type,$value) = ($1,$2,$4);
if ($type eq "CDATA")
{
# CDATA attributes get translated also
$value = parse_data ($value, $char_maps, $txt_escape);
}
print $outfile "A$name $type $value\n";
next;
}
#
# Default action if not skipped over with next: copy in to out.
#
print $outfile $_;
}
};
#
# Take the sgmlsasp output, and make something
# useful from it.
#
$txt->{postASP} = sub
{
my $infile = shift;
my ($outfile, $groffout);
if ($txt->{manpage})
{
$outfile = new FileHandle ">$global->{filename}.man";
}
else
{
create_temp("$global->{tmpbase}.txt.1");
$outfile = new FileHandle
"|$main::progs->{GROFF} $global->{pass} -T $global->{charset} -t $main::progs->{GROFFMACRO} >\"$global->{tmpbase}.txt.1\"";
}
#
# Feed $outfile with roff input.
#
while (<$infile>)
{
unless (/^\.DS/.../^\.DE/)
{
s/^[ \t]{1,}(.*)/$1/g;
}
s/^\.[ \t].*/\\\&$&/g;
s/\\fC/\\fR/g;
s/^.ft C/.ft R/g;
print $outfile $_;
}
$outfile->close;
#
# If we were making a manpage, we're done. Otherwise, a little bit
# of work is left.
#
if ($txt->{manpage})
{
return 0;
}
else
{
$outfile->open (">$global->{filename}.txt");
$groffout = new FileHandle "<$global->{tmpbase}.txt.1";
my $count = 0;
if ($txt->{filter})
{
while (<$groffout>)
{
s/[^\cH][^\cH]\cH\cH//g;
s/.//g;
if ($txt->{blanks})
{
$count = &{$txt->{cutblank}}($count, $outfile, $_);
}
else
{
print $outfile $_;
}
}
}
else
{
if ($txt->{blanks})
{
while (<$groffout>)
{
$count = &{$txt->{cutblank}}($count, $outfile, $_);
}
}
else
{
copy ($groffout, $outfile);
}
}
}
$groffout->close;
$outfile->close;
return 0;
};
$txt->{cutblank} = sub
{
my ($num, $out, $in) = @_;
if ( $in =~ /^$/ )
{
$num++;
}
else
{
$num = 0;
}
if ( $num <= $txt->{blanks} )
{
print $out $in;
}
return ($num);
};
1;
bird2-2.17.5/doc/sbase/dtd/ 0000775 0000000 0000000 00000000000 15211753245 0015232 5 ustar 00root root 0000000 0000000 bird2-2.17.5/doc/sbase/dtd/birddoc.dtd 0000664 0000000 0000000 00000042346 15211753245 0017346 0 ustar 00root root 0000000 0000000
%isoent;
' >
' >
' -- formula begin -- >
'>
">
">
' -- formula end -- >
" >
" >
' >
">
bird2-2.17.5/doc/sbase/dtd/catalog 0000664 0000000 0000000 00000004133 15211753245 0016570 0 ustar 00root root 0000000 0000000 -- This is a DTD, but will be read as -*- sgml -*- --
-- ================================================= --
-- $Id$
This is dtd/catalog for SGML-Tools.
Initial revision June 23st, 1997, by B. Kreimeier
$Log$
Revision 1.1 2000-05-29 12:05:22 mj
Renamed the DTD from linuxdoc to birddoc.
Pavel, please check whether it builds in your environment as well.
Revision 1.7 1998/10/13 12:12:09 cg
* Clean up catalog file. (CdG)
Revision 1.6 1998/03/09 21:10:14 cg
* Removed sgmltool.dtd. (CdG)
Revision 1.5 1998/01/08 19:59:54 cg
* Add empty line, it gave problems. (CdG)
Revision 1.4 1997/12/09 20:56:15 cg
* Added html32.dtd (with a modified reference to ISOent) and updated
catalog accordingly. You can now do sgmlcheck on HTML files. (CdG)
Revision 1.3 1997/07/09 13:27:12 cg
* Completely new DTD setup by Bernd (BK).
--
-- ================================================= --
-- Revision Comments --
-- BK/97/06/23: added a header, changed for 0.99.12 --
-- ================================================= --
DOCTYPE "BIRDDOC" "birddoc.dtd"
-- Linuxdoc96.dtd, frozen orignal Linuxdoc DTD --
DOCTYPE "LINUXDOC" "linuxdoc.dtd"
PUBLIC "-//LinuxDoc//DTD LinuxDoc 96//EN" linuxdoc96.dtd
-- Linuxdoc97 Strict DTD --
PUBLIC "-//LinuxDoc//DTD LinuxDoc 97//EN" linuxdoc97.dtd
-- outdated and shared entities --
ENTITY %common "common"
ENTITY %isoent "isoent"
ENTITY %deprec96 "deprec96"
-- for development and debug, internal use only --
DOCTYPE "QWERTZ" "qwertz.dtd"
DOCTYPE "TEST" "test.dtd"
-- for SGML validation --
DOCTYPE "HTML" "html32.dtd"
PUBLIC "-//W3C//DTD HTML 3.2 Final//EN" html32.dtd
-- obsolete --
ENTITY %general "general"
-- ================================================= --
-- end of dtd/catalog --
--
Local Variables:
mode: sgml
End: --
-- ================================================= --
bird2-2.17.5/doc/sbase/dtd/common 0000664 0000000 0000000 00000005472 15211753245 0016455 0 ustar 00root root 0000000 0000000
bird2-2.17.5/doc/sbase/dtd/isoent 0000664 0000000 0000000 00000003557 15211753245 0016470 0 ustar 00root root 0000000 0000000
%ISOdia;
%ISOgrk3;
%ISOlat1;
%ISOnum;
%ISOpub;
bird2-2.17.5/doc/slides/ 0000775 0000000 0000000 00000000000 15211753245 0014645 5 ustar 00root root 0000000 0000000 bird2-2.17.5/doc/slides/Makefile 0000664 0000000 0000000 00000000722 15211753245 0016306 0 ustar 00root root 0000000 0000000 all: slides.dvi
slides.dvi: slides.tex
csplain slides.tex
slides.ps: slides.dvi
dvips -o slides.ps -D600 -ta4 slides.dvi
view: slides.dvi
xdvi -expert -geometry 1100x700 -l -s 4 -paper a4 -margins 1in slides.dvi
viewlarge: slides.dvi
xdvi -expert -geometry 1024x700 -l -s 1 -paper a4 -margins 1in slides.dvi
viewreal: slides.dvi
xdvi -expert -geometry 1024x700 -l -s 6 -paper a4 -margins 1in slides.dvi
clean:
rm -f *~ *.log *.tfm *.*pk *.*gf *.ps *.dvi
bird2-2.17.5/doc/slides/logo.eps 0000664 0000000 0000000 00000055510 15211753245 0016324 0 ustar 00root root 0000000 0000000 %!PS-Adobe-3.0 EPSF-3.0
%%BoundingBox: 16 477 580 811
%%Creator: CorelDRAW 8
%%Title: C:\Dokumenty\bird\333333.eps
%%CreationDate: Sun Jun 25 11:14:25 2000
%%DocumentProcessColors: Black
%%DocumentSuppliedResources: (atend)
%%EndComments
%%BeginProlog
/AutoFlatness false def
/AutoSteps 0 def
/CMYKMarks true def
/UseLevel 1 def
%Color profile: PROFILES.CCM - Obecn profil tiskrny CMYK
%%BeginResource: procset wCorel8Dict 8.0 0
/wCorel8Dict 300 dict def wCorel8Dict begin
% Copyright (c)1992-97 Corel Corporation
% All rights reserved. v8.0 r0.7
/bd{bind def}bind def/ld{load def}bd/xd{exch def}bd/_ null def/rp{{pop}repeat}
bd/@cp/closepath ld/@gs/gsave ld/@gr/grestore ld/@np/newpath ld/Tl/translate ld
/$sv 0 def/@sv{/$sv save def}bd/@rs{$sv restore}bd/spg/showpage ld/showpage{}
bd currentscreen/@dsp xd/$dsp/@dsp def/$dsa xd/$dsf xd/$sdf false def/$SDF
false def/$Scra 0 def/SetScr/setscreen ld/setscreen{pop pop pop}bd/@ss{2 index
0 eq{$dsf 3 1 roll 4 -1 roll pop}if exch $Scra add exch load SetScr}bd
/SepMode_5 where{pop}{/SepMode_5 0 def}ifelse/CurrentInkName_5 where{pop}
{/CurrentInkName_5(Composite)def}ifelse/$ink_5 where{pop}{/$ink_5 -1 def}
ifelse/$c 0 def/$m 0 def/$y 0 def/$k 0 def/$t 1 def/$n _ def/$o 0 def/$fil 0
def/$C 0 def/$M 0 def/$Y 0 def/$K 0 def/$T 1 def/$N _ def/$O 0 def/$PF false
def/s1c 0 def/s1m 0 def/s1y 0 def/s1k 0 def/s1t 0 def/s1n _ def/$bkg false def
/SK 0 def/SM 0 def/SY 0 def/SC 0 def/$op false def matrix currentmatrix/$ctm xd
/$ptm matrix def/$ttm matrix def/$stm matrix def/$ffpnt true def
/CorelDrawReencodeVect[16#0/grave 16#5/breve 16#6/dotaccent 16#8/ring
16#A/hungarumlaut 16#B/ogonek 16#C/caron 16#D/dotlessi 16#27/quotesingle
16#60/grave 16#7C/bar
16#82/quotesinglbase/florin/quotedblbase/ellipsis/dagger/daggerdbl
16#88/circumflex/perthousand/Scaron/guilsinglleft/OE
16#91/quoteleft/quoteright/quotedblleft/quotedblright/bullet/endash/emdash
16#98/tilde/trademark/scaron/guilsinglright/oe 16#9F/Ydieresis
16#A1/exclamdown/cent/sterling/currency/yen/brokenbar/section
16#a8/dieresis/copyright/ordfeminine/guillemotleft/logicalnot/minus/registered/macron
16#b0/degree/plusminus/twosuperior/threesuperior/acute/mu/paragraph/periodcentered
16#b8/cedilla/onesuperior/ordmasculine/guillemotright/onequarter/onehalf/threequarters/questiondown
16#c0/Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE/Ccedilla
16#c8/Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex/Idieresis
16#d0/Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis/multiply
16#d8/Oslash/Ugrave/Uacute/Ucircumflex/Udieresis/Yacute/Thorn/germandbls
16#e0/agrave/aacute/acircumflex/atilde/adieresis/aring/ae/ccedilla
16#e8/egrave/eacute/ecircumflex/edieresis/igrave/iacute/icircumflex/idieresis
16#f0/eth/ntilde/ograve/oacute/ocircumflex/otilde/odieresis/divide
16#f8/oslash/ugrave/uacute/ucircumflex/udieresis/yacute/thorn/ydieresis]def
/L2?/languagelevel where{pop languagelevel 2 ge}{false}ifelse def
/@BeginSysCorelDict{systemdict/Corel30Dict known{systemdict/Corel30Dict get
exec}if systemdict/CorelLexDict known{1 systemdict/CorelLexDict get exec}if}bd
/@EndSysCorelDict{systemdict/Corel30Dict known{end}if/EndCorelLexDict where
{pop EndCorelLexDict}if}bd AutoFlatness{/@ifl{dup currentflat exch sub 10 gt{
([Error: PathTooComplex; OffendingCommand: AnyPaintingOperator]\n)print flush
@np exit}{currentflat 2 add setflat}ifelse}bd/@fill/fill ld/fill{currentflat{
{@fill}stopped{@ifl}{exit}ifelse}bind loop setflat}bd/@eofill/eofill ld/eofill
{currentflat{{@eofill}stopped{@ifl}{exit}ifelse}bind loop setflat}bd/@clip
/clip ld/clip{currentflat{{@clip}stopped{@ifl}{exit}ifelse}bind loop setflat}
bd/@eoclip/eoclip ld/eoclip{currentflat{{@eoclip}stopped{@ifl}{exit}ifelse}
bind loop setflat}bd/@stroke/stroke ld/stroke{currentflat{{@stroke}stopped
{@ifl}{exit}ifelse}bind loop setflat}bd}if L2?{/@ssa{true setstrokeadjust}bd}{
/@ssa{}bd}ifelse/d/setdash ld/j/setlinejoin ld/J/setlinecap ld/M/setmiterlimit
ld/w/setlinewidth ld/O{/$o xd}bd/R{/$O xd}bd/W/eoclip ld/c/curveto ld/C/c ld/l
/lineto ld/L/l ld/rl/rlineto ld/m/moveto ld/n/newpath ld/N/newpath ld/P{11 rp}
bd/u{}bd/U{}bd/A{pop}bd/q/@gs ld/Q/@gr ld/&{}bd/@j{@sv @np}bd/@J{@rs}bd/g{1
exch sub/$k xd/$c 0 def/$m 0 def/$y 0 def/$t 1 def/$n _ def/$fil 0 def}bd/G{1
sub neg/$K xd _ 1 0 0 0/$C xd/$M xd/$Y xd/$T xd/$N xd}bd/k{1 index type
/stringtype eq{/$t xd/$n xd}{/$t 0 def/$n _ def}ifelse/$k xd/$y xd/$m xd/$c xd
/$fil 0 def}bd/K{1 index type/stringtype eq{/$T xd/$N xd}{/$T 0 def/$N _ def}
ifelse/$K xd/$Y xd/$M xd/$C xd}bd/x/k ld/X/K ld/sf{1 index type/stringtype eq{
/s1t xd/s1n xd}{/s1t 0 def/s1n _ def}ifelse/s1k xd/s1y xd/s1m xd/s1c xd}bd/i{
dup 0 ne{setflat}{pop}ifelse}bd/v{4 -2 roll 2 copy 6 -2 roll c}bd/V/v ld/y{2
copy c}bd/Y/y ld/@w{matrix rotate/$ptm xd matrix scale $ptm dup concatmatrix
/$ptm xd 1 eq{$ptm exch dup concatmatrix/$ptm xd}if 1 w}bd/@g{1 eq dup/$sdf xd
{/$scp xd/$sca xd/$scf xd}if}bd/@G{1 eq dup/$SDF xd{/$SCP xd/$SCA xd/$SCF xd}
if}bd/@D{2 index 0 eq{$dsf 3 1 roll 4 -1 roll pop}if 3 copy exch $Scra add exch
load SetScr/$dsp xd/$dsa xd/$dsf xd}bd/$ngx{$SDF{$SCF SepMode_5 0 eq{$SCA}
{$dsa}ifelse $SCP @ss}if}bd/p{/$pm xd 7 rp/$pyf xd/$pxf xd/$pn xd/$fil 1 def}
bd/@MN{2 copy le{pop}{exch pop}ifelse}bd/@MX{2 copy ge{pop}{exch pop}ifelse}bd
/InRange{3 -1 roll @MN @MX}bd/@sqr{dup 0 rl dup 0 exch rl neg 0 rl @cp}bd
/currentscale{1 0 dtransform matrix defaultmatrix idtransform dup mul exch dup
mul add sqrt 0 1 dtransform matrix defaultmatrix idtransform dup mul exch dup
mul add sqrt}bd/@unscale{}bd/wDstChck{2 1 roll dup 3 -1 roll eq{1 add}if}bd
/@dot{dup mul exch dup mul add 1 exch sub}bd/@lin{exch pop abs 1 exch sub}bd
/cmyk2rgb{3{dup 5 -1 roll add 1 exch sub dup 0 lt{pop 0}if exch}repeat pop}bd
/rgb2cmyk{3{1 exch sub 3 1 roll}repeat 3 copy @MN @MN 3{dup 5 -1 roll sub neg
exch}repeat}bd/rgb2g{2 index .299 mul 2 index .587 mul add 1 index .114 mul add
4 1 roll pop pop pop}bd/WaldoColor_5 where{pop}{/SetRgb/setrgbcolor ld/GetRgb
/currentrgbcolor ld/SetGry/setgray ld/GetGry/currentgray ld/SetRgb2 systemdict
/setrgbcolor get def/GetRgb2 systemdict/currentrgbcolor get def/SetHsb
systemdict/sethsbcolor get def/GetHsb systemdict/currenthsbcolor get def
/rgb2hsb{SetRgb2 GetHsb}bd/hsb2rgb{3 -1 roll dup floor sub 3 1 roll SetHsb
GetRgb2}bd/setcmykcolor where{pop/SetCmyk_5/setcmykcolor ld}{/SetCmyk_5{
cmyk2rgb SetRgb}bd}ifelse/currentcmykcolor where{pop/GetCmyk/currentcmykcolor
ld}{/GetCmyk{GetRgb rgb2cmyk}bd}ifelse/setoverprint where{pop}{/setoverprint{
/$op xd}bd}ifelse/currentoverprint where{pop}{/currentoverprint{$op}bd}ifelse
/@tc_5{5 -1 roll dup 1 ge{pop}{4{dup 6 -1 roll mul exch}repeat pop}ifelse}bd
/@trp{exch pop 5 1 roll @tc_5}bd/setprocesscolor_5{SepMode_5 0 eq{SetCmyk_5}{0
4 $ink_5 sub index exch pop 5 1 roll pop pop pop pop SepsColor true eq{$ink_5 3
gt{1 sub neg SetGry}{0 0 0 4 $ink_5 roll SetCmyk_5}ifelse}{1 sub neg SetGry}
ifelse}ifelse}bd/findcmykcustomcolor where{pop}{/findcmykcustomcolor{5 array
astore}bd}ifelse/setcustomcolor where{pop}{/setcustomcolor{exch aload pop
SepMode_5 0 eq{pop @tc_5 setprocesscolor_5}{CurrentInkName_5 eq{4 index}{0}
ifelse 6 1 roll 5 rp 1 sub neg SetGry}ifelse}bd}ifelse/@scc_5{dup type
/booleantype eq{setoverprint}{1 eq setoverprint}ifelse dup _ eq{pop
setprocesscolor_5 pop}{findcmykcustomcolor exch setcustomcolor}ifelse SepMode_5
0 eq{true}{GetGry 1 eq currentoverprint and not}ifelse}bd/colorimage where{pop
/ColorImage{colorimage}def}{/ColorImage{/ncolors xd pop/dataaq xd{dataaq
ncolors dup 3 eq{/$dat xd 0 1 $dat length 3 div 1 sub{dup 3 mul $dat 1 index
get 255 div $dat 2 index 1 add get 255 div $dat 3 index 2 add get 255 div rgb2g
255 mul cvi exch pop $dat 3 1 roll put}for $dat 0 $dat length 3 idiv
getinterval pop}{4 eq{/$dat xd 0 1 $dat length 4 div 1 sub{dup 4 mul $dat 1
index get 255 div $dat 2 index 1 add get 255 div $dat 3 index 2 add get 255 div
$dat 4 index 3 add get 255 div cmyk2rgb rgb2g 255 mul cvi exch pop $dat 3 1
roll put}for $dat 0 $dat length ncolors idiv getinterval}if}ifelse}image}bd
}ifelse/setcmykcolor{1 5 1 roll _ currentoverprint @scc_5/$ffpnt xd}bd
/currentcmykcolor{0 0 0 0}bd/setrgbcolor{rgb2cmyk setcmykcolor}bd
/currentrgbcolor{currentcmykcolor cmyk2rgb}bd/sethsbcolor{hsb2rgb setrgbcolor}
bd/currenthsbcolor{currentrgbcolor rgb2hsb}bd/setgray{dup dup setrgbcolor}bd
/currentgray{currentrgbcolor rgb2g}bd/InsideDCS false def/IMAGE systemdict
/image get def/image{InsideDCS{IMAGE}{/EPSDict where{pop SepMode_5 0 eq{IMAGE}
{dup type/dicttype eq{dup/ImageType get 1 ne{IMAGE}{dup dup/BitsPerComponent
get 8 eq exch/BitsPerComponent get 1 eq or currentcolorspace 0 get/DeviceGray
eq and{CurrentInkName_5(Black)eq{IMAGE}{dup/DataSource get/TCC xd/Height get
abs{TCC pop}repeat}ifelse}{IMAGE}ifelse}ifelse}{2 index 1 ne{CurrentInkName_5
(Black)eq{IMAGE}{/TCC xd pop pop exch pop abs{TCC pop}repeat}ifelse}{IMAGE}
ifelse}ifelse}ifelse}{IMAGE}ifelse}ifelse}bd}ifelse/WaldoColor_5 true def/@sft
{$tllx $pxf add dup $tllx gt{$pwid sub}if/$tx xd $tury $pyf sub dup $tury lt
{$phei add}if/$ty xd}bd/@stb{pathbbox/$ury xd/$urx xd/$lly xd/$llx xd}bd/@ep{{
cvx exec}forall}bd/@tp{@sv/$in true def 2 copy dup $lly le{/$in false def}if
$phei sub $ury ge{/$in false def}if dup $urx ge{/$in false def}if $pwid add
$llx le{/$in false def}if $in{@np 2 copy m $pwid 0 rl 0 $phei neg rl $pwid neg
0 rl 0 $phei rl clip @np $pn cvlit load aload pop 7 -1 roll 5 index sub 7 -1
roll 3 index sub Tl matrix currentmatrix/$ctm xd @ep pop pop pop pop}{pop pop
}ifelse @rs}bd/@th{@sft 0 1 $tly 1 sub{dup $psx mul $tx add{dup $llx gt{$pwid
sub}{exit}ifelse}loop exch $phei mul $ty exch sub 0 1 $tlx 1 sub{$pwid mul 3
copy 3 -1 roll add exch @tp pop}for pop pop}for}bd/@tv{@sft 0 1 $tlx 1 sub{dup
$pwid mul $tx add exch $psy mul $ty exch sub{dup $ury lt{$phei add}{exit}
ifelse}loop 0 1 $tly 1 sub{$phei mul 3 copy sub @tp pop}for pop pop}for}bd/$fm
0 def/wfill{1 $fm eq{fill}{eofill}ifelse}bd/wclip{1 $fm eq{clip}{eoclip}ifelse
}bd/@pf{@gs $ctm setmatrix $pm concat @stb wclip @sv Bburx Bbury $pm itransform
/$tury xd/$turx xd Bbllx Bblly $pm itransform/$tlly xd/$tllx xd newpath $tllx
$tlly m $tllx $tury l $turx $tury l $turx $tlly l $tllx $tlly m @cp pathbbox
@rs/$tury xd/$turx xd/$tlly xd/$tllx xd/$wid $turx $tllx sub def/$hei $tury
$tlly sub def @gs $vectpat{1 0 0 0 0 _ $o @scc_5{wfill}if}{$t $c $m $y $k $n $o
@scc_5{SepMode_5 0 eq $pfrg or{$tllx $tlly Tl $wid $hei scale <00> 8 1 false[8
0 0 1 0 0]{}imagemask}{/$bkg true def}ifelse}if}ifelse @gr $wid 0 gt $hei 0 gt
and{$pn cvlit load aload pop/$pd xd 3 -1 roll sub/$phei xd exch sub/$pwid xd
$wid $pwid div ceiling 1 add/$tlx xd $hei $phei div ceiling 1 add/$tly xd $psx
0 eq{@tv}{@th}ifelse}if @gr @np/$bkg false def}bd/@Pf{@sv SepMode_5 0 eq $Psc 0
ne or $ink_5 3 eq or{0 J 0 j[]0 d $t $c $m $y $k $n $o @scc_5 pop $ctm
setmatrix 72 1000 div dup matrix scale dup concat dup Bburx exch Bbury exch
itransform ceiling cvi/Bbury xd ceiling cvi/Bburx xd Bbllx exch Bblly exch
itransform floor cvi/Bblly xd floor cvi/Bbllx xd $Prm aload pop $Psn load exec
}{1 SetGry wfill}ifelse @rs @np}bd/F{matrix currentmatrix $sdf{$scf $sca $scp
@ss}if $fil 1 eq{@pf}{$fil 2 eq{@ff}{$fil 3 eq{@Pf}{$t $c $m $y $k $n $o @scc_5
{wfill}{@np}ifelse}ifelse}ifelse}ifelse $sdf{$dsf $dsa $dsp @ss}if setmatrix}
bd/f{@cp F}bd/S{matrix currentmatrix $ctm setmatrix $SDF{$SCF $SCA $SCP @ss}if
$T $C $M $Y $K $N $O @scc_5{matrix currentmatrix $ptm concat stroke setmatrix}
{@np}ifelse $SDF{$dsf $dsa $dsp @ss}if setmatrix}bd/s{@cp S}bd/B{@gs F @gr S}
bd/b{@cp B}bd/_E{5 array astore exch cvlit xd}bd/@cc{currentfile $dat
readhexstring pop}bd/@sm{/$ctm $ctm currentmatrix def}bd/@E{/Bbury xd/Bburx xd
/Bblly xd/Bbllx xd}bd/@c{@cp}bd/@p{/$fil 1 def 1 eq dup/$vectpat xd{/$pfrg true
def}{@gs $t $c $m $y $k $n $o @scc_5/$pfrg xd @gr}ifelse/$pm xd/$psy xd/$psx xd
/$pyf xd/$pxf xd/$pn xd}bd/@P{/$fil 3 def/$Psn xd/$Psc xd array astore/$Prm xd
}bd/@ii{concat 3 index 3 index m 3 index 1 index l 2 copy l 1 index 3 index l 3
index 3 index l clip pop pop pop pop}bd/tcc{@cc}def/@i{@sm @gs @ii 6 index 1 ne
{/$frg true def pop pop}{1 eq{s1t s1c s1m s1y s1k s1n $O @scc_5/$frg xd}{/$frg
false def}ifelse 1 eq{@gs $ctm setmatrix F @gr}if}ifelse @np/$ury xd/$urx xd
/$lly xd/$llx xd/$bts xd/$hei xd/$wid xd/$dat $wid $bts mul 8 div ceiling cvi
string def $bkg $frg or{$SDF{$SCF $SCA $SCP @ss}if $llx $lly Tl $urx $llx sub
$ury $lly sub scale $bkg{$t $c $m $y $k $n $o @scc_5 pop}if $wid $hei abs $bts
1 eq{$bkg}{$bts}ifelse[$wid 0 0 $hei neg 0 $hei 0 gt{$hei}{0}ifelse]/tcc load
$bts 1 eq{imagemask}{image}ifelse $SDF{$dsf $dsa $dsp @ss}if}{$hei abs{tcc pop}
repeat}ifelse @gr $ctm setmatrix}bd/@I{@sm @gs @ii @np/$ury xd/$urx xd/$lly xd
/$llx xd/$ncl xd/$bts xd/$hei xd/$wid xd/$dat $wid $bts mul $ncl mul 8 div
ceiling cvi string def $ngx $llx $lly Tl $urx $llx sub $ury $lly sub scale $wid
$hei abs $bts[$wid 0 0 $hei neg 0 $hei 0 gt{$hei}{0}ifelse]/@cc load false $ncl
ColorImage $SDF{$dsf $dsa $dsp @ss}if @gr $ctm setmatrix}bd/COMP 0 def
/MaskedImage false def L2?{/@I_2{@sm @gs @ii @np/$ury xd/$urx xd/$lly xd/$llx
xd/$ncl xd/$bts xd/$hei xd/$wid xd/$dat $wid $bts mul $ncl mul 8 div ceiling
cvi string def $ngx $ncl 1 eq{/DeviceGray}{$ncl 3 eq{/DeviceRGB}{/DeviceCMYK}
ifelse}ifelse setcolorspace $llx $lly Tl $urx $llx sub $ury $lly sub scale 8
dict begin/ImageType 1 def/Width $wid def/Height $hei abs def/BitsPerComponent
$bts def/Decode $ncl 1 eq{[0 1]}{$ncl 3 eq{[0 1 0 1 0 1]}{[0 1 0 1 0 1 0 1]}
ifelse}ifelse def/ImageMatrix[$wid 0 0 $hei neg 0 $hei 0 gt{$hei}{0}ifelse]def
/DataSource currentfile/ASCII85Decode filter COMP 1 eq{/DCTDecode filter}{COMP
2 eq{/RunLengthDecode filter}if}ifelse def currentdict end image $SDF{$dsf $dsa
$dsp @ss}if @gr $ctm setmatrix}bd}{/@I_2{}bd}ifelse/@I_3{@sm @gs @ii @np/$ury
xd/$urx xd/$lly xd/$llx xd/$ncl xd/$bts xd/$hei xd/$wid xd/$dat $wid $bts mul
$ncl mul 8 div ceiling cvi string def $ngx $ncl 1 eq{/DeviceGray}{$ncl 3 eq
{/DeviceRGB}{/DeviceCMYK}ifelse}ifelse setcolorspace $llx $lly Tl $urx $llx sub
$ury $lly sub scale/ImageDataDict 8 dict def ImageDataDict begin/ImageType 1
def/Width $wid def/Height $hei abs def/BitsPerComponent $bts def/Decode $ncl 1
eq{[0 1]}{$ncl 3 eq{[0 1 0 1 0 1]}{[0 1 0 1 0 1 0 1]}ifelse}ifelse def
/ImageMatrix[$wid 0 0 $hei neg 0 $hei 0 gt{$hei}{0}ifelse]def/DataSource
currentfile/ASCII85Decode filter COMP 1 eq{/DCTDecode filter}{COMP 2 eq{
/RunLengthDecode filter}if}ifelse def end/MaskedImageDict 7 dict def
MaskedImageDict begin/ImageType 3 def/InterleaveType 3 def/MaskDict
ImageMaskDict def/DataDict ImageDataDict def end MaskedImageDict image $SDF
{$dsf $dsa $dsp @ss}if @gr $ctm setmatrix}bd/@SetMask{/$mbts xd/$mhei xd/$mwid
xd/ImageMaskDict 8 dict def ImageMaskDict begin/ImageType 1 def/Width $mwid def
/Height $mhei abs def/BitsPerComponent $mbts def/DataSource maskstream def
/ImageMatrix[$mwid 0 0 $mhei neg 0 $mhei 0 gt{$mhei}{0}ifelse]def/Decode[1 0]
def end}bd/@B{@gs S @gr F}bd/@b{@cp @B}bd/@sep{CurrentInkName_5(Composite)eq
{/$ink_5 -1 def}{CurrentInkName_5(Cyan)eq{/$ink_5 0 def}{CurrentInkName_5
(Magenta)eq{/$ink_5 1 def}{CurrentInkName_5(Yellow)eq{/$ink_5 2 def}{
CurrentInkName_5(Black)eq{/$ink_5 3 def}{/$ink_5 4 def}ifelse}ifelse}ifelse}
ifelse}ifelse}bd/@whi{@gs -72000 dup m -72000 72000 l 72000 dup l 72000 -72000
l @cp 1 SetGry fill @gr}bd/@neg{[{1 exch sub}/exec cvx currenttransfer/exec
cvx]cvx settransfer @whi}bd/deflevel 0 def/@sax{/deflevel deflevel 1 add def}
bd/@eax{/deflevel deflevel dup 0 gt{1 sub}if def deflevel 0 gt{/eax load}{eax}
ifelse}bd/eax{{exec}forall}bd/@rax{deflevel 0 eq{@rs @sv}if}bd/@daq{dup type
/arraytype eq{{}forall}if}bd/@BMP{/@cc xd UseLevel 3 eq MaskedImage true eq and
{7 -2 roll pop pop @I_3}{12 index 1 gt UseLevel 2 eq UseLevel 3 eq or and{7 -2
roll pop pop @I_2}{11 index 1 eq{12 -1 roll pop @i}{7 -2 roll pop pop @I}
ifelse}ifelse}ifelse}bd systemdict/pdfmark known not{/pdfmark/cleartomark ld}
if
/z{exch findfont exch scalefont setfont}bd/ZB{9 dict dup begin 4 1 roll
/FontType 3 def/FontMatrix xd/FontBBox xd/Encoding 256 array def 0 1 255{
Encoding exch/.notdef put}for/CharStrings 256 dict def CharStrings/.notdef{}
put/Metrics 256 dict def Metrics/.notdef 3 -1 roll put/BuildChar{exch dup
/$char exch/Encoding get 3 index get def dup/Metrics get $char get aload pop
setcachedevice begin Encoding exch get CharStrings exch get end exec}def end
definefont pop}bd/ZBAddChar{findfont begin dup 4 1 roll dup 6 1 roll Encoding 3
1 roll put CharStrings 3 1 roll put Metrics 3 1 roll put end}bd/Z{findfont dup
maxlength 2 add dict exch dup{1 index/FID ne{3 index 3 1 roll put}{pop pop}
ifelse}forall pop dup dup/Encoding get 256 array copy dup/$fe xd/Encoding exch
put dup/Fontname 3 index put 3 -1 roll dup length 0 ne{0 exch{dup type 0 type
eq{exch pop}{$fe exch 2 index exch put 1 add}ifelse}forall pop}if dup 256 dict
dup/$met xd/Metrics exch put dup/FontMatrix get 0 get 1000 mul 1 exch div 3
index length 256 eq{0 1 255{dup $fe exch get dup/.notdef eq{pop pop}{5 index 3
-1 roll get 2 index mul $met 3 1 roll put}ifelse}for}if pop definefont pop pop
}bd/@ftx{{currentpoint 3 -1 roll(0)dup 3 -1 roll 0 exch put dup @gs true
charpath $ctm setmatrix @@txt @gr @np stringwidth pop 3 -1 roll add exch m}
forall}bd/@ft{matrix currentmatrix exch $sdf{$scf $sca $scp @ss}if $fil 1 eq
{/@@txt/@pf ld @ftx}{$fil 2 eq{/@@txt/@ff ld @ftx}{$fil 3 eq{/@@txt/@Pf ld
@ftx}{$t $c $m $y $k $n $o @scc_5{show}{pop}ifelse}ifelse}ifelse}ifelse $sdf
{$dsf $dsa $dsp @ss}if setmatrix}bd/@st{matrix currentmatrix exch $SDF{$SCF
$SCA $SCP @ss}if $T $C $M $Y $K $N $O @scc_5{{currentpoint 3 -1 roll(0)dup 3 -1
roll 0 exch put dup @gs true charpath $ctm setmatrix $ptm concat stroke @gr @np
stringwidth pop 3 -1 roll add exch m}forall}{pop}ifelse $SDF{$dsf $dsa $dsp
@ss}if setmatrix}bd/@te{@ft}bd/@tr{@st}bd/@ta{dup @gs @ft @gr @st}bd/@t@a{dup
@gs @st @gr @ft}bd/@tm{@sm concat}bd/e{/t{@te}def}bd/r{/t{@tr}def}bd/o{/t{pop}
def}bd/a{/t{@ta}def}bd/@a{/t{@t@a}def}bd/t{@te}def/T{@np $ctm setmatrix/$ttm
matrix def}bd/ddt{t}def/@t{/$stm $stm currentmatrix def 3 1 roll m $ttm concat
ddt $stm setmatrix}bd/@n{/$ttm exch matrix rotate def}bd/@s{}bd/@l{}bd
end
%%EndResource
%%EndProlog
%%BeginSetup
wCorel8Dict begin
@BeginSysCorelDict
2.6131 setmiterlimit
1.00 setflat
/$fst 256 def
%%EndSetup
%%Page: 1 1
%LogicalPage: 1
%%BeginPageSetup
@sv
@sm
@sv
%%EndPageSetup
@rax %Note: Object
29.85335 518.65002 561.80353 728.45660 @E
0 O 0 @g
0.00 0.00 0.00 0.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 5.66929 5.66929 0.00000 @w
/$fm 0 def
295.82872 728.45660 m
442.32265 728.45660 561.80353 681.33146 561.80353 623.55345 c
561.80353 565.77458 442.32265 518.65002 295.82872 518.65002 c
149.33424 518.65002 29.85335 565.77458 29.85335 623.55345 c
29.85335 681.33146 149.33424 728.45660 295.82872 728.45660 c
@c
B
@rax 82.51002 578.66967 509.14658 668.43666 @E
[0.00028346 0.00000000 0.00000000 0.00028346 82.51001273 578.66964812] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Swis721BlkExBT 437905.00000 z
%CHAR: 0 0 (B) @t
157208 78896 m
243986 78896 l
263911 78896 276829 80720 282741 84443 c
288652 88165 291645 94879 291645 104586 c
291645 114512 288579 121446 282449 125168 c
276318 128963 263473 130861 243986 130861 c
157208 130861 L
157208 78896 L
@c
157208 242234 m
157208 197568 L
239461 197568 l
257269 197568 268801 199174 274129 202385 c
279383 205596 282011 211362 282011 219828 c
282011 228367 279602 234206 274712 237417 c
269895 240629 258145 242234 239461 242234 c
157208 242234 L
@c
289090 316240 m
333246 316240 364556 310183 382875 297994 c
401194 285806 410317 265589 410317 237345 c
410317 221799 406741 208224 399661 196473 c
392509 184796 381999 175308 368205 168083 C
386451 162244 400172 152683 409441 139546 c
418710 126336 423381 109914 423381 90208 c
423381 60139 413528 37587 393896 22552 c
374190 7517 344631 0 305147 0 c
34667 0 L
34667 316240 L
289090 316240 l
@c
F
%CHAR: 440970 0 (I) @t
475637 0 m
475637 316240 L
598178 316240 L
598178 0 L
475637 0 L
@c
F
%CHAR: 632334 0 (R) @t
907703 316240 m
935218 316240 957260 314927 973827 312299 c
990321 309672 1003240 305585 1012509 299965 c
1024332 293031 1033382 283616 1039586 271866 c
1045789 260116 1048855 246541 1048855 231141 c
1048855 212457 1044257 196035 1034988 181877 c
1025719 167645 1012946 157427 996671 151150 C
1010611 145311 1020464 138086 1026084 129474 c
1031703 120862 1034988 105608 1036009 83786 c
1036155 81377 1036301 78020 1036447 73787 c
1038418 32405 1043965 9488 1053161 4890 C
1053161 0 L
916972 0 L
912812 6715 910550 19633 910112 38901 c
909820 50140 909309 58825 908579 64956 c
907265 76560 903397 84662 896902 89333 c
890479 94077 879604 96412 864351 96412 c
791221 96412 L
791221 0 L
667001 0 L
667001 316240 L
907703 316240 l
@c
791221 179614 m
862599 179614 l
881283 179614 894493 181804 902083 186256 c
909747 190635 913542 198079 913542 208443 c
913542 218734 909966 225886 902740 229973 c
895515 233987 881137 236031 859607 236031 c
791221 236031 L
791221 179614 L
@c
F
%CHAR: 1066298 0 (D) @t
1223506 238220 m
1223506 84005 L
1284448 84005 l
1316196 84005 1338967 90062 1352688 102105 c
1366482 114147 1373342 133853 1373342 161222 c
1373342 188445 1366409 208078 1352469 220120 c
1338602 232163 1315904 238220 1284448 238220 c
1223506 238220 L
@c
1100965 316678 m
1303643 316678 l
1369255 316678 1419176 303176 1453552 276172 c
1487928 249168 1505079 209756 1505079 158011 c
1505079 106411 1488001 67145 1453771 40287 c
1419541 13429 1369547 0 1303643 0 c
1100965 0 L
1100965 316678 L
@c
F
T
@rax %Note: Object
202.57002 663.60898 462.94894 788.24381 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.21543 0.21543 0.00000 @w
/$fm 0 def
260.91354 727.66403 m
284.90258 722.60872 308.89162 717.55398 332.88066 712.49783 C
372.47783 785.04321 371.74762 810.24123 462.94894 768.46677 C
412.01121 767.74422 394.34910 800.57197 337.90961 694.42894 c
336.72728 692.20375 216.16299 742.15219 202.57002 663.60898 C
200.58690 726.36633 231.68494 734.82888 260.91354 727.66403 C
@c
B
@rax %Note: Object
17.18787 478.84422 579.89707 569.31194 @E
0 O 0 @g
0.00 0.00 0.00 0.00 k
/$fm 0 def
17.18787 569.31194 m
579.89707 569.31194 L
579.89707 478.84422 L
17.18787 478.84422 L
17.18787 569.31194 L
@c
F
@rax %Note: Object
86.84816 567.50202 504.80901 567.50315 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 5.66929 5.66929 0.00000 @w
/$fm 0 def
86.84816 567.50258 m
504.80901 567.50258 L
S
@rax %Note: Object
86.84816 554.44139 504.80901 554.44252 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 5.66929 5.66929 0.00000 @w
/$fm 0 def
86.84816 554.44195 m
504.80901 554.44195 L
S
@rax %Note: Object
86.84816 541.70674 504.80901 541.70787 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 5.66929 5.66929 0.00000 @w
/$fm 0 def
86.84816 541.70731 m
504.80901 541.70731 L
S
%%PageTrailer
@rs
@rs
%%Trailer
@EndSysCorelDict
end
%%DocumentSuppliedResources: procset wCorel8Dict
%%EOF
bird2-2.17.5/doc/slides/obr1.eps 0000664 0000000 0000000 00000256660 15211753245 0016240 0 ustar 00root root 0000000 0000000 %!PS-Adobe-3.0 EPSF-3.0
%%BoundingBox: 16 42 558 453
%%Creator: CorelDRAW
%%Title:
%%CreationDate: Mon Jun 26 13:55:02 2000
%%DocumentProcessColors: Black
%%DocumentSuppliedResources: (atend)
%%EndComments
%%BeginProlog
/AutoFlatness true def
/AutoSteps 0 def
/CMYKMarks true def
/UseLevel2 false def
%Color profile: Disabled
%%BeginResource: procset wCorel6Dict 6.0 0
% Copyright (c)1992-96 Corel Corporation
% All rights reserved. v6.0 r1.1
/wCorel6Dict 300 dict def wCorel6Dict begin/bd{bind def}bind def/ld{load def}
bd/xd{exch def}bd/_ null def/rp{{pop}repeat}bd/@cp/closepath ld/@gs/gsave ld
/@gr/grestore ld/@np/newpath ld/Tl/translate ld/$sv 0 def/@sv{/$sv save def}bd
/@rs{$sv restore}bd/spg/showpage ld/showpage{}bd currentscreen/@dsp xd/$dsp
/@dsp def/$dsa xd/$dsf xd/$sdf false def/$SDF false def/$Scra 0 def/SetScr
/setscreen ld/setscreen{pop pop pop}bd/@ss{2 index 0 eq{$dsf 3 1 roll 4 -1 roll
pop}if exch $Scra add exch load SetScr}bd/SepMode_5 where{pop}{/SepMode_5 0
def}ifelse/CurrentInkName_5 where{pop}{/CurrentInkName_5(Composite)def}ifelse
/$ink_5 where{pop}{/$ink_5 -1 def}ifelse/$c 0 def/$m 0 def/$y 0 def/$k 0 def
/$t 1 def/$n _ def/$o 0 def/$fil 0 def/$C 0 def/$M 0 def/$Y 0 def/$K 0 def/$T 1
def/$N _ def/$O 0 def/$PF false def/s1c 0 def/s1m 0 def/s1y 0 def/s1k 0 def
/s1t 0 def/s1n _ def/$bkg false def/SK 0 def/SM 0 def/SY 0 def/SC 0 def/$op
false def matrix currentmatrix/$ctm xd/$ptm matrix def/$ttm matrix def/$stm
matrix def/$fst 128 def/$pad 0 def/$rox 0 def/$roy 0 def/$fmp 50 def/$ffpnt
true def/CorelDrawReencodeVect[16#0/grave 16#5/breve 16#6/dotaccent 16#8/ring
16#A/hungarumlaut 16#B/ogonek 16#C/caron 16#D/dotlessi 16#27/quotesingle
16#60/grave 16#7C/bar
16#82/quotesinglbase/florin/quotedblbase/ellipsis/dagger/daggerdbl
16#88/circumflex/perthousand/Scaron/guilsinglleft/OE
16#91/quoteleft/quoteright/quotedblleft/quotedblright/bullet/endash/emdash
16#98/tilde/trademark/scaron/guilsinglright/oe 16#9F/Ydieresis
16#A1/exclamdown/cent/sterling/currency/yen/brokenbar/section
16#a8/dieresis/copyright/ordfeminine/guillemotleft/logicalnot/minus/registered/macron
16#b0/degree/plusminus/twosuperior/threesuperior/acute/mu/paragraph/periodcentered
16#b8/cedilla/onesuperior/ordmasculine/guillemotright/onequarter/onehalf/threequarters/questiondown
16#c0/Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE/Ccedilla
16#c8/Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex/Idieresis
16#d0/Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis/multiply
16#d8/Oslash/Ugrave/Uacute/Ucircumflex/Udieresis/Yacute/Thorn/germandbls
16#e0/agrave/aacute/acircumflex/atilde/adieresis/aring/ae/ccedilla
16#e8/egrave/eacute/ecircumflex/edieresis/igrave/iacute/icircumflex/idieresis
16#f0/eth/ntilde/ograve/oacute/ocircumflex/otilde/odieresis/divide
16#f8/oslash/ugrave/uacute/ucircumflex/udieresis/yacute/thorn/ydieresis]def
/L2?/languagelevel where{pop languagelevel 2 ge}{false}ifelse def
/@BeginSysCorelDict{systemdict/Corel30Dict known{systemdict/Corel30Dict get
exec}if}bd/@EndSysCorelDict{systemdict/Corel30Dict known{end}if}bd AutoFlatness
{/@ifl{dup currentflat exch sub 10 gt{
([Error: PathTooComplex; OffendingCommand: AnyPaintingOperator]\n)print flush
@np exit}{currentflat 2 add setflat}ifelse}bd/@fill/fill ld/fill{currentflat{
{@fill}stopped{@ifl}{exit}ifelse}bind loop setflat}bd/@eofill/eofill ld/eofill
{currentflat{{@eofill}stopped{@ifl}{exit}ifelse}bind loop setflat}bd/@clip
/clip ld/clip{currentflat{{@clip}stopped{@ifl}{exit}ifelse}bind loop setflat}
bd/@eoclip/eoclip ld/eoclip{currentflat{{@eoclip}stopped{@ifl}{exit}ifelse}
bind loop setflat}bd/@stroke/stroke ld/stroke{currentflat{{@stroke}stopped
{@ifl}{exit}ifelse}bind loop setflat}bd}if L2?{/@ssa{true setstrokeadjust}bd}{
/@ssa{}bd}ifelse/d/setdash ld/j/setlinejoin ld/J/setlinecap ld/M/setmiterlimit
ld/w/setlinewidth ld/O{/$o xd}bd/R{/$O xd}bd/W/eoclip ld/c/curveto ld/C/c ld/l
/lineto ld/L/l ld/rl/rlineto ld/m/moveto ld/n/newpath ld/N/newpath ld/P{11 rp}
bd/u{}bd/U{}bd/A{pop}bd/q/@gs ld/Q/@gr ld/&{}bd/@j{@sv @np}bd/@J{@rs}bd/g{1
exch sub/$k xd/$c 0 def/$m 0 def/$y 0 def/$t 1 def/$n _ def/$fil 0 def}bd/G{1
sub neg/$K xd _ 1 0 0 0/$C xd/$M xd/$Y xd/$T xd/$N xd}bd/k{1 index type
/stringtype eq{/$t xd/$n xd}{/$t 0 def/$n _ def}ifelse/$k xd/$y xd/$m xd/$c xd
/$fil 0 def}bd/K{1 index type/stringtype eq{/$T xd/$N xd}{/$T 0 def/$N _ def}
ifelse/$K xd/$Y xd/$M xd/$C xd}bd/x/k ld/X/K ld/sf{1 index type/stringtype eq{
/s1t xd/s1n xd}{/s1t 0 def/s1n _ def}ifelse/s1k xd/s1y xd/s1m xd/s1c xd}bd/i{
dup 0 ne{setflat}{pop}ifelse}bd/v{4 -2 roll 2 copy 6 -2 roll c}bd/V/v ld/y{2
copy c}bd/Y/y ld/@w{matrix rotate/$ptm xd matrix scale $ptm dup concatmatrix
/$ptm xd 1 eq{$ptm exch dup concatmatrix/$ptm xd}if 1 w}bd/@g{1 eq dup/$sdf xd
{/$scp xd/$sca xd/$scf xd}if}bd/@G{1 eq dup/$SDF xd{/$SCP xd/$SCA xd/$SCF xd}
if}bd/@D{2 index 0 eq{$dsf 3 1 roll 4 -1 roll pop}if 3 copy exch $Scra add exch
load SetScr/$dsp xd/$dsa xd/$dsf xd}bd/$ngx{$SDF{$SCF SepMode_5 0 eq{$SCA}
{$dsa}ifelse $SCP @ss}if}bd/p{/$pm xd 7 rp/$pyf xd/$pxf xd/$pn xd/$fil 1 def}
bd/@MN{2 copy le{pop}{exch pop}ifelse}bd/@MX{2 copy ge{pop}{exch pop}ifelse}bd
/InRange{3 -1 roll @MN @MX}bd/wDstChck{2 1 roll dup 3 -1 roll eq{1 add}if}bd
/@dot{dup mul exch dup mul add 1 exch sub}bd/@lin{exch pop abs 1 exch sub}bd
/cmyk2rgb{3{dup 5 -1 roll add 1 exch sub dup 0 lt{pop 0}if exch}repeat pop}bd
/rgb2cmyk{3{1 exch sub 3 1 roll}repeat 3 copy @MN @MN 3{dup 5 -1 roll sub neg
exch}repeat}bd/rgb2g{2 index .299 mul 2 index .587 mul add 1 index .114 mul add
4 1 roll pop pop pop}bd/WaldoColor_5 where{pop}{/SetRgb/setrgbcolor ld/GetRgb
/currentrgbcolor ld/SetGry/setgray ld/GetGry/currentgray ld/SetRgb2 systemdict
/setrgbcolor get def/GetRgb2 systemdict/currentrgbcolor get def/SetHsb
systemdict/sethsbcolor get def/GetHsb systemdict/currenthsbcolor get def
/rgb2hsb{SetRgb2 GetHsb}bd/hsb2rgb{3 -1 roll dup floor sub 3 1 roll SetHsb
GetRgb2}bd/setcmykcolor where{pop/SetCmyk_5/setcmykcolor ld}{/SetCmyk_5{
cmyk2rgb SetRgb}bd}ifelse/currentcmykcolor where{pop/GetCmyk/currentcmykcolor
ld}{/GetCmyk{GetRgb rgb2cmyk}bd}ifelse/setoverprint where{pop}{/setoverprint{
/$op xd}bd}ifelse/currentoverprint where{pop}{/currentoverprint{$op}bd}ifelse
/@tc_5{5 -1 roll dup 1 ge{pop}{4{dup 6 -1 roll mul exch}repeat pop}ifelse}bd
/@trp{exch pop 5 1 roll @tc_5}bd/setprocesscolor_5{SepMode_5 0 eq{SetCmyk_5}{0
4 $ink_5 sub index exch pop 5 1 roll pop pop pop pop SepsColor true eq{$ink_5 3
gt{1 sub neg SetGry}{0 0 0 4 $ink_5 roll SetCmyk_5}ifelse}{1 sub neg SetGry}
ifelse}ifelse}bd/findcmykcustomcolor where{pop}{/findcmykcustomcolor{5 array
astore}bd}ifelse/setcustomcolor where{pop}{/setcustomcolor{exch aload pop
SepMode_5 0 eq{pop @tc_5 setprocesscolor_5}{CurrentInkName_5 eq{4 index}{0}
ifelse 6 1 roll 5 rp 1 sub neg SetGry}ifelse}bd}ifelse/@scc_5{dup type
/booleantype eq{setoverprint}{1 eq setoverprint}ifelse dup _ eq{pop
setprocesscolor_5 pop}{findcmykcustomcolor exch setcustomcolor}ifelse SepMode_5
0 eq{true}{GetGry 1 eq currentoverprint and not}ifelse}bd/colorimage where{pop
/ColorImage{colorimage}def}{/ColorImage{/ncolors xd pop/dataaq xd{dataaq
ncolors dup 3 eq{/$dat xd 0 1 $dat length 3 div 1 sub{dup 3 mul $dat 1 index
get 255 div $dat 2 index 1 add get 255 div $dat 3 index 2 add get 255 div rgb2g
255 mul cvi exch pop $dat 3 1 roll put}for $dat 0 $dat length 3 idiv
getinterval pop}{4 eq{/$dat xd 0 1 $dat length 4 div 1 sub{dup 4 mul $dat 1
index get 255 div $dat 2 index 1 add get 255 div $dat 3 index 2 add get 255 div
$dat 4 index 3 add get 255 div cmyk2rgb rgb2g 255 mul cvi exch pop $dat 3 1
roll put}for $dat 0 $dat length ncolors idiv getinterval}if}ifelse}image}bd
}ifelse/setcmykcolor{1 5 1 roll _ currentoverprint @scc_5/$ffpnt xd}bd
/currentcmykcolor{0 0 0 0}bd/setrgbcolor{rgb2cmyk setcmykcolor}bd
/currentrgbcolor{currentcmykcolor cmyk2rgb}bd/sethsbcolor{hsb2rgb setrgbcolor}
bd/currenthsbcolor{currentrgbcolor rgb2hsb}bd/setgray{dup dup setrgbcolor}bd
/currentgray{currentrgbcolor rgb2g}bd}ifelse/WaldoColor_5 true def/@sft{$tllx
$pxf add dup $tllx gt{$pwid sub}if/$tx xd $tury $pyf sub dup $tury lt{$phei
add}if/$ty xd}bd/@stb{pathbbox/$ury xd/$urx xd/$lly xd/$llx xd}bd/@ep{{cvx exec
}forall}bd/@tp{@sv/$in true def 2 copy dup $lly le{/$in false def}if $phei sub
$ury ge{/$in false def}if dup $urx ge{/$in false def}if $pwid add $llx le{/$in
false def}if $in{@np 2 copy m $pwid 0 rl 0 $phei neg rl $pwid neg 0 rl 0 $phei
rl clip @np $pn cvlit load aload pop 7 -1 roll 5 index sub 7 -1 roll 3 index
sub Tl matrix currentmatrix/$ctm xd @ep pop pop pop pop}{pop pop}ifelse @rs}bd
/@th{@sft 0 1 $tly 1 sub{dup $psx mul $tx add{dup $llx gt{$pwid sub}{exit}
ifelse}loop exch $phei mul $ty exch sub 0 1 $tlx 1 sub{$pwid mul 3 copy 3 -1
roll add exch @tp pop}for pop pop}for}bd/@tv{@sft 0 1 $tlx 1 sub{dup $pwid mul
$tx add exch $psy mul $ty exch sub{dup $ury lt{$phei add}{exit}ifelse}loop 0 1
$tly 1 sub{$phei mul 3 copy sub @tp pop}for pop pop}for}bd/@pf{@gs $ctm
setmatrix $pm concat @stb eoclip Bburx Bbury $pm itransform/$tury xd/$turx xd
Bbllx Bblly $pm itransform/$tlly xd/$tllx xd/$wid $turx $tllx sub def/$hei
$tury $tlly sub def @gs $vectpat{1 0 0 0 0 _ $o @scc_5{eofill}if}{$t $c $m $y
$k $n $o @scc_5{SepMode_5 0 eq $pfrg or{$tllx $tlly Tl $wid $hei scale <00> 8 1
false[8 0 0 1 0 0]{}imagemask}{/$bkg true def}ifelse}if}ifelse @gr $wid 0 gt
$hei 0 gt and{$pn cvlit load aload pop/$pd xd 3 -1 roll sub/$phei xd exch sub
/$pwid xd $wid $pwid div ceiling 1 add/$tlx xd $hei $phei div ceiling 1 add
/$tly xd $psx 0 eq{@tv}{@th}ifelse}if @gr @np/$bkg false def}bd/@dlt_hsb{$fco
nff ge{/$fco nff 1 sub def}if sub neg 2 div dup $fco div/kdb xd nff $fco sub
div/kdb2 xd sub neg 2 div dup $fco div/kds xd nff $fco sub div/kds2 xd sub neg
dup 0 eq{pop $frb 2 eq{.99}{-.99}ifelse}if dup $frb 2 eq exch 0 lt and{1 add}
if dup $frb 1 eq exch 0 gt and{1 sub}if 2 div dup $fco div/kdh xd nff $fco sub
div/kdh2 xd}bd/@dlt_cmyk{$fmp 50 eq{sub neg nff dup 1 gt{1 sub}if div/$dk xd
sub neg nff dup 1 gt{1 sub}if div/$dy xd sub neg nff dup 1 gt{1 sub}if div/$dm
xd sub neg nff dup 1 gt{1 sub}if div/$dc xd sub neg nff dup 1 gt{1 sub}if div
/$dt xd}{$fco nff ge{/$fco nff 1 sub def}if sub neg 2 div dup $fco div/$dk xd
nff $fco sub div/$dk2 xd sub neg 2 div dup $fco div/$dy xd nff $fco sub div
/$dy2 xd sub neg 2 div dup $fco div/$dm xd nff $fco sub div/$dm2 xd sub neg 2
div dup $fco div/$dc xd nff $fco sub div/$dc2 xd sub neg 2 div dup $fco div
/$dt xd nff $fco sub div/$dt2 xd}ifelse}bd/@dlt{$fse $fss sub dup/nff xd $fmp
mul $fmp add 100 div round cvi dup 0 le{pop 1}if/$fco xd/$fi 0 def $frb dup 1
eq exch 2 eq or{$frt dup $frc $frm $fry $frk @tc_5 4 copy cmyk2rgb rgb2hsb 3
copy/myb xd/mys xd/myh xd $tot $toc $tom $toy $tok @tc_5 cmyk2rgb rgb2hsb 3 1
roll 4 1 roll 5 1 roll @dlt_hsb}{$frt dup $frc $frm $fry $frk @tc_5 5 copy $tot
dup $toc $tom $toy $tok @tc_5 5 1 roll 6 1 roll 7 1 roll 8 1 roll 9 1 roll
@dlt_cmyk}ifelse}bd/@ffnxt{/$fi $fi 1 add def $frb dup 1 eq exch 2 eq or{pop
pop pop pop myh mys myb $fi $fco lt{kdb add 3 1 roll kds add 3 1 roll kdh add 3
1 roll}{kdb2 add 3 1 roll kds2 add 3 1 roll kdh2 add 3 1 roll}ifelse 3 copy
/myb xd/mys xd/myh xd hsb2rgb rgb2cmyk}{$fi $fco lt $fmp 50 eq or{$dk add 5 1
roll $dy add 5 1 roll $dm add 5 1 roll $dc add 5 1 roll $dt add 5 1 roll}{$dk2
add 5 1 roll $dy2 add 5 1 roll $dm2 add 5 1 roll $dc2 add 5 1 roll $dt2 add 5 1
roll}ifelse}ifelse}bd/ffcol{5 copy $fsit 0 eq{setcmykcolor pop}{SepMode_5 0 ne
{$frn findcmykcustomcolor exch setcustomcolor}{pop pop pop pop $frc $frm $fry
$frk $frn findcmykcustomcolor exch setcustomcolor}ifelse}ifelse}bd/@ftl{1 index
4 index sub dup $pad mul dup/$pdw xd 2 mul sub $fst div/$wid xd 2 index sub
/$hei xd pop Tl @dlt $fss 0 eq{ffcol n 0 0 m 0 $hei l $pdw $hei l $pdw 0 l @cp
$ffpnt{fill}{@np}ifelse}if $fss $wid mul $pdw add 0 Tl nff{ffcol n 0 0 m 0 $hei
l $wid $hei l $wid 0 l @cp $ffpnt{fill}{@np}ifelse $wid 0 Tl @ffnxt}repeat 5 rp
$tot dup $toc $tom $toy $tok @tc_5 ffcol n 0 0 m 0 $hei l $pdw $hei l $pdw 0 l
@cp $ffpnt{fill}{@np}ifelse 5 rp}bd/@ftrs{1 index 4 index sub dup $rox mul
/$row xd 2 div 1 index 4 index sub dup $roy mul/$roh xd 2 div 2 copy dup mul
exch dup mul add sqrt $row dup mul $roh dup mul add sqrt add dup/$hei xd $fst
div/$wid xd 4 index add $roh add exch 5 index add $row add exch Tl $fan rotate
pop pop pop pop @dlt $fss 0 eq{ffcol $fty 3 eq{$hei dup neg dup m 2 mul @sqr}{
0 0 m 0 0 $hei 0 360 arc}ifelse $ffpnt{fill}{@np}ifelse}if 1.0 $pad 2 mul sub
dup scale $hei $fss $wid mul sub/$hei xd nff{ffcol $fty 3 eq{n $hei dup neg dup
m 2 mul @sqr}{n 0 0 m 0 0 $hei 0 360 arc}ifelse $ffpnt{fill}{@np}ifelse/$hei
$hei $wid sub def @ffnxt}repeat 5 rp}bd/@ftc{1 index 4 index sub dup $rox mul
/$row xd 2 div 1 index 4 index sub dup $roy mul/$roh xd 2 div 2 copy dup mul
exch dup mul add sqrt $row dup mul $roh dup mul add sqrt add dup/$hei xd $fst
div/$wid xd 4 index add $roh add exch 5 index add $row add exch Tl pop pop pop
pop @dlt $fss 0 eq{ffcol $ffpnt{fill}{@np}ifelse}{n}ifelse/$dang 180 $fst 1 sub
div def/$sang $dang -2 div 180 add def/$eang $dang 2 div 180 add def/$sang
$sang $dang $fss mul add def/$eang $eang $dang $fss mul add def/$sang $eang
$dang sub def nff{ffcol n 0 0 m 0 0 $hei $sang $fan add $eang $fan add arc
$ffpnt{fill}{@np}ifelse 0 0 m 0 0 $hei $eang neg $fan add $sang neg $fan add
arc $ffpnt{fill}{@np}ifelse/$sang $eang def/$eang $eang $dang add def @ffnxt}
repeat 5 rp}bd/@fstAdjust{72 0 matrix defaultmatrix dtransform exch dup mul
exch dup mul add sqrt currentscreen pop pop div dup mul 1 add cvi 2 256 InRange
$fsc 1 sub dup 0 le{pop 1}if mul/opt$fst xd AutoSteps dup 1 eq exch 3 eq or{
opt$fst dup dup $fst dup 3 1 roll div exch 3 -1 roll gt{/$adj xd/$fst xd}{pop
pop}ifelse}if AutoSteps dup 2 eq exch 3 eq or{opt$fst dup dup $fst dup 3 1 roll
div exch 3 -1 roll lt{/$adj xd/$fst xd}{pop pop}ifelse}if}bd/@ff{/old$fst $fst
def/$adj 1 def/$fss 0 def $o 1 eq setoverprint AutoSteps 0 gt{@fstAdjust}if 1 1
$fsc 1 sub{dup 1 sub $fsit 0 eq{$fsa exch 5 mul 5 getinterval aload pop pop
/$frk xd/$fry xd/$frm xd/$frc xd/$frn _ def/$frt 1 def $fsa exch 5 mul 5
getinterval aload pop $adj mul cvi $fss add/$fse xd/$tok xd/$toy xd/$tom xd
/$toc xd/$ton _ def/$tot 1 def}{$fsa exch 7 mul 7 getinterval aload pop pop
/$frt xd/$frn xd/$frk xd/$fry xd/$frm xd/$frc xd $fsa exch 7 mul 7 getinterval
aload pop $adj mul cvi $fss add/$fse xd/$tot xd/$ton xd/$tok xd/$toy xd/$tom xd
/$toc xd}ifelse $fsit 0 eq SepMode_5 0 eq or dup not CurrentInkName_5 $frn eq
and or{@sv $ctm setmatrix eoclip Bbllx Bblly Bburx Bbury $fty 2 eq{@ftc}{1
index 3 index m 2 copy l 3 index 1 index l 3 index 3 index l @cp $fty dup 1 eq
exch 3 eq or{@ftrs}{pop pop pop pop $fan rotate pathbbox @ftl}ifelse}ifelse @rs
/$fss $fse def}{1 0 0 0 0 _ $o @scc_5{fill}if}ifelse}for @np/$fst old$fst def}
bd/@Pf{@sv SepMode_5 0 eq $Psc 0 ne or $ink_5 3 eq or{0 J 0 j[]0 d $t $c $m $y
$k $n $o @scc_5 pop $ctm setmatrix 72 1000 div dup matrix scale dup concat dup
Bburx exch Bbury exch itransform ceiling cvi/Bbury xd ceiling cvi/Bburx xd
Bbllx exch Bblly exch itransform floor cvi/Bblly xd floor cvi/Bbllx xd $Prm
aload pop $Psn load exec}{1 SetGry eofill}ifelse @rs @np}bd/F{matrix
currentmatrix $sdf{$scf $sca $scp @ss}if $fil 1 eq{@pf}{$fil 2 eq{@ff}{$fil 3
eq{@Pf}{$t $c $m $y $k $n $o @scc_5{eofill}{@np}ifelse}ifelse}ifelse}ifelse
$sdf{$dsf $dsa $dsp @ss}if setmatrix}bd/f{@cp F}bd/S{matrix currentmatrix $ctm
setmatrix $SDF{$SCF $SCA $SCP @ss}if $T $C $M $Y $K $N $O @scc_5{matrix
currentmatrix $ptm concat stroke setmatrix}{@np}ifelse $SDF{$dsf $dsa $dsp
@ss}if setmatrix}bd/s{@cp S}bd/B{@gs F @gr S}bd/b{@cp B}bd/_E{5 array astore
exch cvlit xd}bd/@cc{currentfile $dat readhexstring pop}bd/@sm{/$ctm $ctm
currentmatrix def}bd/@E{/Bbury xd/Bburx xd/Bblly xd/Bbllx xd}bd/@c{@cp}bd/@p{
/$fil 1 def 1 eq dup/$vectpat xd{/$pfrg true def}{@gs $t $c $m $y $k $n $o
@scc_5/$pfrg xd @gr}ifelse/$pm xd/$psy xd/$psx xd/$pyf xd/$pxf xd/$pn xd}bd/@P
{/$fil 3 def/$Psn xd/$Psc xd array astore/$Prm xd}bd/@k{/$fil 2 def/$fmp xd
/$roy xd/$rox xd/$pad xd/$fty xd/$fan xd $fty 1 eq{/$fan 0 def}if/$frb xd/$fst
xd/$fsc xd/$fsa xd/$fsit 0 def}bd/@x{/$fil 2 def/$fmp xd/$roy xd/$rox xd/$pad
xd/$fty xd/$fan xd $fty 1 eq{/$fan 0 def}if/$frb xd/$fst xd/$fsc xd/$fsa xd
/$fsit 1 def}bd/@ii{concat 3 index 3 index m 3 index 1 index l 2 copy l 1 index
3 index l 3 index 3 index l clip pop pop pop pop}bd/tcc{@cc}def/@i{@sm @gs @ii
6 index 1 ne{/$frg true def pop pop}{1 eq{s1t s1c s1m s1y s1k s1n $O @scc_5
/$frg xd}{/$frg false def}ifelse 1 eq{@gs $ctm setmatrix F @gr}if}ifelse @np
/$ury xd/$urx xd/$lly xd/$llx xd/$bts xd/$hei xd/$wid xd/$dat $wid $bts mul 8
div ceiling cvi string def $bkg $frg or{$SDF{$SCF $SCA $SCP @ss}if $llx $lly Tl
$urx $llx sub $ury $lly sub scale $bkg{$t $c $m $y $k $n $o @scc_5 pop}if $wid
$hei abs $bts 1 eq{$bkg}{$bts}ifelse[$wid 0 0 $hei neg 0 $hei 0
gt{$hei}{0}ifelse]/tcc load $bts 1 eq{imagemask}{image}ifelse $SDF{$dsf $dsa
$dsp @ss}if}{$hei abs{tcc pop}repeat}ifelse @gr $ctm setmatrix}bd/@I{@sm @gs
@ii @np/$ury xd/$urx xd/$lly xd/$llx xd/$ncl xd/$bts xd/$hei xd/$wid xd/$dat
$wid $bts mul $ncl mul 8 div ceiling cvi string def $ngx $llx $lly Tl $urx $llx
sub $ury $lly sub scale $wid $hei abs $bts[$wid 0 0 $hei neg 0 $hei 0
gt{$hei}{0}ifelse]/@cc load false $ncl ColorImage $SDF{$dsf $dsa $dsp @ss}if
@gr $ctm setmatrix}bd L2?{/@I_2{@sm @gs @ii @np/$ury xd/$urx xd/$lly xd/$llx xd
/$ncl xd/$bts xd/$hei xd/$wid xd/$dat $wid $bts mul $ncl mul 8 div ceiling cvi
string def $ngx $ncl 1 eq{/DeviceGray}{$ncl 3 eq{/DeviceRGB}{/DeviceCMYK}
ifelse}ifelse setcolorspace $llx $lly Tl $urx $llx sub $ury $lly sub scale 8
dict begin/ImageType 1 def/Width $wid def/Height $hei abs def/BitsPerComponent
$bts def/Decode $ncl 1 eq{[0 1]}{$ncl 3 eq{[0 1 0 1 0 1]}{[0 1 0 1 0 1 0 1]}
ifelse}ifelse def/ImageMatrix[$wid 0 0 $hei neg 0 $hei 0 gt{$hei}{0}ifelse]def
/DataSource currentfile/ASCII85Decode filter def currentdict end image $SDF
{$dsf $dsa $dsp @ss}if @gr $ctm setmatrix}bd}{/@I_2{}bd}ifelse/z{exch findfont
exch scalefont setfont}bd/ZB{9 dict dup begin 4 1 roll/FontType 3 def
/FontMatrix xd/FontBBox xd/Encoding 256 array def 0 1 255{Encoding exch
/.notdef put}for/CharStrings 256 dict def CharStrings/.notdef{}put/Metrics 256
dict def Metrics/.notdef 3 -1 roll put/BuildChar{exch dup/$char exch/Encoding
get 3 index get def dup/Metrics get $char get aload pop setcachedevice begin
Encoding exch get CharStrings exch get end exec}def end definefont pop}bd
/ZBAddChar{findfont begin dup 4 1 roll dup 6 1 roll Encoding 3 1 roll put
CharStrings 3 1 roll put Metrics 3 1 roll put end}bd/Z{findfont dup maxlength 2
add dict exch dup{1 index/FID ne{3 index 3 1 roll put}{pop pop}ifelse}forall
pop dup dup/Encoding get 256 array copy dup/$fe xd/Encoding exch put dup
/Fontname 3 index put 3 -1 roll dup length 0 ne{0 exch{dup type 0 type eq{exch
pop}{$fe exch 2 index exch put 1 add}ifelse}forall pop}if dup 256 dict dup
/$met xd/Metrics exch put dup/FontMatrix get 0 get 1000 mul 1 exch div 3 index
length 256 eq{0 1 255{dup $fe exch get dup/.notdef eq{pop pop}{5 index 3 -1
roll get 2 index mul $met 3 1 roll put}ifelse}for}if pop definefont pop pop}bd
/@ftx{{currentpoint 3 -1 roll(0)dup 3 -1 roll 0 exch put dup @gs true charpath
$ctm setmatrix @@txt @gr @np stringwidth pop 3 -1 roll add exch m}forall}bd
/@ft{matrix currentmatrix exch $sdf{$scf $sca $scp @ss}if $fil 1 eq{/@@txt/@pf
ld @ftx}{$fil 2 eq{/@@txt/@ff ld @ftx}{$fil 3 eq{/@@txt/@Pf ld @ftx}{$t $c $m
$y $k $n $o @scc_5{show}{pop}ifelse}ifelse}ifelse}ifelse $sdf{$dsf $dsa $dsp
@ss}if setmatrix}bd/@st{matrix currentmatrix exch $SDF{$SCF $SCA $SCP @ss}if $T
$C $M $Y $K $N $O @scc_5{{currentpoint 3 -1 roll(0)dup 3 -1 roll 0 exch put dup
@gs true charpath $ctm setmatrix $ptm concat stroke @gr @np stringwidth pop 3
-1 roll add exch m}forall}{pop}ifelse $SDF{$dsf $dsa $dsp @ss}if setmatrix}bd
/@te{@ft}bd/@tr{@st}bd/@ta{dup @gs @ft @gr @st}bd/@t@a{dup @gs @st @gr @ft}bd
/@tm{@sm concat}bd/e{/t{@te}def}bd/r{/t{@tr}def}bd/o{/t{pop}def}bd/a{/t{@ta}
def}bd/@a{/t{@t@a}def}bd/t{@te}def/T{@np $ctm setmatrix/$ttm matrix def}bd/ddt
{t}def/@t{/$stm $stm currentmatrix def 3 1 roll m $ttm concat ddt $stm
setmatrix}bd/@n{/$ttm exch matrix rotate def}bd/@s{}bd/@l{}bd/@B{@gs S @gr F}
bd/@b{@cp @B}bd/@sep{CurrentInkName_5(Composite)eq{/$ink_5 -1 def}{
CurrentInkName_5(Cyan)eq{/$ink_5 0 def}{CurrentInkName_5(Magenta)eq{/$ink_5 1
def}{CurrentInkName_5(Yellow)eq{/$ink_5 2 def}{CurrentInkName_5(Black)eq
{/$ink_5 3 def}{/$ink_5 4 def}ifelse}ifelse}ifelse}ifelse}ifelse}bd/@whi{@gs
-72000 dup m -72000 72000 l 72000 dup l 72000 -72000 l @cp 1 SetGry fill @gr}
bd/@neg{[{1 exch sub}/exec cvx currenttransfer/exec cvx]cvx settransfer @whi}
bd/currentscale{1 0 dtransform matrix defaultmatrix idtransform dup mul exch
dup mul add sqrt 0 1 dtransform matrix defaultmatrix idtransform dup mul exch
dup mul add sqrt}bd/@unscale{}bd/@smc{CMYKMarks{0 exch eq{1 1 1 1 1 _ 0 @scc_5
pop}{1 0 0 0 0 _ 0 @scc_5 pop}ifelse}{SetGry}ifelse}bd/@gmc{CMYKMarks{GetCmyk
pop pop pop 1 eq{0}{1}ifelse}{GetGry}ifelse}bd/@sqr{dup 0 rl dup 0 exch rl neg
0 rl @cp}bd/corelsym{@gs @np Tl -90 rotate 7{45 rotate -.75 2 m 1.5 @sqr fill}
repeat @gr}bd/@reg_cor{@gs @np Tl -6 -6 m 12 @sqr @gs 1 @gmc sub @smc fill @gr
4{90 rotate 0 4 m 0 4 rl}repeat stroke 0 0 corelsym @gr}bd/@reg_std{@gs @np Tl
.3 w 0 0 5 0 360 arc @cp @gs 1 @gmc sub @smc fill @gr 4{90 rotate 0 0 m 0 8 rl
}repeat stroke @gr}bd/@reg_inv{@gs @np Tl .3 w 0 0 5 0 360 arc @cp @gs 1 @gmc
sub @smc fill @gr 4{90 rotate 0 0 m 0 8 rl}repeat stroke 0 0 m 0 0 5 90 180 arc
@cp 0 0 5 270 360 arc @cp fill @gr}bd/@reg_sqr{@gs @np Tl .3 w -7 -7 m 14 @sqr
fill @gs 1 @gmc sub @smc 0 0 5 0 360 arc @cp save fill restore 4{90 rotate 0 0
m 0 8 rl}repeat stroke @gr 4{90 rotate 0 0 m 0 5 rl}repeat stroke @gr}bd
/@reg_lng{@gs @np 0 eq{/$Xlen 16 def/$Ylen 8 def}{/$Xlen 8 def/$Ylen 16 def}
ifelse Tl .3 w 0 0 5 0 360 arc @cp @gs 1 @gmc sub @smc fill @gr 90 rotate 0 0 m
0 $Xlen rl 90 rotate 0 0 m 0 $Ylen rl 90 rotate 0 0 m 0 $Xlen rl 90 rotate 0 0
m 0 $Ylen rl stroke @gr}bd/@setdcol{0 $dcol eq{0 exch 1 exch sub 0 0 0 _ 0
@scc_5 pop}{1 $dcol eq{0 exch 0 exch 1 exch sub 0 0 _ 0 @scc_5 pop}{2 $dcol eq
{0 exch 0 exch 0 exch 1 exch sub 0 _ 0 @scc_5 pop}{SetGry}ifelse}ifelse}ifelse
}bd/$corelmeter[1 .95 .75 .50 .25 .05 0]def/@colormeter{@gs @np 0 @setdcol 0.3
w/Courier findfont 5 scalefont setfont/yy xd/xx xd 0 1 6{dup xx 20 sub yy m 20
@sqr @gs $corelmeter exch get dup @setdcol fill @gr stroke xx 18 sub yy 2 add m
exch dup 3 ge{1 SetGry}{0 @setdcol}ifelse 3 eq{pop}{100 mul 100 exch sub cvi 20
string cvs show}ifelse/yy yy 20 add def}for @gr}bd/@calbar{@gs Tl @gs @np 0 0 m
@gs 20 @sqr 1 1 0 0 0 _ 0 @scc_5 pop fill @gr 20 0 Tl 0 0 m @gs 20 @sqr 1 1 0 1
0 _ 0 @scc_5 pop fill @gr 20 0 Tl 0 0 m @gs 20 @sqr 1 0 0 1 0 _ 0 @scc_5 pop
fill @gr 20 0 Tl 0 0 m @gs 20 @sqr 1 0 1 1 0 _ 0 @scc_5 pop fill @gr 20 0 Tl 0
0 m @gs 20 @sqr 1 0 1 0 0 _ 0 @scc_5 pop fill @gr 20 0 Tl 0 0 m @gs 20 @sqr 1 1
1 0 0 _ 0 @scc_5 pop fill @gr 20 0 Tl 0 0 m @gs 20 @sqr 1 1 1 1 0 _ 0 @scc_5
pop fill @gr @gr @np -84 0 Tl @gs 0 0 m 20 @sqr clip 1 1 0 0 0 _ 0 @scc_5 pop
@gain @gr 20 0 Tl @gs 0 0 m 20 @sqr clip 1 0 1 0 0 _ 0 @scc_5 pop @gain @gr 20
0 Tl @gs 0 0 m 20 @sqr clip 1 0 0 1 0 _ 0 @scc_5 pop @gain @gr 20 0 Tl @gs 0 0
m 20 @sqr clip 1 0 0 0 1 _ 0 @scc_5 pop @gain @gr @gr}bd/@gain{10 10 Tl @np 0 0
m 0 10 360{0 0 15 4 -1 roll dup 5 add arc @cp}for fill}bd/@crop{@gs 10 div
/$croplen xd .3 w 0 @smc Tl rotate 0 0 m 0 $croplen neg rl stroke @gr}bd
/deflevel 0 def/@sax{/deflevel deflevel 1 add def}bd/@eax{/deflevel deflevel
dup 0 gt{1 sub}if def deflevel 0 gt{/eax load}{eax}ifelse}bd/eax{{exec}forall}
bd/@rax{deflevel 0 eq{@rs @sv}if}bd/@daq{dup type/arraytype eq{{}forall}if}bd
/@BMP{/@cc xd 12 index 1 gt UseLevel2 true eq and{7 -2 roll pop pop @I_2}{11
index 1 eq{12 -1 roll pop @i}{7 -2 roll pop pop @I}ifelse}ifelse}bd systemdict
/pdfmark known not{/pdfmark/cleartomark ld}if/@BeginEPS{$ngx 0 SetGry 0 J 0 j 1
w[]0 d 10 M false setoverprint @np/EPSDict 200 dict def EPSDict begin @sv
SepMode_5 0 ne{/colorimage{@gs/sepdict 50 dict def sepdict begin[{1 exch sub}
/exec cvx currenttransfer/exec cvx]cvx settransfer 3 eq/$rgb xd{$rgb{/daq0 xd
/daq1 xd/daq2 xd/daq_rgb load}{/daq0 xd/daq1 xd/daq2 xd/daq3 xd/daq_cmyk load}
ifelse}{/daq0 xd/daq_one load}ifelse 2 index 8 eq/8bit xd $ink_5 dup 0 lt exch
3 gt or{}{image}ifelse end @gr}bd/2cmyk{3{255 exch sub 3 1 roll}repeat 3 copy
@MN @MN 3{dup 5 -1 roll sub neg exch}repeat}bd/daq_rgb{/i 0 def/daq2 load exec
/daq1 load exec/daq0 load exec dup dup length 0 exch getinterval/$data xd{8bit
{1 index i get 3 index i get 2cmyk 4 $ink_5 neg roll pop pop pop}{pop 0}ifelse
$data i 3 -1 roll put/i i 1 add def}forall pop pop $data}bd/daq_cmyk{/daq3 load
exec/daq2 load exec/daq1 load exec/daq0 load exec 4 $ink_5 neg roll pop pop pop
}bd/daq_one{/$in 0 def/$out 0 def/daq0 load exec dup dup length $rgb{3}{4}
ifelse idiv 0 exch getinterval/$data xd $data{pop 8bit{$rgb{0 index $in 2 add
get 1 index $in 1 add get 2 index $in get 2cmyk}{0 index $in get 1 index $in 1
add get 2 index $in 2 add get 3 index $in 3 add get}ifelse 4 $ink_5 neg roll
pop pop pop}{0}ifelse $data $out 3 -1 roll put/$in $in $rgb{3}{4}ifelse add def
/$out $out 1 add def}forall pop $data}bd}if}bd/@EndEPS{@rs end}bd end
%%EndResource
%%EndProlog
%%BeginSetup
wCorel6Dict begin
@BeginSysCorelDict
2.6131 setmiterlimit
1.00 setflat
/$fst 128 def
%%EndSetup
%%Page: 1 1
%LogicalPage: 1
%%BeginPageSetup
@sv
@sm
@sv
%%EndPageSetup
@rax %Note: Object
83.97014 259.95969 114.68438 290.67392 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
99.32712 290.67392 m
107.78542 290.67392 114.68438 283.77496 114.68438 275.31666 c
114.68438 266.85836 107.78542 259.95969 99.32712 259.95969 c
90.86882 259.95969 83.97014 266.85836 83.97014 275.31666 c
83.97014 283.77496 90.86882 290.67392 99.32712 290.67392 c
@c
S
@rax %Note: Object
279.32825 232.53874 310.04277 263.25326 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
294.68551 263.25326 m
303.14381 263.25326 310.04277 256.35430 310.04277 247.89600 c
310.04277 239.43770 303.14381 232.53874 294.68551 232.53874 c
286.22721 232.53874 279.32825 239.43770 279.32825 247.89600 c
279.32825 256.35430 286.22721 263.25326 294.68551 263.25326 c
@c
S
@rax %Note: Object
230.18513 281.09282 260.89937 311.80706 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
245.54239 311.80706 m
254.00069 311.80706 260.89937 304.90838 260.89937 296.45008 c
260.89937 287.99178 254.00069 281.09282 245.54239 281.09282 c
237.08409 281.09282 230.18513 287.99178 230.18513 296.45008 c
230.18513 304.90838 237.08409 311.80706 245.54239 311.80706 c
@c
S
@rax %Note: Object
65.86441 334.92841 196.39956 420.47603 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
131.13213 420.47603 m
167.07997 420.47603 196.39956 401.26110 196.39956 377.70208 c
196.39956 354.14334 167.07997 334.92841 131.13213 334.92841 c
95.18372 334.92841 65.86441 354.14334 65.86441 377.70208 c
65.86441 401.26110 95.18372 420.47603 131.13213 420.47603 c
@c
S
@rax %Note: Object
18.25739 132.23424 148.79254 217.78186 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
83.52510 217.78186 m
119.47323 217.78186 148.79254 198.56693 148.79254 175.00791 c
148.79254 151.44917 119.47323 132.23424 83.52510 132.23424 c
47.57698 132.23424 18.25739 151.44917 18.25739 175.00791 c
18.25739 198.56693 47.57698 217.78186 83.52510 217.78186 c
@c
S
@rax %Note: Object
358.41742 313.34910 488.95257 398.89672 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
423.68513 398.89672 m
459.63298 398.89672 488.95257 379.68180 488.95257 356.12277 c
488.95257 332.56375 459.63298 313.34910 423.68513 313.34910 c
387.73672 313.34910 358.41742 332.56375 358.41742 356.12277 c
358.41742 379.68180 387.73672 398.89672 423.68513 398.89672 c
@c
S
@rax %Note: Object
42.92561 103.02831 63.38098 123.48369 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
46.98283 123.48369 m
63.38098 119.42646 L
59.32375 103.02831 L
42.92561 107.08554 L
46.98283 123.48369 L
@c
S
@rax %Note: Object
54.59528 121.55641 58.20066 136.12791 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
54.59528 121.55641 m
58.20066 136.12791 L
S
@rax %Note: Object
62.18079 416.13307 85.60488 439.55717 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
85.60488 425.49761 m
71.54532 416.13307 L
62.18079 430.19263 L
76.24035 439.55717 L
85.60488 425.49761 L
@c
S
@rax %Note: Object
79.04551 408.68646 87.36690 421.17987 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
79.04551 421.17987 m
87.36690 408.68646 L
S
@rax %Note: Object
111.04526 103.96715 132.91540 125.83729 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
111.04526 119.70907 m
126.78718 125.83729 L
132.91540 110.09537 L
117.17348 103.96715 L
111.04526 119.70907 L
@c
S
@rax %Note: Object
112.93285 122.51820 118.37849 136.50661 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
118.37849 122.51820 m
112.93285 136.50661 L
S
@rax %Note: Object
77.10151 100.53014 93.99402 117.42293 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
77.10151 117.42293 m
93.99402 117.42293 L
93.99402 100.53014 L
77.10151 100.53014 L
77.10151 117.42293 L
@c
S
@rax %Note: Object
84.95348 117.38041 84.95461 132.39128 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
84.95405 117.38041 m
84.95405 132.39128 L
S
@rax %Note: Object
100.99531 431.86224 121.27776 452.14441 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
121.27776 435.69156 m
104.82463 431.86224 L
100.99531 448.31509 L
117.44844 452.14441 L
121.27776 435.69156 L
@c
S
@rax %Note: Object
113.61997 419.33254 117.02268 433.95307 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
113.61997 433.95307 m
117.02268 419.33254 L
S
@rax %Note: Object
144.97342 431.85288 165.03959 451.91906 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
161.48863 431.85288 m
144.97342 435.40384 L
148.52438 451.91906 L
165.03959 448.36809 L
161.48863 431.85288 L
@c
S
@rax %Note: Object
150.66510 418.86964 153.82063 433.54517 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
153.82063 433.54517 m
150.66510 418.86964 L
S
@rax %Note: Object
180.05528 414.07427 203.45272 437.47172 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
194.16699 414.07427 m
180.05528 423.36028 L
189.34101 437.47172 L
203.45272 428.18598 L
194.16699 414.07427 L
@c
S
@rax %Note: Object
179.37921 405.88668 187.63058 418.42658 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
187.63058 418.42658 m
179.37921 405.88668 L
S
@rax %Note: Object
459.08447 400.93455 481.57483 423.42491 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
474.35811 400.93455 m
459.08447 408.15156 L
466.30148 423.42491 L
481.57483 416.20791 L
474.35811 400.93455 L
@c
S
@rax %Note: Object
460.86321 390.75562 467.27631 404.32791 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
467.27631 404.32791 m
460.86321 390.75562 L
S
@rax %Note: Object
407.76208 412.44350 426.30180 430.98293 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
426.30180 414.17972 m
409.49830 412.44350 L
407.76208 429.24671 L
424.56557 430.98293 L
426.30180 414.17972 L
@c
S
@rax %Note: Object
418.48639 398.48343 420.02901 413.41493 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
418.48639 413.41493 m
420.02901 398.48343 L
S
@rax %Note: Object
499.01301 362.19969 520.42876 383.61543 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
504.42718 362.19969 m
499.01301 378.20098 L
515.01430 383.61543 L
520.42876 367.61386 L
504.42718 362.19969 L
@c
S
@rax %Note: Object
487.73169 364.84044 501.95083 369.65169 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
501.95083 369.65169 m
487.73169 364.84044 L
S
@rax %Note: Object
184.11392 307.48762 233.84268 353.20224 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
184.11392 353.20224 m
233.84268 307.48762 L
S
@rax %Note: Object
255.22157 256.54649 281.77880 284.62989 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
255.22157 284.62989 m
281.77880 256.54649 L
S
@rax %Note: Object
259.40409 303.75553 363.04441 339.20787 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
259.40409 303.75553 m
363.04441 339.20787 L
S
@rax %Note: Object
304.48517 259.90696 373.26898 328.01244 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
304.48517 259.90696 m
373.26898 328.01244 L
S
@rax %Note: Object
97.20510 216.99099 97.66998 260.37326 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
97.66998 260.37326 m
97.20510 216.99099 L
S
@rax %Note: Object
99.52894 291.16063 111.61247 336.87553 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
99.52894 291.16063 m
111.61247 336.87553 L
S
@rax 298.00573 52.50643 381.29613 176.63839 @E
[0.00028346 0.00000000 0.00000000 0.00028346 304.50528020 174.93193061] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 63499.00000 z
%CHAR: 0 -57480 (1) @t
23657 -57480 m
18073 -57480 L
18073 -21918 L
16729 -23198 14961 -24486 12785 -25767 c
10609 -27047 8640 -28007 6912 -28647 C
6912 -23254 L
10032 -21790 12761 -20006 15097 -17926 c
17433 -15838 19089 -13806 20057 -11846 C
23657 -11846 L
23657 -57480 L
@c
F
%CHAR: 133264 -57480 (c) @t
158937 -45415 m
164417 -46135 L
163825 -49912 162281 -52880 159817 -55016 c
157353 -57160 154313 -58232 150713 -58232 c
146217 -58232 142592 -56760 139856 -53816 c
137120 -50872 135744 -46639 135744 -41143 c
135744 -37591 136336 -34479 137504 -31815 c
138680 -29151 140480 -27143 142880 -25815 c
145289 -24486 147913 -23814 150745 -23814 c
154321 -23814 157249 -24718 159521 -26527 c
161793 -28335 163249 -30903 163889 -34231 C
158465 -35071 L
157953 -32863 157033 -31191 155721 -30079 c
154409 -28959 152817 -28399 150961 -28399 c
148153 -28399 145865 -29407 144113 -31423 c
142360 -33439 141480 -36631 141480 -40991 c
141480 -45407 142328 -48632 144017 -50632 c
145713 -52632 147929 -53640 150657 -53640 c
152841 -53640 154673 -52968 156137 -51624 c
157609 -50280 158545 -48208 158929 -45423 C
158937 -45415 L
@c
F
%CHAR: 0 -128552 (2) @t
31970 -123192 m
31962 -128552 L
1920 -128552 L
1880 -127216 2096 -125920 2568 -124680 c
3336 -122632 4560 -120616 6240 -118632 c
7920 -116647 10360 -114351 13545 -111751 c
18481 -107703 21825 -104487 23553 -102127 c
25289 -99759 26161 -97519 26161 -95414 c
26161 -93206 25369 -91334 23793 -89814 c
22209 -88294 20145 -87534 17609 -87534 c
14921 -87534 12769 -88342 11161 -89950 c
9544 -91566 8728 -93806 8712 -96654 C
2976 -96062 L
3360 -91790 4840 -88526 7400 -86286 c
9960 -84046 13409 -82918 17729 -82918 c
22089 -82918 25545 -84126 28081 -86542 c
30625 -88958 31898 -91966 31898 -95534 c
31898 -97351 31521 -99143 30785 -100895 c
30041 -102655 28801 -104511 27081 -106447 c
25353 -108391 22481 -111063 18473 -114447 c
15129 -117255 12969 -119168 12025 -120168 c
11081 -121168 10288 -122184 9672 -123192 C
31970 -123192 L
@c
F
%CHAR: 133264 -128552 (l) @t
137328 -128552 m
137320 -83102 L
142904 -83102 L
142904 -128552 L
137328 -128552 L
@c
F
%CHAR: 147368 -128552 (o) @t
149480 -112087 m
149480 -105991 151168 -101471 154560 -98543 c
157392 -96110 160849 -94886 164913 -94886 c
169441 -94886 173145 -96374 176009 -99335 c
178881 -102295 180322 -106399 180322 -111623 c
180322 -115863 179682 -119200 178417 -121624 c
177145 -124056 175289 -125944 172865 -127288 c
170441 -128632 167785 -129304 164913 -129304 c
160305 -129304 156576 -127824 153736 -124872 c
150896 -121912 149472 -117647 149472 -112095 C
149480 -112087 L
@c
155208 -112087 m
155208 -116303 156128 -119464 157969 -121560 c
159809 -123656 162129 -124712 164913 -124712 c
167681 -124712 169985 -123656 171825 -121552 c
173665 -119440 174585 -116223 174585 -111903 c
174585 -107839 173657 -104751 171809 -102655 c
169961 -100559 167657 -99503 164913 -99503 c
162129 -99503 159809 -100551 157969 -102631 c
156128 -104719 155208 -107879 155208 -112095 C
155208 -112087 L
@c
F
%CHAR: 182680 -128552 (c) @t
208353 -116487 m
213833 -117207 L
213241 -120984 211697 -123952 209233 -126088 c
206769 -128232 203729 -129304 200129 -129304 c
195633 -129304 192008 -127832 189272 -124888 c
186536 -121944 185160 -117711 185160 -112215 c
185160 -108663 185752 -105551 186920 -102887 c
188096 -100223 189896 -98215 192296 -96887 c
194705 -95558 197329 -94886 200161 -94886 c
203737 -94886 206665 -95790 208937 -97599 c
211209 -99407 212665 -101975 213305 -105303 C
207881 -106143 L
207369 -103935 206449 -102263 205137 -101151 c
203825 -100031 202233 -99471 200377 -99471 c
197569 -99471 195281 -100479 193529 -102495 c
191776 -104511 190896 -107703 190896 -112063 c
190896 -116479 191744 -119704 193433 -121704 c
195129 -123704 197345 -124712 200073 -124712 c
202257 -124712 204089 -124040 205553 -122696 c
207025 -121352 207961 -119280 208345 -116495 C
208353 -116487 L
@c
F
%CHAR: 214432 -128552 (a) @t
240105 -124488 m
238041 -126248 236041 -127496 234137 -128216 c
232225 -128936 230169 -129304 227977 -129304 c
224360 -129304 221576 -128416 219640 -126656 c
217696 -124888 216720 -122624 216720 -119872 c
216720 -118264 217088 -116783 217816 -115455 c
218552 -114127 219520 -113047 220704 -112247 c
221888 -111447 223232 -110831 224720 -110415 c
225817 -110127 227473 -109847 229681 -109583 c
234185 -109047 237505 -108399 239633 -107655 C
239649 -106895 239665 -106407 239665 -106199 c
239665 -103927 239137 -102327 238089 -101399 c
236665 -100135 234537 -99503 231729 -99503 c
229105 -99503 227169 -99967 225921 -100879 c
224672 -101799 223736 -103431 223144 -105767 C
217680 -105023 L
218176 -102687 218992 -100799 220128 -99367 c
221264 -97927 222920 -96815 225065 -96046 c
227209 -95278 229705 -94886 232537 -94886 c
235345 -94886 237633 -95222 239385 -95878 c
241145 -96534 242441 -97375 243265 -98375 c
244089 -99375 244673 -100647 245001 -102167 c
245185 -103119 245281 -104839 245281 -107319 c
245281 -114759 l
245281 -119944 245401 -123232 245633 -124600 c
245873 -125976 246346 -127296 247050 -128552 C
241217 -128552 L
240641 -127400 240257 -126040 240097 -124496 C
240105 -124488 L
@c
239641 -112023 m
237609 -112855 234569 -113559 230521 -114135 c
228233 -114463 226601 -114839 225657 -115247 c
224704 -115663 223960 -116271 223448 -117063 c
222936 -117863 222672 -118752 222672 -119720 c
222672 -121208 223240 -122448 224360 -123440 c
225489 -124432 227145 -124928 229313 -124928 c
231457 -124928 233377 -124456 235049 -123520 c
236721 -122576 237953 -121288 238737 -119656 c
239329 -118400 239633 -116535 239633 -114079 c
239641 -112023 L
@c
F
%CHAR: 249744 -128552 (l) @t
253808 -128552 m
253800 -83102 L
259384 -83102 L
259384 -128552 L
253808 -128552 L
@c
F
%CHAR: 0 -199624 (3) @t
2664 -187623 m
8240 -186887 L
8880 -190048 9976 -192328 11513 -193720 c
13049 -195112 14937 -195816 17145 -195816 c
19769 -195816 21985 -194904 23793 -193088 c
25601 -191272 26505 -189015 26505 -186327 c
26505 -183767 25665 -181647 23993 -179983 c
22321 -178319 20185 -177487 17609 -177487 c
16553 -177487 15241 -177695 13673 -178111 C
14289 -173215 L
14657 -173247 14961 -173271 15185 -173271 c
17561 -173271 19705 -172647 21601 -171415 c
23505 -170175 24457 -168255 24457 -165678 c
24457 -163630 23761 -161934 22385 -160590 c
21001 -159246 19209 -158574 17017 -158574 c
14849 -158574 13033 -159262 11593 -160622 c
10152 -161982 9216 -164038 8800 -166758 C
3224 -165766 L
3896 -162030 5448 -159126 7864 -157078 c
10280 -155022 13297 -153990 16897 -153990 c
19377 -153990 21665 -154526 23745 -155582 c
25833 -156646 27433 -158102 28537 -159942 c
29641 -161782 30193 -163734 30193 -165798 c
30193 -167766 29665 -169559 28617 -171167 c
27561 -172775 25993 -174063 23929 -175007 C
26617 -175631 28705 -176919 30193 -178871 c
31681 -180823 32426 -183271 32426 -186199 c
32426 -190168 30977 -193536 28089 -196288 c
25193 -199048 21529 -200432 17113 -200432 c
13129 -200432 9808 -199240 7176 -196872 c
4544 -194496 3032 -191408 2664 -187631 c
2664 -187623 L
@c
F
%CHAR: 133264 -199624 (b) @t
142600 -199624 m
137416 -199624 L
137416 -154174 L
142992 -154174 L
142992 -170391 L
145345 -167438 148361 -165958 152017 -165958 c
154041 -165958 155961 -166366 157769 -167182 c
159577 -167999 161065 -169151 162233 -170623 c
163401 -172095 164321 -173887 164977 -175967 c
165634 -178055 165970 -180295 165970 -182671 c
165970 -188311 164569 -192680 161785 -195752 c
159001 -198832 155641 -200376 151737 -200376 c
147857 -200376 144801 -198752 142592 -195504 C
142600 -199624 L
@c
142536 -182911 m
142536 -186863 143072 -189720 144145 -191472 c
145897 -194344 148281 -195784 151273 -195784 c
153705 -195784 155817 -194720 157593 -192608 c
159369 -190488 160265 -187327 160265 -183135 c
160265 -178839 159409 -175663 157713 -173615 c
156009 -171567 153937 -170543 151521 -170543 c
149089 -170543 146977 -171607 145201 -173719 c
143424 -175839 142528 -178911 142528 -182919 C
142536 -182911 L
@c
F
%CHAR: 0 -270696 (A) @t
-104 -270696 m
17361 -225246 L
23841 -225246 L
42442 -270696 L
35594 -270696 L
30289 -256935 L
11281 -256935 L
6288 -270696 L
-104 -270696 L
@c
13025 -252031 m
28425 -252031 L
23681 -239447 l
22241 -235622 21161 -232478 20457 -230022 C
19881 -232934 19065 -235830 18009 -238702 c
13025 -252031 L
@c
F
%CHAR: 136800 -270696 (3) @t
139464 -258695 m
145040 -257959 L
145680 -261120 146776 -263400 148313 -264792 c
149849 -266184 151737 -266888 153945 -266888 c
156569 -266888 158785 -265976 160593 -264160 c
162401 -262344 163305 -260087 163305 -257399 c
163305 -254839 162465 -252719 160793 -251055 c
159121 -249391 156985 -248559 154409 -248559 c
153353 -248559 152041 -248767 150473 -249183 C
151089 -244287 L
151457 -244319 151761 -244343 151985 -244343 c
154361 -244343 156505 -243719 158401 -242487 c
160305 -241247 161257 -239327 161257 -236750 c
161257 -234702 160561 -233006 159185 -231662 c
157801 -230318 156009 -229646 153817 -229646 c
151649 -229646 149833 -230334 148393 -231694 c
146952 -233054 146016 -235110 145600 -237830 C
140024 -236838 L
140696 -233102 142248 -230198 144664 -228150 c
147080 -226094 150097 -225062 153697 -225062 c
156177 -225062 158465 -225598 160545 -226654 c
162633 -227718 164233 -229174 165337 -231014 c
166441 -232854 166993 -234806 166993 -236870 c
166993 -238838 166465 -240631 165417 -242239 c
164361 -243847 162793 -245135 160729 -246079 C
163417 -246703 165505 -247991 166993 -249943 c
168481 -251895 169226 -254343 169226 -257271 c
169226 -261240 167777 -264608 164889 -267360 c
161993 -270120 158329 -271504 153913 -271504 c
149929 -271504 146608 -270312 143976 -267944 c
141344 -265568 139832 -262480 139464 -258703 c
139464 -258695 L
@c
F
%CHAR: 0 -341768 (B) @t
4648 -341768 m
4648 -296318 L
21697 -296318 l
25169 -296318 27953 -296782 30049 -297694 c
32146 -298614 33802 -300038 34986 -301942 c
36170 -303854 36770 -305862 36770 -307942 c
36770 -309886 36242 -311719 35194 -313431 c
34138 -315143 32538 -316535 30409 -317591 C
33162 -318391 35282 -319775 36754 -321711 c
38226 -323647 38970 -325951 38970 -328591 c
38970 -330719 38522 -332712 37626 -334536 c
36730 -336360 35610 -337776 34290 -338768 c
32970 -339760 31305 -340512 29313 -341008 c
27321 -341512 24873 -341768 21977 -341768 c
4648 -341768 L
@c
10665 -315415 m
20489 -315415 l
23153 -315415 25073 -315239 26225 -314887 c
27753 -314439 28913 -313679 29681 -312631 c
30457 -311575 30849 -310247 30849 -308654 c
30849 -307150 30481 -305822 29761 -304678 c
29041 -303526 28001 -302734 26665 -302318 c
25321 -301894 23009 -301678 19745 -301678 c
10665 -301678 L
10665 -315415 L
@c
10665 -336408 m
21977 -336408 l
23921 -336408 25289 -336336 26073 -336192 c
27449 -335944 28609 -335528 29537 -334952 c
30465 -334376 31241 -333528 31834 -332424 c
32434 -331320 32738 -330039 32738 -328591 c
32738 -326903 32298 -325431 31433 -324183 c
30569 -322935 29361 -322047 27825 -321543 c
26289 -321039 24065 -320783 21169 -320783 c
10665 -320783 L
10665 -336408 L
@c
F
%CHAR: 140304 -341768 (a) @t
165977 -337704 m
163913 -339464 161913 -340712 160009 -341432 c
158097 -342152 156041 -342520 153849 -342520 c
150232 -342520 147448 -341632 145512 -339872 c
143568 -338104 142592 -335840 142592 -333088 c
142592 -331480 142960 -329999 143688 -328671 c
144424 -327343 145392 -326263 146576 -325463 c
147760 -324663 149104 -324047 150592 -323631 c
151689 -323343 153345 -323063 155553 -322799 c
160057 -322263 163377 -321615 165505 -320871 C
165521 -320111 165537 -319623 165537 -319415 c
165537 -317143 165009 -315543 163961 -314615 c
162537 -313351 160409 -312719 157601 -312719 c
154977 -312719 153041 -313183 151793 -314095 c
150544 -315015 149608 -316647 149016 -318983 C
143552 -318239 L
144048 -315903 144864 -314015 146000 -312583 c
147136 -311143 148792 -310031 150937 -309262 c
153081 -308494 155577 -308102 158409 -308102 c
161217 -308102 163505 -308438 165257 -309094 c
167017 -309750 168313 -310591 169137 -311591 c
169961 -312591 170545 -313863 170873 -315383 c
171057 -316335 171153 -318055 171153 -320535 c
171153 -327975 l
171153 -333160 171273 -336448 171505 -337816 c
171745 -339192 172218 -340512 172922 -341768 C
167089 -341768 L
166513 -340616 166129 -339256 165969 -337712 C
165977 -337704 L
@c
165513 -325239 m
163481 -326071 160441 -326775 156393 -327351 c
154105 -327679 152473 -328055 151529 -328463 c
150576 -328879 149832 -329487 149320 -330279 c
148808 -331079 148544 -331968 148544 -332936 c
148544 -334424 149112 -335664 150232 -336656 c
151361 -337648 153017 -338144 155185 -338144 c
157329 -338144 159249 -337672 160921 -336736 c
162593 -335792 163825 -334504 164609 -332872 c
165201 -331616 165505 -329751 165505 -327295 c
165513 -325239 L
@c
F
%CHAR: 0 -412840 (C) @t
37330 -396903 m
43338 -398423 L
42082 -403368 39810 -407136 36538 -409728 c
33266 -412320 29257 -413616 24521 -413616 c
19625 -413616 15641 -412616 12577 -410624 c
9504 -408632 7168 -405736 5568 -401959 c
3968 -398183 3160 -394111 3160 -389775 c
3160 -385047 4064 -380910 5872 -377390 c
7680 -373870 10256 -371182 13593 -369358 c
16929 -367534 20609 -366614 24617 -366614 c
29161 -366614 32986 -367774 36082 -370086 c
39186 -372398 41354 -375662 42570 -379854 C
36642 -381247 L
35594 -377942 34058 -375526 32058 -374022 c
30057 -372518 27529 -371758 24489 -371758 c
21001 -371758 18073 -372598 15729 -374270 c
13385 -375942 11729 -378198 10785 -381014 c
9840 -383831 9360 -386751 9360 -389743 c
9360 -393607 9928 -396983 11049 -399863 c
12169 -402744 13929 -404904 16305 -406328 c
18681 -407752 21257 -408472 24025 -408472 c
27393 -408472 30249 -407496 32586 -405560 c
34922 -403616 36506 -400727 37330 -396903 C
@c
F
%CHAR: 143808 -412840 (1) @t
167465 -412840 m
161881 -412840 L
161881 -377278 L
160537 -378558 158769 -379846 156593 -381127 c
154417 -382407 152448 -383367 150720 -384007 C
150720 -378614 L
153840 -377150 156569 -375366 158905 -373286 c
161241 -371198 162897 -369166 163865 -367206 C
167465 -367206 L
167465 -412840 L
@c
F
T
@rax 298.00573 52.50643 381.29613 176.63839 @E
[0.00028346 0.00000000 0.00000000 0.00028346 304.50528020 174.93193061] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/MTExtra 63499.00000 z
%CHAR: 52952 -57480 (a) @t
57712 -43511 m
57712 -57736 L
54536 -57736 L
54536 -25726 L
57712 -25726 L
57712 -39951 L
106539 -39951 L
105314 -38727 103586 -36783 101362 -34143 c
99138 -31503 97242 -29199 95682 -27255 C
97906 -25030 L
102130 -30071 107451 -35639 113843 -41735 C
107451 -47832 102130 -53400 97906 -58432 C
95682 -56216 L
100802 -49824 104426 -45583 106539 -43511 C
57712 -43511 L
@c
F
%CHAR: 52952 -128552 (a) @t
57712 -114583 m
57712 -128808 L
54536 -128808 L
54536 -96798 L
57712 -96798 L
57712 -111023 L
106539 -111023 L
105314 -109799 103586 -107855 101362 -105215 c
99138 -102575 97242 -100271 95682 -98327 C
97906 -96102 L
102130 -101143 107451 -106711 113843 -112807 C
107451 -118904 102130 -124472 97906 -129504 C
95682 -127288 L
100802 -120896 104426 -116655 106539 -114583 C
57712 -114583 L
@c
F
%CHAR: 52952 -199624 (a) @t
57712 -185655 m
57712 -199880 L
54536 -199880 L
54536 -167870 L
57712 -167870 L
57712 -182095 L
106539 -182095 L
105314 -180871 103586 -178927 101362 -176287 c
99138 -173647 97242 -171343 95682 -169399 C
97906 -167174 L
102130 -172215 107451 -177783 113843 -183879 C
107451 -189976 102130 -195544 97906 -200576 C
95682 -198360 L
100802 -191968 104426 -187727 106539 -185655 C
57712 -185655 L
@c
F
%CHAR: 56488 -270696 (a) @t
61248 -256727 m
61248 -270952 L
58072 -270952 L
58072 -238942 L
61248 -238942 L
61248 -253167 L
110075 -253167 L
108850 -251943 107122 -249999 104898 -247359 c
102674 -244719 100778 -242415 99218 -240471 C
101442 -238246 L
105666 -243287 110987 -248855 117379 -254951 C
110987 -261048 105666 -266616 101442 -271648 C
99218 -269432 L
104338 -263040 107962 -258799 110075 -256727 C
61248 -256727 L
@c
F
%CHAR: 59992 -341768 (a) @t
64752 -327799 m
64752 -342024 L
61576 -342024 L
61576 -310014 L
64752 -310014 L
64752 -324239 L
113579 -324239 L
112354 -323015 110626 -321071 108402 -318431 c
106178 -315791 104282 -313487 102722 -311543 C
104946 -309318 L
109170 -314359 114491 -319927 120883 -326023 C
114491 -332120 109170 -337688 104946 -342720 C
102722 -340504 L
107842 -334112 111466 -329871 113579 -327799 C
64752 -327799 L
@c
F
%CHAR: 63496 -412840 (a) @t
68256 -398871 m
68256 -413096 L
65080 -413096 L
65080 -381086 L
68256 -381086 L
68256 -395311 L
117083 -395311 L
115858 -394087 114130 -392143 111906 -389503 c
109682 -386863 107786 -384559 106226 -382615 C
108450 -380390 L
112674 -385431 117995 -390999 124387 -397095 C
117995 -403192 112674 -408760 108450 -413792 C
106226 -411576 L
111346 -405184 114970 -400943 117083 -398871 C
68256 -398871 L
@c
F
T
@rax 413.35115 55.92019 553.73272 208.51654 @E
[0.00028346 0.00000000 0.00000000 0.00028346 419.85069330 205.98632317] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_LucidaConsole 42333.00000 z
%CHAR: 0 -33408 (P) @t
4716 -33408 m
4716 -6890 L
13331 -6890 l
16403 -6890 18599 -7166 19907 -7718 c
22582 -8876 23920 -11114 23920 -14413 c
23920 -17197 22840 -19381 20687 -20965 c
18527 -22549 15551 -23341 11765 -23341 c
8789 -23341 L
8789 -33408 L
4716 -33408 L
@c
8789 -20281 m
11327 -20281 l
16841 -20281 19601 -18349 19601 -14497 c
19601 -12877 19079 -11708 18041 -11006 c
16997 -10304 15263 -9950 12839 -9950 c
8789 -9950 L
8789 -20281 L
@c
F
%CHAR: 25530 -33408 (o) @t
38285 -33930 m
34991 -33930 32400 -32880 30522 -30798 c
28644 -28710 27702 -25837 27702 -22189 c
27702 -18553 28650 -15685 30534 -13597 c
32418 -11510 35009 -10466 38285 -10466 c
41573 -10466 44165 -11510 46043 -13597 c
47926 -15685 48868 -18553 48868 -22189 c
48868 -25837 47926 -28710 46049 -30792 c
44165 -32880 41573 -33924 38285 -33924 C
38285 -33930 L
@c
38285 -30864 m
40241 -30864 41771 -30096 42869 -28572 c
43973 -27048 44525 -24913 44525 -22189 c
44525 -19477 43973 -17347 42875 -15823 c
41771 -14293 40241 -13525 38285 -13525 c
36329 -13525 34799 -14293 33701 -15817 c
32597 -17347 32046 -19477 32046 -22189 c
32046 -24913 32597 -27048 33695 -28572 c
34799 -30096 36329 -30864 38285 -30864 c
@c
F
%CHAR: 51060 -33408 (k) @t
55464 -33408 m
55464 -770 L
59537 -770 L
59537 -21667 L
68957 -10958 L
73366 -10958 L
64481 -21055 L
75616 -33408 L
70115 -33408 L
59537 -21667 L
59537 -33408 L
55464 -33408 L
@c
F
%CHAR: 76590 -33408 (u) @t
98332 -10958 m
98332 -33408 L
94259 -33408 L
94259 -29196 L
92387 -32346 89825 -33924 86585 -33924 c
82350 -33924 80226 -31386 80226 -26323 c
80226 -10958 L
84299 -10958 L
84299 -25207 l
84299 -26970 84569 -28224 85103 -28956 c
85637 -29688 86555 -30060 87851 -30060 c
89891 -30060 92027 -28584 94259 -25639 C
94259 -10958 L
98332 -10958 L
@c
F
%CHAR: 102120 -33408 (d) @t
120311 -33408 m
120311 -29196 L
118325 -32346 115865 -33924 112949 -33924 c
110417 -33924 108414 -32940 106950 -30972 c
105486 -29004 104748 -26317 104748 -22933 c
104748 -19213 105618 -16201 107352 -13909 c
109086 -11618 111359 -10466 114167 -10466 c
116579 -10466 118631 -11486 120311 -13525 C
120311 -770 L
124384 -770 L
124384 -33408 L
120311 -33408 L
@c
120311 -16585 m
118409 -14545 116543 -13525 114731 -13525 c
112943 -13525 111551 -14311 110567 -15883 c
109583 -17455 109092 -19669 109092 -22519 c
109092 -27792 110669 -30432 113819 -30432 c
116117 -30432 118283 -28998 120311 -26137 C
120311 -16585 L
@c
F
%CHAR: 153180 -33408 (c) @t
175984 -32682 m
173573 -33510 171167 -33924 168767 -33924 c
164855 -33924 161837 -32904 159726 -30870 c
157614 -28830 156552 -25933 156552 -22189 c
156552 -18511 157596 -15631 159684 -13567 c
161771 -11504 164675 -10466 168395 -10466 c
170765 -10466 173159 -10826 175570 -11546 C
175570 -14953 L
172913 -14005 170639 -13525 168767 -13525 c
166319 -13525 164387 -14299 162995 -15841 c
161597 -17383 160895 -19501 160895 -22189 c
160895 -24901 161645 -27024 163133 -28560 c
164627 -30096 166697 -30864 169325 -30864 c
171293 -30864 173519 -30402 175984 -29484 C
175984 -32682 L
@c
F
%CHAR: 204240 -33408 (n) @t
208002 -33408 m
208002 -10958 L
212075 -10958 L
212075 -15181 L
213947 -12038 216497 -10466 219725 -10466 c
223985 -10466 226114 -12997 226114 -18055 c
226114 -33408 L
222041 -33408 L
222041 -19171 l
222041 -17419 221765 -16171 221225 -15439 c
220679 -14701 219761 -14329 218483 -14329 c
216443 -14329 214307 -15799 212075 -18739 C
212075 -33408 L
208002 -33408 L
@c
F
%CHAR: 229770 -33408 (e) @t
252472 -32520 m
249647 -33456 247049 -33924 244697 -33924 c
240839 -33924 237869 -32928 235800 -30948 c
233724 -28968 232686 -26125 232686 -22435 c
232686 -18955 233682 -16081 235668 -13837 c
237659 -11594 240197 -10466 243269 -10466 c
246365 -10466 248657 -11396 250121 -13255 c
251590 -15115 252328 -18013 252328 -21937 c
252328 -23239 L
237029 -23239 L
237329 -28320 240071 -30864 245255 -30864 c
247445 -30864 249857 -30342 252472 -29298 C
252472 -32520 L
@c
237155 -20179 m
247985 -20179 L
247985 -19603 l
247985 -15553 246293 -13525 242915 -13525 c
241295 -13525 239969 -14113 238961 -15283 c
237947 -16453 237341 -18091 237149 -20179 C
237155 -20179 L
@c
F
%CHAR: 255300 -33408 (f) @t
264479 -33408 m
264479 -14539 L
258360 -14539 L
258360 -11480 L
264479 -11480 L
264479 -9104 l
264479 -5966 265211 -3704 266669 -2324 c
268127 -944 270527 -254 273863 -254 c
276065 -254 278158 -554 280126 -1148 C
280126 -4370 L
278116 -3668 276125 -3314 274169 -3314 c
272093 -3314 270629 -3710 269801 -4502 c
268973 -5294 268553 -6692 268553 -8672 c
268553 -11480 L
279280 -11480 L
279280 -14539 L
268553 -14539 L
268553 -33408 L
264479 -33408 L
@c
F
%CHAR: 280830 -33408 (u) @t
302572 -10958 m
302572 -33408 L
298499 -33408 L
298499 -29196 L
296627 -32346 294065 -33924 290825 -33924 c
286590 -33924 284466 -31386 284466 -26323 c
284466 -10958 L
288539 -10958 L
288539 -25207 l
288539 -26970 288809 -28224 289343 -28956 c
289877 -29688 290795 -30060 292091 -30060 c
294131 -30060 296267 -28584 298499 -25639 C
298499 -10958 L
302572 -10958 L
@c
F
%CHAR: 306360 -33408 (n) @t
310122 -33408 m
310122 -10958 L
314195 -10958 L
314195 -15181 L
316067 -12038 318617 -10466 321845 -10466 c
326105 -10466 328234 -12997 328234 -18055 c
328234 -33408 L
324161 -33408 L
324161 -19171 l
324161 -17419 323885 -16171 323345 -15439 c
322799 -14701 321881 -14329 320603 -14329 c
318563 -14329 316427 -15799 314195 -18739 C
314195 -33408 L
310122 -33408 L
@c
F
%CHAR: 331890 -33408 (g) @t
336276 -40919 m
336708 -37482 L
339143 -38514 341417 -39030 343505 -39030 c
347861 -39030 350039 -36954 350039 -32814 c
350231 -28758 L
348521 -31854 346043 -33408 342803 -33408 c
340241 -33408 338202 -32430 336696 -30486 c
335190 -28536 334434 -25903 334434 -22597 c
334434 -19003 335310 -16075 337056 -13825 c
338808 -11570 341081 -10442 343877 -10442 c
346067 -10442 348227 -11474 350351 -13525 C
350351 -10958 L
354178 -10958 L
354178 -28926 l
354178 -31830 353986 -34026 353602 -35490 c
353218 -36954 352487 -38256 351425 -39384 c
349733 -41183 347075 -42089 343469 -42089 c
341345 -42089 338946 -41693 336276 -40913 C
336276 -40919 L
@c
350105 -25447 m
350105 -16621 L
348269 -14557 346373 -13519 344417 -13519 c
342641 -13519 341255 -14293 340265 -15835 c
339275 -17377 338778 -19543 338778 -22327 c
338778 -24679 339215 -26526 340079 -27852 c
340943 -29184 342161 -29850 343715 -29850 c
346127 -29850 348257 -28380 350105 -25453 C
350105 -25447 L
@c
F
%CHAR: 357420 -33408 (u) @t
379162 -10958 m
379162 -33408 L
375089 -33408 L
375089 -29196 L
373217 -32346 370655 -33924 367415 -33924 c
363180 -33924 361056 -31386 361056 -26323 c
361056 -10958 L
365129 -10958 L
365129 -25207 l
365129 -26970 365399 -28224 365933 -28956 c
366467 -29688 367385 -30060 368681 -30060 c
370721 -30060 372857 -28584 375089 -25639 C
375089 -10958 L
379162 -10958 L
@c
F
%CHAR: 382950 -33408 (j) @t
386010 -41003 m
386010 -37590 L
388128 -38550 390233 -39036 392309 -39036 c
394043 -39036 395237 -38598 395873 -37728 c
396515 -36852 396839 -35226 396839 -32856 c
396839 -14017 L
387660 -14017 L
387660 -10958 L
400913 -10958 L
400913 -32028 l
400913 -35514 400223 -38064 398855 -39666 c
397487 -41267 395297 -42071 392309 -42071 c
390353 -42071 388254 -41711 386010 -40997 C
386010 -41003 L
@c
396323 -5876 m
396323 -770 L
401429 -770 L
401429 -5876 L
396323 -5876 L
@c
F
%CHAR: 408480 -33408 (e) @t
431182 -32520 m
428357 -33456 425759 -33924 423407 -33924 c
419549 -33924 416579 -32928 414510 -30948 c
412434 -28968 411396 -26125 411396 -22435 c
411396 -18955 412392 -16081 414378 -13837 c
416369 -11594 418907 -10466 421979 -10466 c
425075 -10466 427367 -11396 428831 -13255 c
430300 -15115 431038 -18013 431038 -21937 c
431038 -23239 L
415739 -23239 L
416039 -28320 418781 -30864 423965 -30864 c
426155 -30864 428567 -30342 431182 -29298 C
431182 -32520 L
@c
415865 -20179 m
426695 -20179 L
426695 -19603 l
426695 -15553 425003 -13525 421625 -13525 c
420005 -13525 418679 -14113 417671 -15283 c
416657 -16453 416051 -18091 415859 -20179 C
415865 -20179 L
@c
F
%CHAR: 434010 -33408 (:) @t
443705 -17077 m
443705 -10958 L
449825 -10958 L
449825 -17077 L
443705 -17077 L
@c
443705 -33408 m
443705 -27288 L
449825 -27288 L
449825 -33408 L
443705 -33408 L
@c
F
T
@rax 413.35115 55.92019 553.73272 208.51654 @E
[0.00028346 0.00000000 0.00000000 0.00028346 419.85069330 205.98632317] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 63499.00000 z
%CHAR: 0 -154990 (1) @t
23657 -154990 m
18073 -154990 L
18073 -119428 L
16729 -120708 14961 -121996 12785 -123277 c
10609 -124557 8640 -125517 6912 -126157 C
6912 -120764 L
10032 -119300 12761 -117516 15097 -115436 c
17433 -113348 19089 -111316 20057 -109356 C
23657 -109356 L
23657 -154990 L
@c
F
%CHAR: 133264 -154990 (3) @t
135928 -142989 m
141504 -142253 L
142144 -145414 143240 -147694 144777 -149086 c
146313 -150478 148201 -151182 150409 -151182 c
153033 -151182 155249 -150270 157057 -148454 c
158865 -146638 159769 -144381 159769 -141693 c
159769 -139133 158929 -137013 157257 -135349 c
155585 -133685 153449 -132853 150873 -132853 c
149817 -132853 148505 -133061 146937 -133477 C
147553 -128581 L
147921 -128613 148225 -128637 148449 -128637 c
150825 -128637 152969 -128013 154865 -126781 c
156769 -125541 157721 -123621 157721 -121044 c
157721 -118996 157025 -117300 155649 -115956 c
154265 -114612 152473 -113940 150281 -113940 c
148113 -113940 146297 -114628 144857 -115988 c
143416 -117348 142480 -119404 142064 -122124 C
136488 -121132 L
137160 -117396 138712 -114492 141128 -112444 c
143544 -110388 146561 -109356 150161 -109356 c
152641 -109356 154929 -109892 157009 -110948 c
159097 -112012 160697 -113468 161801 -115308 c
162905 -117148 163457 -119100 163457 -121164 c
163457 -123132 162929 -124925 161881 -126533 c
160825 -128141 159257 -129429 157193 -130373 C
159881 -130997 161969 -132285 163457 -134237 c
164945 -136189 165690 -138637 165690 -141565 c
165690 -145534 164241 -148902 161353 -151654 c
158457 -154414 154793 -155798 150377 -155798 c
146393 -155798 143072 -154606 140440 -152238 c
137808 -149862 136296 -146774 135928 -142997 c
135928 -142989 L
@c
F
%CHAR: 0 -226062 (2) @t
31970 -220702 m
31962 -226062 L
1920 -226062 L
1880 -224726 2096 -223430 2568 -222190 c
3336 -220142 4560 -218126 6240 -216142 c
7920 -214157 10360 -211861 13545 -209261 c
18481 -205213 21825 -201997 23553 -199637 c
25289 -197269 26161 -195029 26161 -192924 c
26161 -190716 25369 -188844 23793 -187324 c
22209 -185804 20145 -185044 17609 -185044 c
14921 -185044 12769 -185852 11161 -187460 c
9544 -189076 8728 -191316 8712 -194164 C
2976 -193572 L
3360 -189300 4840 -186036 7400 -183796 c
9960 -181556 13409 -180428 17729 -180428 c
22089 -180428 25545 -181636 28081 -184052 c
30625 -186468 31898 -189476 31898 -193044 c
31898 -194861 31521 -196653 30785 -198405 c
30041 -200165 28801 -202021 27081 -203957 c
25353 -205901 22481 -208573 18473 -211957 c
15129 -214765 12969 -216678 12025 -217678 c
11081 -218678 10288 -219694 9672 -220702 C
31970 -220702 L
@c
F
%CHAR: 133264 -226062 (l) @t
137328 -226062 m
137320 -180612 L
142904 -180612 L
142904 -226062 L
137328 -226062 L
@c
F
%CHAR: 147368 -226062 (o) @t
149480 -209597 m
149480 -203501 151168 -198981 154560 -196053 c
157392 -193620 160849 -192396 164913 -192396 c
169441 -192396 173145 -193884 176009 -196845 c
178881 -199805 180322 -203909 180322 -209133 c
180322 -213373 179682 -216710 178417 -219134 c
177145 -221566 175289 -223454 172865 -224798 c
170441 -226142 167785 -226814 164913 -226814 c
160305 -226814 156576 -225334 153736 -222382 c
150896 -219422 149472 -215157 149472 -209605 C
149480 -209597 L
@c
155208 -209597 m
155208 -213813 156128 -216974 157969 -219070 c
159809 -221166 162129 -222222 164913 -222222 c
167681 -222222 169985 -221166 171825 -219062 c
173665 -216950 174585 -213733 174585 -209413 c
174585 -205349 173657 -202261 171809 -200165 c
169961 -198069 167657 -197013 164913 -197013 c
162129 -197013 159809 -198061 157969 -200141 c
156128 -202229 155208 -205389 155208 -209605 C
155208 -209597 L
@c
F
%CHAR: 182680 -226062 (c) @t
208353 -213997 m
213833 -214717 L
213241 -218494 211697 -221462 209233 -223598 c
206769 -225742 203729 -226814 200129 -226814 c
195633 -226814 192008 -225342 189272 -222398 c
186536 -219454 185160 -215221 185160 -209725 c
185160 -206173 185752 -203061 186920 -200397 c
188096 -197733 189896 -195725 192296 -194397 c
194705 -193068 197329 -192396 200161 -192396 c
203737 -192396 206665 -193300 208937 -195109 c
211209 -196917 212665 -199485 213305 -202813 C
207881 -203653 L
207369 -201445 206449 -199773 205137 -198661 c
203825 -197541 202233 -196981 200377 -196981 c
197569 -196981 195281 -197989 193529 -200005 c
191776 -202021 190896 -205213 190896 -209573 c
190896 -213989 191744 -217214 193433 -219214 c
195129 -221214 197345 -222222 200073 -222222 c
202257 -222222 204089 -221550 205553 -220206 c
207025 -218862 207961 -216790 208345 -214005 C
208353 -213997 L
@c
F
%CHAR: 214432 -226062 (a) @t
240105 -221998 m
238041 -223758 236041 -225006 234137 -225726 c
232225 -226446 230169 -226814 227977 -226814 c
224360 -226814 221576 -225926 219640 -224166 c
217696 -222398 216720 -220134 216720 -217382 c
216720 -215774 217088 -214293 217816 -212965 c
218552 -211637 219520 -210557 220704 -209757 c
221888 -208957 223232 -208341 224720 -207925 c
225817 -207637 227473 -207357 229681 -207093 c
234185 -206557 237505 -205909 239633 -205165 C
239649 -204405 239665 -203917 239665 -203709 c
239665 -201437 239137 -199837 238089 -198909 c
236665 -197645 234537 -197013 231729 -197013 c
229105 -197013 227169 -197477 225921 -198389 c
224672 -199309 223736 -200941 223144 -203277 C
217680 -202533 L
218176 -200197 218992 -198309 220128 -196877 c
221264 -195437 222920 -194325 225065 -193556 c
227209 -192788 229705 -192396 232537 -192396 c
235345 -192396 237633 -192732 239385 -193388 c
241145 -194044 242441 -194885 243265 -195885 c
244089 -196885 244673 -198157 245001 -199677 c
245185 -200629 245281 -202349 245281 -204829 c
245281 -212269 l
245281 -217454 245401 -220742 245633 -222110 c
245873 -223486 246346 -224806 247050 -226062 C
241217 -226062 L
240641 -224910 240257 -223550 240097 -222006 C
240105 -221998 L
@c
239641 -209533 m
237609 -210365 234569 -211069 230521 -211645 c
228233 -211973 226601 -212349 225657 -212757 c
224704 -213173 223960 -213781 223448 -214573 c
222936 -215373 222672 -216262 222672 -217230 c
222672 -218718 223240 -219958 224360 -220950 c
225489 -221942 227145 -222438 229313 -222438 c
231457 -222438 233377 -221966 235049 -221030 c
236721 -220086 237953 -218798 238737 -217166 c
239329 -215910 239633 -214045 239633 -211589 c
239641 -209533 L
@c
F
%CHAR: 249744 -226062 (l) @t
253808 -226062 m
253800 -180612 L
259384 -180612 L
259384 -226062 L
253808 -226062 L
@c
F
%CHAR: 0 -297134 (3) @t
2664 -285133 m
8240 -284397 L
8880 -287558 9976 -289838 11513 -291230 c
13049 -292622 14937 -293326 17145 -293326 c
19769 -293326 21985 -292414 23793 -290598 c
25601 -288782 26505 -286525 26505 -283837 c
26505 -281277 25665 -279157 23993 -277493 c
22321 -275829 20185 -274997 17609 -274997 c
16553 -274997 15241 -275205 13673 -275621 C
14289 -270725 L
14657 -270757 14961 -270781 15185 -270781 c
17561 -270781 19705 -270157 21601 -268925 c
23505 -267685 24457 -265765 24457 -263188 c
24457 -261140 23761 -259444 22385 -258100 c
21001 -256756 19209 -256084 17017 -256084 c
14849 -256084 13033 -256772 11593 -258132 c
10152 -259492 9216 -261548 8800 -264268 C
3224 -263276 L
3896 -259540 5448 -256636 7864 -254588 c
10280 -252532 13297 -251500 16897 -251500 c
19377 -251500 21665 -252036 23745 -253092 c
25833 -254156 27433 -255612 28537 -257452 c
29641 -259292 30193 -261244 30193 -263308 c
30193 -265276 29665 -267069 28617 -268677 c
27561 -270285 25993 -271573 23929 -272517 C
26617 -273141 28705 -274429 30193 -276381 c
31681 -278333 32426 -280781 32426 -283709 c
32426 -287678 30977 -291046 28089 -293798 c
25193 -296558 21529 -297942 17113 -297942 c
13129 -297942 9808 -296750 7176 -294382 c
4544 -292006 3032 -288918 2664 -285141 c
2664 -285133 L
@c
F
%CHAR: 133264 -297134 (b) @t
142600 -297134 m
137416 -297134 L
137416 -251684 L
142992 -251684 L
142992 -267901 L
145345 -264948 148361 -263468 152017 -263468 c
154041 -263468 155961 -263876 157769 -264692 c
159577 -265509 161065 -266661 162233 -268133 c
163401 -269605 164321 -271397 164977 -273477 c
165634 -275565 165970 -277805 165970 -280181 c
165970 -285821 164569 -290190 161785 -293262 c
159001 -296342 155641 -297886 151737 -297886 c
147857 -297886 144801 -296262 142592 -293014 C
142600 -297134 L
@c
142536 -280421 m
142536 -284373 143072 -287230 144145 -288982 c
145897 -291854 148281 -293294 151273 -293294 c
153705 -293294 155817 -292230 157593 -290118 c
159369 -287998 160265 -284837 160265 -280645 c
160265 -276349 159409 -273173 157713 -271125 c
156009 -269077 153937 -268053 151521 -268053 c
149089 -268053 146977 -269117 145201 -271229 c
143424 -273349 142528 -276421 142528 -280429 C
142536 -280421 L
@c
F
%CHAR: 0 -368206 (A) @t
-104 -368206 m
17361 -322756 L
23841 -322756 L
42442 -368206 L
35594 -368206 L
30289 -354445 L
11281 -354445 L
6288 -368206 L
-104 -368206 L
@c
13025 -349541 m
28425 -349541 L
23681 -336957 l
22241 -333132 21161 -329988 20457 -327532 C
19881 -330444 19065 -333340 18009 -336212 c
13025 -349541 L
@c
F
%CHAR: 136800 -368206 (3) @t
139464 -356205 m
145040 -355469 L
145680 -358630 146776 -360910 148313 -362302 c
149849 -363694 151737 -364398 153945 -364398 c
156569 -364398 158785 -363486 160593 -361670 c
162401 -359854 163305 -357597 163305 -354909 c
163305 -352349 162465 -350229 160793 -348565 c
159121 -346901 156985 -346069 154409 -346069 c
153353 -346069 152041 -346277 150473 -346693 C
151089 -341797 L
151457 -341829 151761 -341853 151985 -341853 c
154361 -341853 156505 -341229 158401 -339997 c
160305 -338757 161257 -336837 161257 -334260 c
161257 -332212 160561 -330516 159185 -329172 c
157801 -327828 156009 -327156 153817 -327156 c
151649 -327156 149833 -327844 148393 -329204 c
146952 -330564 146016 -332620 145600 -335340 C
140024 -334348 L
140696 -330612 142248 -327708 144664 -325660 c
147080 -323604 150097 -322572 153697 -322572 c
156177 -322572 158465 -323108 160545 -324164 c
162633 -325228 164233 -326684 165337 -328524 c
166441 -330364 166993 -332316 166993 -334380 c
166993 -336348 166465 -338141 165417 -339749 c
164361 -341357 162793 -342645 160729 -343589 C
163417 -344213 165505 -345501 166993 -347453 c
168481 -349405 169226 -351853 169226 -354781 c
169226 -358750 167777 -362118 164889 -364870 c
161993 -367630 158329 -369014 153913 -369014 c
149929 -369014 146608 -367822 143976 -365454 c
141344 -363078 139832 -359990 139464 -356213 c
139464 -356205 L
@c
F
%CHAR: 0 -439278 (B) @t
4648 -439278 m
4648 -393828 L
21697 -393828 l
25169 -393828 27953 -394292 30049 -395204 c
32146 -396124 33802 -397548 34986 -399452 c
36170 -401364 36770 -403372 36770 -405452 c
36770 -407396 36242 -409229 35194 -410941 c
34138 -412653 32538 -414045 30409 -415101 C
33162 -415901 35282 -417285 36754 -419221 c
38226 -421157 38970 -423461 38970 -426101 c
38970 -428229 38522 -430222 37626 -432046 c
36730 -433870 35610 -435286 34290 -436278 c
32970 -437270 31305 -438022 29313 -438518 c
27321 -439022 24873 -439278 21977 -439278 c
4648 -439278 L
@c
10665 -412925 m
20489 -412925 l
23153 -412925 25073 -412749 26225 -412397 c
27753 -411949 28913 -411189 29681 -410141 c
30457 -409085 30849 -407757 30849 -406164 c
30849 -404660 30481 -403332 29761 -402188 c
29041 -401036 28001 -400244 26665 -399828 c
25321 -399404 23009 -399188 19745 -399188 c
10665 -399188 L
10665 -412925 L
@c
10665 -433918 m
21977 -433918 l
23921 -433918 25289 -433846 26073 -433702 c
27449 -433454 28609 -433038 29537 -432462 c
30465 -431886 31241 -431038 31834 -429934 c
32434 -428830 32738 -427549 32738 -426101 c
32738 -424413 32298 -422941 31433 -421693 c
30569 -420445 29361 -419557 27825 -419053 c
26289 -418549 24065 -418293 21169 -418293 c
10665 -418293 L
10665 -433918 L
@c
F
%CHAR: 140304 -439278 (a) @t
165977 -435214 m
163913 -436974 161913 -438222 160009 -438942 c
158097 -439662 156041 -440030 153849 -440030 c
150232 -440030 147448 -439142 145512 -437382 c
143568 -435614 142592 -433350 142592 -430598 c
142592 -428990 142960 -427509 143688 -426181 c
144424 -424853 145392 -423773 146576 -422973 c
147760 -422173 149104 -421557 150592 -421141 c
151689 -420853 153345 -420573 155553 -420309 c
160057 -419773 163377 -419125 165505 -418381 C
165521 -417621 165537 -417133 165537 -416925 c
165537 -414653 165009 -413053 163961 -412125 c
162537 -410861 160409 -410229 157601 -410229 c
154977 -410229 153041 -410693 151793 -411605 c
150544 -412525 149608 -414157 149016 -416493 C
143552 -415749 L
144048 -413413 144864 -411525 146000 -410093 c
147136 -408653 148792 -407541 150937 -406772 c
153081 -406004 155577 -405612 158409 -405612 c
161217 -405612 163505 -405948 165257 -406604 c
167017 -407260 168313 -408101 169137 -409101 c
169961 -410101 170545 -411373 170873 -412893 c
171057 -413845 171153 -415565 171153 -418045 c
171153 -425485 l
171153 -430670 171273 -433958 171505 -435326 c
171745 -436702 172218 -438022 172922 -439278 C
167089 -439278 L
166513 -438126 166129 -436766 165969 -435222 C
165977 -435214 L
@c
165513 -422749 m
163481 -423581 160441 -424285 156393 -424861 c
154105 -425189 152473 -425565 151529 -425973 c
150576 -426389 149832 -426997 149320 -427789 c
148808 -428589 148544 -429478 148544 -430446 c
148544 -431934 149112 -433174 150232 -434166 c
151361 -435158 153017 -435654 155185 -435654 c
157329 -435654 159249 -435182 160921 -434246 c
162593 -433302 163825 -432014 164609 -430382 c
165201 -429126 165505 -427261 165505 -424805 c
165513 -422749 L
@c
F
%CHAR: 0 -510350 (C) @t
37330 -494413 m
43338 -495933 L
42082 -500878 39810 -504646 36538 -507238 c
33266 -509830 29257 -511126 24521 -511126 c
19625 -511126 15641 -510126 12577 -508134 c
9504 -506142 7168 -503246 5568 -499469 c
3968 -495693 3160 -491621 3160 -487285 c
3160 -482557 4064 -478420 5872 -474900 c
7680 -471380 10256 -468692 13593 -466868 c
16929 -465044 20609 -464124 24617 -464124 c
29161 -464124 32986 -465284 36082 -467596 c
39186 -469908 41354 -473172 42570 -477364 C
36642 -478757 L
35594 -475452 34058 -473036 32058 -471532 c
30057 -470028 27529 -469268 24489 -469268 c
21001 -469268 18073 -470108 15729 -471780 c
13385 -473452 11729 -475708 10785 -478524 c
9840 -481341 9360 -484261 9360 -487253 c
9360 -491117 9928 -494493 11049 -497373 c
12169 -500254 13929 -502414 16305 -503838 c
18681 -505262 21257 -505982 24025 -505982 c
27393 -505982 30249 -505006 32586 -503070 c
34922 -501126 36506 -498237 37330 -494413 C
@c
F
%CHAR: 143808 -510350 (3) @t
146472 -498349 m
152048 -497613 L
152688 -500774 153784 -503054 155321 -504446 c
156857 -505838 158745 -506542 160953 -506542 c
163577 -506542 165793 -505630 167601 -503814 c
169409 -501998 170313 -499741 170313 -497053 c
170313 -494493 169473 -492373 167801 -490709 c
166129 -489045 163993 -488213 161417 -488213 c
160361 -488213 159049 -488421 157481 -488837 C
158097 -483941 L
158465 -483973 158769 -483997 158993 -483997 c
161369 -483997 163513 -483373 165409 -482141 c
167313 -480901 168265 -478981 168265 -476404 c
168265 -474356 167569 -472660 166193 -471316 c
164809 -469972 163017 -469300 160825 -469300 c
158657 -469300 156841 -469988 155401 -471348 c
153960 -472708 153024 -474764 152608 -477484 C
147032 -476492 L
147704 -472756 149256 -469852 151672 -467804 c
154088 -465748 157105 -464716 160705 -464716 c
163185 -464716 165473 -465252 167553 -466308 c
169641 -467372 171241 -468828 172345 -470668 c
173449 -472508 174001 -474460 174001 -476524 c
174001 -478492 173473 -480285 172425 -481893 c
171369 -483501 169801 -484789 167737 -485733 C
170425 -486357 172513 -487645 174001 -489597 c
175489 -491549 176234 -493997 176234 -496925 c
176234 -500894 174785 -504262 171897 -507014 c
169001 -509774 165337 -511158 160921 -511158 c
156937 -511158 153616 -509966 150984 -507598 c
148352 -505222 146840 -502134 146472 -498357 c
146472 -498349 L
@c
F
T
@rax 413.35115 55.92019 553.73272 208.51654 @E
[0.00028346 0.00000000 0.00000000 0.00028346 419.85069330 205.98632317] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/MTExtra 63499.00000 z
%CHAR: 52952 -154990 (a) @t
57712 -141021 m
57712 -155246 L
54536 -155246 L
54536 -123236 L
57712 -123236 L
57712 -137461 L
106539 -137461 L
105314 -136237 103586 -134293 101362 -131653 c
99138 -129013 97242 -126709 95682 -124765 C
97906 -122540 L
102130 -127581 107451 -133149 113843 -139245 C
107451 -145342 102130 -150910 97906 -155942 C
95682 -153726 L
100802 -147334 104426 -143093 106539 -141021 C
57712 -141021 L
@c
F
%CHAR: 52952 -226062 (a) @t
57712 -212093 m
57712 -226318 L
54536 -226318 L
54536 -194308 L
57712 -194308 L
57712 -208533 L
106539 -208533 L
105314 -207309 103586 -205365 101362 -202725 c
99138 -200085 97242 -197781 95682 -195837 C
97906 -193612 L
102130 -198653 107451 -204221 113843 -210317 C
107451 -216414 102130 -221982 97906 -227014 C
95682 -224798 L
100802 -218406 104426 -214165 106539 -212093 C
57712 -212093 L
@c
F
%CHAR: 52952 -297134 (a) @t
57712 -283165 m
57712 -297390 L
54536 -297390 L
54536 -265380 L
57712 -265380 L
57712 -279605 L
106539 -279605 L
105314 -278381 103586 -276437 101362 -273797 c
99138 -271157 97242 -268853 95682 -266909 C
97906 -264684 L
102130 -269725 107451 -275293 113843 -281389 C
107451 -287486 102130 -293054 97906 -298086 C
95682 -295870 L
100802 -289478 104426 -285237 106539 -283165 C
57712 -283165 L
@c
F
%CHAR: 56488 -368206 (a) @t
61248 -354237 m
61248 -368462 L
58072 -368462 L
58072 -336452 L
61248 -336452 L
61248 -350677 L
110075 -350677 L
108850 -349453 107122 -347509 104898 -344869 c
102674 -342229 100778 -339925 99218 -337981 C
101442 -335756 L
105666 -340797 110987 -346365 117379 -352461 C
110987 -358558 105666 -364126 101442 -369158 C
99218 -366942 L
104338 -360550 107962 -356309 110075 -354237 C
61248 -354237 L
@c
F
%CHAR: 59992 -439278 (a) @t
64752 -425309 m
64752 -439534 L
61576 -439534 L
61576 -407524 L
64752 -407524 L
64752 -421749 L
113579 -421749 L
112354 -420525 110626 -418581 108402 -415941 c
106178 -413301 104282 -410997 102722 -409053 C
104946 -406828 L
109170 -411869 114491 -417437 120883 -423533 C
114491 -429630 109170 -435198 104946 -440230 C
102722 -438014 L
107842 -431622 111466 -427381 113579 -425309 C
64752 -425309 L
@c
F
%CHAR: 63496 -510350 (a) @t
68256 -496381 m
68256 -510606 L
65080 -510606 L
65080 -478596 L
68256 -478596 L
68256 -492821 L
117083 -492821 L
115858 -491597 114130 -489653 111906 -487013 c
109682 -484373 107786 -482069 106226 -480125 C
108450 -477900 L
112674 -482941 117995 -488509 124387 -494605 C
117995 -500702 112674 -506270 108450 -511302 C
106226 -509086 L
111346 -502694 114970 -498453 117083 -496381 C
68256 -496381 L
@c
F
T
@rax %Note: Object
289.47175 44.08809 557.67969 214.78422 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.21600 0.21600 0.00000 @w
289.47175 214.78422 m
557.67969 214.78422 L
557.67969 44.08809 L
289.47175 44.08809 L
289.47175 214.78422 L
@c
S
@rax %Note: Object
394.90328 44.73156 394.90441 215.42258 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.21600 0.21600 0.00000 @w
394.90384 215.42258 m
394.90384 44.73156 L
S
@rax 289.96469 241.90838 299.24220 255.15298 @E
[0.00021766 0.00000000 0.00000000 0.00021766 289.96477394 241.90829453] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 84666.00000 z
%CHAR: 0 0 (2) @t
42621 7150 m
42621 0 L
2555 0 L
2508 1782 2790 3516 3423 5157 c
4442 7888 6083 10584 8322 13221 c
10573 15872 13819 18931 18064 22400 c
24651 27792 29105 32082 31414 35235 c
33723 38388 34884 41377 34884 44191 c
34884 47133 33829 49630 31731 51646 c
29621 53674 26866 54694 23479 54694 c
19892 54694 17020 53615 14875 51470 c
12729 49314 11639 46336 11616 42539 C
3962 43324 L
4477 49021 6458 53381 9869 56358 c
13292 59347 17888 60847 23643 60847 c
29457 60847 34063 59230 37450 56018 c
40838 52795 42539 48786 42539 44027 c
42539 41600 42033 39209 41049 36876 c
40064 34532 38412 32059 36114 29480 c
33817 26890 29984 23326 24639 18802 c
20173 15063 17302 12518 16036 11182 c
14770 9846 13714 8486 12893 7150 C
42621 7150 L
@c
F
T
@rax 240.85474 290.96646 250.26605 304.44576 @E
[0.00021766 0.00000000 0.00000000 0.00021766 240.85469059 291.20120864] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 84666.00000 z
%CHAR: 0 0 (3) @t
3552 16001 m
10994 16985 L
11838 12764 13304 9717 15344 7865 c
17396 6013 19904 5075 22858 5075 c
26351 5075 29316 6294 31719 8709 c
34133 11135 35341 14149 35341 17735 c
35341 21146 34227 23971 32000 26186 c
29773 28402 26925 29515 23479 29515 c
22072 29515 20314 29234 18228 28683 C
19048 35212 L
19541 35165 19951 35130 20255 35130 c
23420 35130 26268 35962 28800 37615 c
31332 39267 32610 41822 32610 45258 c
32610 47989 31684 50263 29843 52045 c
28003 53826 25612 54729 22694 54729 c
19798 54729 17384 53815 15462 52009 c
13538 50193 12284 47450 11733 43816 C
4290 45141 L
5204 50122 7279 53990 10490 56733 c
13714 59476 17735 60847 22529 60847 c
25835 60847 28882 60132 31660 58726 c
34438 57307 36571 55362 38048 52912 c
39525 50462 40264 47848 40264 45094 c
40264 42480 39560 40088 38154 37943 c
36747 35798 34661 34086 31906 32821 C
35493 32000 38283 30277 40264 27675 c
42244 25073 43242 21803 43242 17900 c
43242 12600 41307 8111 37450 4442 c
33594 762 28706 -1078 22811 -1078 c
17501 -1078 13081 504 9564 3669 c
6048 6833 4044 10948 3552 15989 c
3552 16001 L
@c
F
T
@rax 94.27493 268.81852 101.14157 282.06283 @E
[0.00021766 0.00000000 0.00000000 0.00021766 94.27491729 268.81837052] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 84666.00000 z
%CHAR: 0 0 (1) @t
31543 0 m
24100 0 L
24100 47415 L
22307 45703 19951 43992 17044 42291 c
14137 40580 11522 39291 9213 38435 C
9213 45633 L
13374 47591 17020 49970 20127 52748 c
23244 55526 25448 58233 26737 60847 C
31531 60847 L
31543 0 L
@c
F
T
@rax 324.79313 264.82791 334.25717 274.81635 @E
[0.00021766 0.00000000 0.00000000 0.00021766 324.79316307 265.04574485] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 84666.00000 z
%CHAR: 0 0 (a) @t
34227 5415 m
31473 3071 28812 1418 26268 457 c
23725 -504 20982 -996 18064 -996 c
13245 -996 9529 188 6939 2532 c
4349 4888 3048 7912 3048 11569 c
3048 13714 3540 15684 4513 17454 c
5497 19236 6787 20666 8357 21732 c
9940 22811 11733 23631 13714 24182 c
15169 24557 17384 24944 20338 25296 c
26339 26011 30769 26878 33606 27863 C
33629 28871 33641 29527 33641 29797 c
33641 32821 32938 34966 31531 36208 c
29632 37884 26808 38728 23057 38728 c
19564 38728 16985 38107 15321 36888 c
13655 35669 12413 33489 11616 30383 C
4337 31367 L
4993 34485 6083 37005 7595 38916 c
9107 40826 11311 42303 14172 43336 c
17032 44367 20361 44895 24135 44895 c
27886 44895 30933 44449 33266 43570 c
35610 42691 37333 41576 38435 40240 c
39537 38904 40322 37216 40756 35177 c
41002 33911 41131 31613 41131 28308 c
41131 18392 l
41131 11475 41295 7103 41600 5275 c
41916 3446 42550 1676 43488 0 C
35716 0 L
34942 1535 34438 3352 34227 5415 C
@c
33606 22037 m
30910 20935 26843 19986 21451 19212 c
18392 18779 16223 18275 14958 17735 c
13690 17185 12706 16364 12026 15309 c
11346 14254 10994 13069 10994 11780 c
10994 9799 11745 8134 13245 6822 c
14747 5497 16950 4829 19834 4829 c
22694 4829 25260 5462 27487 6705 c
29714 7959 31367 9682 32410 11862 c
33207 13538 33606 16024 33606 19306 c
33606 22037 L
@c
F
T
@rax 270.42094 268.60054 279.91361 282.00784 @E
[0.00021766 0.00000000 0.00000000 0.00021766 270.42081867 268.81837052] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 84666.00000 z
%CHAR: 0 0 (b) @t
12448 0 m
5532 0 L
5532 60601 L
12975 60601 L
12975 38974 L
16118 42914 20127 44895 25003 44895 c
27698 44895 30265 44344 32668 43265 c
35083 42174 37075 40639 38623 38669 c
40182 36700 41412 34321 42280 31543 c
43160 28753 43605 25776 43605 22611 c
43605 15086 41740 9271 38025 5169 c
34309 1067 29843 -996 24639 -996 c
19458 -996 15379 1172 12436 5497 C
12448 0 L
@c
12366 22283 m
12366 17020 13069 13210 14500 10866 c
16845 7044 20021 5122 24018 5122 c
27265 5122 30078 6540 32446 9354 c
34813 12178 35997 16399 35997 21990 c
35997 27710 34860 31953 32586 34673 c
30312 37404 27558 38775 24346 38775 c
21099 38775 18286 37357 15919 34544 c
13550 31719 12354 27616 12354 22272 C
12366 22283 L
@c
F
T
@rax 243.29140 233.52123 252.33420 243.50967 @E
[0.00021766 0.00000000 0.00000000 0.00021766 243.29134578 233.73902440] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 84666.00000 z
%CHAR: 0 0 (c) @t
34227 16083 m
41541 15122 L
40744 10080 38693 6130 35411 3282 c
32117 434 28062 -996 23268 -996 c
17267 -996 12424 973 8779 4888 c
5134 8814 3305 14454 3305 21779 c
3305 26515 4091 30676 5661 34227 c
7232 37779 9623 40451 12823 42221 c
16036 44004 19541 44895 23315 44895 c
28074 44895 31988 43687 35012 41272 c
38037 38857 39994 35434 40838 31004 C
33606 29879 L
32926 32832 31695 35059 29949 36536 c
28202 38025 26081 38775 23596 38775 c
19857 38775 16809 37427 14465 34743 c
12120 32059 10948 27804 10948 21990 c
10948 16094 12085 11803 14336 9131 c
16598 6458 19552 5122 23186 5122 c
26104 5122 28554 6025 30500 7806 c
32457 9588 33711 12354 34227 16071 c
34227 16083 L
@c
F
T
@rax 77.74583 165.48973 90.32485 179.12920 @E
[0.00021766 0.00000000 0.00000000 0.00021766 77.74592832 165.71466363] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 84666.00000 z
%CHAR: 0 0 (C) @t
49771 21252 m
57788 19212 L
56112 12635 53076 7607 48716 4149 c
44356 692 38998 -1043 32692 -1043 c
26163 -1043 20842 293 16763 2942 c
12671 5603 9553 9459 7420 14500 c
5286 19541 4208 24967 4208 30746 c
4208 37052 5415 42574 7818 47262 c
10233 51963 13667 55538 18122 57976 c
22576 60414 27476 61633 32821 61633 c
38880 61633 43992 60085 48118 57003 c
52244 53920 55139 49571 56757 43980 C
48856 42115 L
47450 46524 45410 49747 42738 51752 c
40064 53768 36700 54776 32657 54776 c
28003 54776 24100 53650 20982 51423 c
17853 49196 15649 46184 14383 42433 c
13116 38669 12483 34778 12483 30793 c
12483 25636 13233 21135 14735 17302 c
16235 13456 18568 10584 21732 8685 c
24897 6787 28343 5825 32035 5825 c
36524 5825 40334 7126 43441 9705 c
46559 12296 48669 16153 49771 21240 c
49771 21252 L
@c
F
T
@rax 121.59014 368.92828 133.93672 382.11761 @E
[0.00021766 0.00000000 0.00000000 0.00021766 121.61878102 368.92822371] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 84666.00000 z
%CHAR: 0 0 (A) @t
-141 0 m
23151 60601 L
31789 60601 L
56592 0 L
47450 0 L
40381 18345 L
15040 18345 L
8381 0 L
-141 0 L
@c
17360 24885 m
37908 24885 L
31578 41670 l
29656 46758 28214 50955 27276 54236 C
26503 50345 25413 46477 24018 42656 c
17360 24885 L
@c
F
T
@rax 419.27187 344.77682 430.58183 357.96643 @E
[0.00021766 0.00000000 0.00000000 0.00021766 419.27182886 344.77693330] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 84666.00000 z
%CHAR: 0 0 (B) @t
6201 0 m
6201 60601 L
28929 60601 l
33559 60601 37286 59980 40076 58761 c
42867 57542 45071 55643 46641 53100 c
48224 50556 49021 47884 49021 45094 c
49021 42515 48317 40064 46922 37779 c
45516 35493 43383 33641 40545 32235 C
44203 31168 47028 29328 48997 26749 c
50966 24159 51963 21088 51963 17560 c
51963 14723 51365 12085 50169 9647 c
48974 7209 47473 5321 45715 4009 c
43957 2684 41729 1676 39080 1008 c
36431 340 33161 0 29304 0 c
6201 0 L
@c
14219 35141 m
27323 35130 l
30875 35130 33430 35364 34966 35833 c
37005 36442 38541 37450 39572 38857 c
40603 40264 41131 42033 41131 44145 c
41131 46161 40650 47931 39689 49454 c
38728 50978 37333 52033 35552 52596 c
33758 53158 30676 53451 26327 53451 c
14219 53451 L
14219 35141 L
@c
14219 7150 m
29304 7150 l
31895 7150 33723 7244 34766 7431 c
36607 7759 38154 8322 39384 9084 c
40627 9858 41647 10983 42445 12460 c
43242 13936 43652 15637 43652 17560 c
43652 19822 43066 21791 41916 23455 c
40768 25120 39150 26292 37099 26960 c
35048 27640 32082 27980 28226 27980 c
14219 27980 L
14219 7150 L
@c
F
T
@rax %Note: Object
261.56608 194.14970 300.50872 234.18142 @E
0 J 0 j [2 5 ] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.21600 0.21600 0.00000 @w
300.50872 234.18142 m
276.19228 224.62866 261.56608 197.55694 287.02261 194.14970 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
290.53729 193.67943 m
283.94476 197.61279 L
284.67638 195.48085 284.40907 193.48271 283.14255 191.61836 C
290.53729 193.67943 L
f
@J
@rax %Note: Object
114.16252 248.54570 280.20444 271.78214 @E
0 J 0 j [2 5 ] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
114.16252 271.78214 m
280.20444 248.54570 L
S
%%PageTrailer
@rs
@rs
%%Trailer
@EndSysCorelDict
end
%%DocumentSuppliedResources: procset wCorel6Dict
%%EOF
bird2-2.17.5/doc/slides/obr2.eps 0000664 0000000 0000000 00000136151 15211753245 0016231 0 ustar 00root root 0000000 0000000 %!PS-Adobe-3.0 EPSF-3.0
%%BoundingBox: 38 83 565 445
%%Creator: CorelDRAW
%%Title:
%%CreationDate: Mon Jun 26 02:36:57 2000
%%DocumentProcessColors: Black
%%DocumentSuppliedResources: (atend)
%%EndComments
%%BeginProlog
/AutoFlatness true def
/AutoSteps 0 def
/CMYKMarks true def
/UseLevel2 false def
%Color profile: _DEFAULT.CCM - Generic CMYK
%%BeginResource: procset wCorel6Dict 6.0 0
% Copyright (c)1992-96 Corel Corporation
% All rights reserved. v6.0 r1.1
/wCorel6Dict 300 dict def wCorel6Dict begin/bd{bind def}bind def/ld{load def}
bd/xd{exch def}bd/_ null def/rp{{pop}repeat}bd/@cp/closepath ld/@gs/gsave ld
/@gr/grestore ld/@np/newpath ld/Tl/translate ld/$sv 0 def/@sv{/$sv save def}bd
/@rs{$sv restore}bd/spg/showpage ld/showpage{}bd currentscreen/@dsp xd/$dsp
/@dsp def/$dsa xd/$dsf xd/$sdf false def/$SDF false def/$Scra 0 def/SetScr
/setscreen ld/setscreen{pop pop pop}bd/@ss{2 index 0 eq{$dsf 3 1 roll 4 -1 roll
pop}if exch $Scra add exch load SetScr}bd/SepMode_5 where{pop}{/SepMode_5 0
def}ifelse/CurrentInkName_5 where{pop}{/CurrentInkName_5(Composite)def}ifelse
/$ink_5 where{pop}{/$ink_5 -1 def}ifelse/$c 0 def/$m 0 def/$y 0 def/$k 0 def
/$t 1 def/$n _ def/$o 0 def/$fil 0 def/$C 0 def/$M 0 def/$Y 0 def/$K 0 def/$T 1
def/$N _ def/$O 0 def/$PF false def/s1c 0 def/s1m 0 def/s1y 0 def/s1k 0 def
/s1t 0 def/s1n _ def/$bkg false def/SK 0 def/SM 0 def/SY 0 def/SC 0 def/$op
false def matrix currentmatrix/$ctm xd/$ptm matrix def/$ttm matrix def/$stm
matrix def/$fst 128 def/$pad 0 def/$rox 0 def/$roy 0 def/$fmp 50 def/$ffpnt
true def/CorelDrawReencodeVect[16#0/grave 16#5/breve 16#6/dotaccent 16#8/ring
16#A/hungarumlaut 16#B/ogonek 16#C/caron 16#D/dotlessi 16#27/quotesingle
16#60/grave 16#7C/bar
16#82/quotesinglbase/florin/quotedblbase/ellipsis/dagger/daggerdbl
16#88/circumflex/perthousand/Scaron/guilsinglleft/OE
16#91/quoteleft/quoteright/quotedblleft/quotedblright/bullet/endash/emdash
16#98/tilde/trademark/scaron/guilsinglright/oe 16#9F/Ydieresis
16#A1/exclamdown/cent/sterling/currency/yen/brokenbar/section
16#a8/dieresis/copyright/ordfeminine/guillemotleft/logicalnot/minus/registered/macron
16#b0/degree/plusminus/twosuperior/threesuperior/acute/mu/paragraph/periodcentered
16#b8/cedilla/onesuperior/ordmasculine/guillemotright/onequarter/onehalf/threequarters/questiondown
16#c0/Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE/Ccedilla
16#c8/Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex/Idieresis
16#d0/Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis/multiply
16#d8/Oslash/Ugrave/Uacute/Ucircumflex/Udieresis/Yacute/Thorn/germandbls
16#e0/agrave/aacute/acircumflex/atilde/adieresis/aring/ae/ccedilla
16#e8/egrave/eacute/ecircumflex/edieresis/igrave/iacute/icircumflex/idieresis
16#f0/eth/ntilde/ograve/oacute/ocircumflex/otilde/odieresis/divide
16#f8/oslash/ugrave/uacute/ucircumflex/udieresis/yacute/thorn/ydieresis]def
/L2?/languagelevel where{pop languagelevel 2 ge}{false}ifelse def
/@BeginSysCorelDict{systemdict/Corel30Dict known{systemdict/Corel30Dict get
exec}if}bd/@EndSysCorelDict{systemdict/Corel30Dict known{end}if}bd AutoFlatness
{/@ifl{dup currentflat exch sub 10 gt{
([Error: PathTooComplex; OffendingCommand: AnyPaintingOperator]\n)print flush
@np exit}{currentflat 2 add setflat}ifelse}bd/@fill/fill ld/fill{currentflat{
{@fill}stopped{@ifl}{exit}ifelse}bind loop setflat}bd/@eofill/eofill ld/eofill
{currentflat{{@eofill}stopped{@ifl}{exit}ifelse}bind loop setflat}bd/@clip
/clip ld/clip{currentflat{{@clip}stopped{@ifl}{exit}ifelse}bind loop setflat}
bd/@eoclip/eoclip ld/eoclip{currentflat{{@eoclip}stopped{@ifl}{exit}ifelse}
bind loop setflat}bd/@stroke/stroke ld/stroke{currentflat{{@stroke}stopped
{@ifl}{exit}ifelse}bind loop setflat}bd}if L2?{/@ssa{true setstrokeadjust}bd}{
/@ssa{}bd}ifelse/d/setdash ld/j/setlinejoin ld/J/setlinecap ld/M/setmiterlimit
ld/w/setlinewidth ld/O{/$o xd}bd/R{/$O xd}bd/W/eoclip ld/c/curveto ld/C/c ld/l
/lineto ld/L/l ld/rl/rlineto ld/m/moveto ld/n/newpath ld/N/newpath ld/P{11 rp}
bd/u{}bd/U{}bd/A{pop}bd/q/@gs ld/Q/@gr ld/&{}bd/@j{@sv @np}bd/@J{@rs}bd/g{1
exch sub/$k xd/$c 0 def/$m 0 def/$y 0 def/$t 1 def/$n _ def/$fil 0 def}bd/G{1
sub neg/$K xd _ 1 0 0 0/$C xd/$M xd/$Y xd/$T xd/$N xd}bd/k{1 index type
/stringtype eq{/$t xd/$n xd}{/$t 0 def/$n _ def}ifelse/$k xd/$y xd/$m xd/$c xd
/$fil 0 def}bd/K{1 index type/stringtype eq{/$T xd/$N xd}{/$T 0 def/$N _ def}
ifelse/$K xd/$Y xd/$M xd/$C xd}bd/x/k ld/X/K ld/sf{1 index type/stringtype eq{
/s1t xd/s1n xd}{/s1t 0 def/s1n _ def}ifelse/s1k xd/s1y xd/s1m xd/s1c xd}bd/i{
dup 0 ne{setflat}{pop}ifelse}bd/v{4 -2 roll 2 copy 6 -2 roll c}bd/V/v ld/y{2
copy c}bd/Y/y ld/@w{matrix rotate/$ptm xd matrix scale $ptm dup concatmatrix
/$ptm xd 1 eq{$ptm exch dup concatmatrix/$ptm xd}if 1 w}bd/@g{1 eq dup/$sdf xd
{/$scp xd/$sca xd/$scf xd}if}bd/@G{1 eq dup/$SDF xd{/$SCP xd/$SCA xd/$SCF xd}
if}bd/@D{2 index 0 eq{$dsf 3 1 roll 4 -1 roll pop}if 3 copy exch $Scra add exch
load SetScr/$dsp xd/$dsa xd/$dsf xd}bd/$ngx{$SDF{$SCF SepMode_5 0 eq{$SCA}
{$dsa}ifelse $SCP @ss}if}bd/p{/$pm xd 7 rp/$pyf xd/$pxf xd/$pn xd/$fil 1 def}
bd/@MN{2 copy le{pop}{exch pop}ifelse}bd/@MX{2 copy ge{pop}{exch pop}ifelse}bd
/InRange{3 -1 roll @MN @MX}bd/wDstChck{2 1 roll dup 3 -1 roll eq{1 add}if}bd
/@dot{dup mul exch dup mul add 1 exch sub}bd/@lin{exch pop abs 1 exch sub}bd
/cmyk2rgb{3{dup 5 -1 roll add 1 exch sub dup 0 lt{pop 0}if exch}repeat pop}bd
/rgb2cmyk{3{1 exch sub 3 1 roll}repeat 3 copy @MN @MN 3{dup 5 -1 roll sub neg
exch}repeat}bd/rgb2g{2 index .299 mul 2 index .587 mul add 1 index .114 mul add
4 1 roll pop pop pop}bd/WaldoColor_5 where{pop}{/SetRgb/setrgbcolor ld/GetRgb
/currentrgbcolor ld/SetGry/setgray ld/GetGry/currentgray ld/SetRgb2 systemdict
/setrgbcolor get def/GetRgb2 systemdict/currentrgbcolor get def/SetHsb
systemdict/sethsbcolor get def/GetHsb systemdict/currenthsbcolor get def
/rgb2hsb{SetRgb2 GetHsb}bd/hsb2rgb{3 -1 roll dup floor sub 3 1 roll SetHsb
GetRgb2}bd/setcmykcolor where{pop/SetCmyk_5/setcmykcolor ld}{/SetCmyk_5{
cmyk2rgb SetRgb}bd}ifelse/currentcmykcolor where{pop/GetCmyk/currentcmykcolor
ld}{/GetCmyk{GetRgb rgb2cmyk}bd}ifelse/setoverprint where{pop}{/setoverprint{
/$op xd}bd}ifelse/currentoverprint where{pop}{/currentoverprint{$op}bd}ifelse
/@tc_5{5 -1 roll dup 1 ge{pop}{4{dup 6 -1 roll mul exch}repeat pop}ifelse}bd
/@trp{exch pop 5 1 roll @tc_5}bd/setprocesscolor_5{SepMode_5 0 eq{SetCmyk_5}{0
4 $ink_5 sub index exch pop 5 1 roll pop pop pop pop SepsColor true eq{$ink_5 3
gt{1 sub neg SetGry}{0 0 0 4 $ink_5 roll SetCmyk_5}ifelse}{1 sub neg SetGry}
ifelse}ifelse}bd/findcmykcustomcolor where{pop}{/findcmykcustomcolor{5 array
astore}bd}ifelse/setcustomcolor where{pop}{/setcustomcolor{exch aload pop
SepMode_5 0 eq{pop @tc_5 setprocesscolor_5}{CurrentInkName_5 eq{4 index}{0}
ifelse 6 1 roll 5 rp 1 sub neg SetGry}ifelse}bd}ifelse/@scc_5{dup type
/booleantype eq{setoverprint}{1 eq setoverprint}ifelse dup _ eq{pop
setprocesscolor_5 pop}{findcmykcustomcolor exch setcustomcolor}ifelse SepMode_5
0 eq{true}{GetGry 1 eq currentoverprint and not}ifelse}bd/colorimage where{pop
/ColorImage{colorimage}def}{/ColorImage{/ncolors xd pop/dataaq xd{dataaq
ncolors dup 3 eq{/$dat xd 0 1 $dat length 3 div 1 sub{dup 3 mul $dat 1 index
get 255 div $dat 2 index 1 add get 255 div $dat 3 index 2 add get 255 div rgb2g
255 mul cvi exch pop $dat 3 1 roll put}for $dat 0 $dat length 3 idiv
getinterval pop}{4 eq{/$dat xd 0 1 $dat length 4 div 1 sub{dup 4 mul $dat 1
index get 255 div $dat 2 index 1 add get 255 div $dat 3 index 2 add get 255 div
$dat 4 index 3 add get 255 div cmyk2rgb rgb2g 255 mul cvi exch pop $dat 3 1
roll put}for $dat 0 $dat length ncolors idiv getinterval}if}ifelse}image}bd
}ifelse/setcmykcolor{1 5 1 roll _ currentoverprint @scc_5/$ffpnt xd}bd
/currentcmykcolor{0 0 0 0}bd/setrgbcolor{rgb2cmyk setcmykcolor}bd
/currentrgbcolor{currentcmykcolor cmyk2rgb}bd/sethsbcolor{hsb2rgb setrgbcolor}
bd/currenthsbcolor{currentrgbcolor rgb2hsb}bd/setgray{dup dup setrgbcolor}bd
/currentgray{currentrgbcolor rgb2g}bd}ifelse/WaldoColor_5 true def/@sft{$tllx
$pxf add dup $tllx gt{$pwid sub}if/$tx xd $tury $pyf sub dup $tury lt{$phei
add}if/$ty xd}bd/@stb{pathbbox/$ury xd/$urx xd/$lly xd/$llx xd}bd/@ep{{cvx exec
}forall}bd/@tp{@sv/$in true def 2 copy dup $lly le{/$in false def}if $phei sub
$ury ge{/$in false def}if dup $urx ge{/$in false def}if $pwid add $llx le{/$in
false def}if $in{@np 2 copy m $pwid 0 rl 0 $phei neg rl $pwid neg 0 rl 0 $phei
rl clip @np $pn cvlit load aload pop 7 -1 roll 5 index sub 7 -1 roll 3 index
sub Tl matrix currentmatrix/$ctm xd @ep pop pop pop pop}{pop pop}ifelse @rs}bd
/@th{@sft 0 1 $tly 1 sub{dup $psx mul $tx add{dup $llx gt{$pwid sub}{exit}
ifelse}loop exch $phei mul $ty exch sub 0 1 $tlx 1 sub{$pwid mul 3 copy 3 -1
roll add exch @tp pop}for pop pop}for}bd/@tv{@sft 0 1 $tlx 1 sub{dup $pwid mul
$tx add exch $psy mul $ty exch sub{dup $ury lt{$phei add}{exit}ifelse}loop 0 1
$tly 1 sub{$phei mul 3 copy sub @tp pop}for pop pop}for}bd/@pf{@gs $ctm
setmatrix $pm concat @stb eoclip Bburx Bbury $pm itransform/$tury xd/$turx xd
Bbllx Bblly $pm itransform/$tlly xd/$tllx xd/$wid $turx $tllx sub def/$hei
$tury $tlly sub def @gs $vectpat{1 0 0 0 0 _ $o @scc_5{eofill}if}{$t $c $m $y
$k $n $o @scc_5{SepMode_5 0 eq $pfrg or{$tllx $tlly Tl $wid $hei scale <00> 8 1
false[8 0 0 1 0 0]{}imagemask}{/$bkg true def}ifelse}if}ifelse @gr $wid 0 gt
$hei 0 gt and{$pn cvlit load aload pop/$pd xd 3 -1 roll sub/$phei xd exch sub
/$pwid xd $wid $pwid div ceiling 1 add/$tlx xd $hei $phei div ceiling 1 add
/$tly xd $psx 0 eq{@tv}{@th}ifelse}if @gr @np/$bkg false def}bd/@dlt_hsb{$fco
nff ge{/$fco nff 1 sub def}if sub neg 2 div dup $fco div/kdb xd nff $fco sub
div/kdb2 xd sub neg 2 div dup $fco div/kds xd nff $fco sub div/kds2 xd sub neg
dup 0 eq{pop $frb 2 eq{.99}{-.99}ifelse}if dup $frb 2 eq exch 0 lt and{1 add}
if dup $frb 1 eq exch 0 gt and{1 sub}if 2 div dup $fco div/kdh xd nff $fco sub
div/kdh2 xd}bd/@dlt_cmyk{$fmp 50 eq{sub neg nff dup 1 gt{1 sub}if div/$dk xd
sub neg nff dup 1 gt{1 sub}if div/$dy xd sub neg nff dup 1 gt{1 sub}if div/$dm
xd sub neg nff dup 1 gt{1 sub}if div/$dc xd sub neg nff dup 1 gt{1 sub}if div
/$dt xd}{$fco nff ge{/$fco nff 1 sub def}if sub neg 2 div dup $fco div/$dk xd
nff $fco sub div/$dk2 xd sub neg 2 div dup $fco div/$dy xd nff $fco sub div
/$dy2 xd sub neg 2 div dup $fco div/$dm xd nff $fco sub div/$dm2 xd sub neg 2
div dup $fco div/$dc xd nff $fco sub div/$dc2 xd sub neg 2 div dup $fco div
/$dt xd nff $fco sub div/$dt2 xd}ifelse}bd/@dlt{$fse $fss sub dup/nff xd $fmp
mul $fmp add 100 div round cvi dup 0 le{pop 1}if/$fco xd/$fi 0 def $frb dup 1
eq exch 2 eq or{$frt dup $frc $frm $fry $frk @tc_5 4 copy cmyk2rgb rgb2hsb 3
copy/myb xd/mys xd/myh xd $tot $toc $tom $toy $tok @tc_5 cmyk2rgb rgb2hsb 3 1
roll 4 1 roll 5 1 roll @dlt_hsb}{$frt dup $frc $frm $fry $frk @tc_5 5 copy $tot
dup $toc $tom $toy $tok @tc_5 5 1 roll 6 1 roll 7 1 roll 8 1 roll 9 1 roll
@dlt_cmyk}ifelse}bd/@ffnxt{/$fi $fi 1 add def $frb dup 1 eq exch 2 eq or{pop
pop pop pop myh mys myb $fi $fco lt{kdb add 3 1 roll kds add 3 1 roll kdh add 3
1 roll}{kdb2 add 3 1 roll kds2 add 3 1 roll kdh2 add 3 1 roll}ifelse 3 copy
/myb xd/mys xd/myh xd hsb2rgb rgb2cmyk}{$fi $fco lt $fmp 50 eq or{$dk add 5 1
roll $dy add 5 1 roll $dm add 5 1 roll $dc add 5 1 roll $dt add 5 1 roll}{$dk2
add 5 1 roll $dy2 add 5 1 roll $dm2 add 5 1 roll $dc2 add 5 1 roll $dt2 add 5 1
roll}ifelse}ifelse}bd/ffcol{5 copy $fsit 0 eq{setcmykcolor pop}{SepMode_5 0 ne
{$frn findcmykcustomcolor exch setcustomcolor}{pop pop pop pop $frc $frm $fry
$frk $frn findcmykcustomcolor exch setcustomcolor}ifelse}ifelse}bd/@ftl{1 index
4 index sub dup $pad mul dup/$pdw xd 2 mul sub $fst div/$wid xd 2 index sub
/$hei xd pop Tl @dlt $fss 0 eq{ffcol n 0 0 m 0 $hei l $pdw $hei l $pdw 0 l @cp
$ffpnt{fill}{@np}ifelse}if $fss $wid mul $pdw add 0 Tl nff{ffcol n 0 0 m 0 $hei
l $wid $hei l $wid 0 l @cp $ffpnt{fill}{@np}ifelse $wid 0 Tl @ffnxt}repeat 5 rp
$tot dup $toc $tom $toy $tok @tc_5 ffcol n 0 0 m 0 $hei l $pdw $hei l $pdw 0 l
@cp $ffpnt{fill}{@np}ifelse 5 rp}bd/@ftrs{1 index 4 index sub dup $rox mul
/$row xd 2 div 1 index 4 index sub dup $roy mul/$roh xd 2 div 2 copy dup mul
exch dup mul add sqrt $row dup mul $roh dup mul add sqrt add dup/$hei xd $fst
div/$wid xd 4 index add $roh add exch 5 index add $row add exch Tl $fan rotate
pop pop pop pop @dlt $fss 0 eq{ffcol $fty 3 eq{$hei dup neg dup m 2 mul @sqr}{
0 0 m 0 0 $hei 0 360 arc}ifelse $ffpnt{fill}{@np}ifelse}if 1.0 $pad 2 mul sub
dup scale $hei $fss $wid mul sub/$hei xd nff{ffcol $fty 3 eq{n $hei dup neg dup
m 2 mul @sqr}{n 0 0 m 0 0 $hei 0 360 arc}ifelse $ffpnt{fill}{@np}ifelse/$hei
$hei $wid sub def @ffnxt}repeat 5 rp}bd/@ftc{1 index 4 index sub dup $rox mul
/$row xd 2 div 1 index 4 index sub dup $roy mul/$roh xd 2 div 2 copy dup mul
exch dup mul add sqrt $row dup mul $roh dup mul add sqrt add dup/$hei xd $fst
div/$wid xd 4 index add $roh add exch 5 index add $row add exch Tl pop pop pop
pop @dlt $fss 0 eq{ffcol $ffpnt{fill}{@np}ifelse}{n}ifelse/$dang 180 $fst 1 sub
div def/$sang $dang -2 div 180 add def/$eang $dang 2 div 180 add def/$sang
$sang $dang $fss mul add def/$eang $eang $dang $fss mul add def/$sang $eang
$dang sub def nff{ffcol n 0 0 m 0 0 $hei $sang $fan add $eang $fan add arc
$ffpnt{fill}{@np}ifelse 0 0 m 0 0 $hei $eang neg $fan add $sang neg $fan add
arc $ffpnt{fill}{@np}ifelse/$sang $eang def/$eang $eang $dang add def @ffnxt}
repeat 5 rp}bd/@fstAdjust{72 0 matrix defaultmatrix dtransform exch dup mul
exch dup mul add sqrt currentscreen pop pop div dup mul 1 add cvi 2 256 InRange
$fsc 1 sub dup 0 le{pop 1}if mul/opt$fst xd AutoSteps dup 1 eq exch 3 eq or{
opt$fst dup dup $fst dup 3 1 roll div exch 3 -1 roll gt{/$adj xd/$fst xd}{pop
pop}ifelse}if AutoSteps dup 2 eq exch 3 eq or{opt$fst dup dup $fst dup 3 1 roll
div exch 3 -1 roll lt{/$adj xd/$fst xd}{pop pop}ifelse}if}bd/@ff{/old$fst $fst
def/$adj 1 def/$fss 0 def $o 1 eq setoverprint AutoSteps 0 gt{@fstAdjust}if 1 1
$fsc 1 sub{dup 1 sub $fsit 0 eq{$fsa exch 5 mul 5 getinterval aload pop pop
/$frk xd/$fry xd/$frm xd/$frc xd/$frn _ def/$frt 1 def $fsa exch 5 mul 5
getinterval aload pop $adj mul cvi $fss add/$fse xd/$tok xd/$toy xd/$tom xd
/$toc xd/$ton _ def/$tot 1 def}{$fsa exch 7 mul 7 getinterval aload pop pop
/$frt xd/$frn xd/$frk xd/$fry xd/$frm xd/$frc xd $fsa exch 7 mul 7 getinterval
aload pop $adj mul cvi $fss add/$fse xd/$tot xd/$ton xd/$tok xd/$toy xd/$tom xd
/$toc xd}ifelse $fsit 0 eq SepMode_5 0 eq or dup not CurrentInkName_5 $frn eq
and or{@sv $ctm setmatrix eoclip Bbllx Bblly Bburx Bbury $fty 2 eq{@ftc}{1
index 3 index m 2 copy l 3 index 1 index l 3 index 3 index l @cp $fty dup 1 eq
exch 3 eq or{@ftrs}{pop pop pop pop $fan rotate pathbbox @ftl}ifelse}ifelse @rs
/$fss $fse def}{1 0 0 0 0 _ $o @scc_5{fill}if}ifelse}for @np/$fst old$fst def}
bd/@Pf{@sv SepMode_5 0 eq $Psc 0 ne or $ink_5 3 eq or{0 J 0 j[]0 d $t $c $m $y
$k $n $o @scc_5 pop $ctm setmatrix 72 1000 div dup matrix scale dup concat dup
Bburx exch Bbury exch itransform ceiling cvi/Bbury xd ceiling cvi/Bburx xd
Bbllx exch Bblly exch itransform floor cvi/Bblly xd floor cvi/Bbllx xd $Prm
aload pop $Psn load exec}{1 SetGry eofill}ifelse @rs @np}bd/F{matrix
currentmatrix $sdf{$scf $sca $scp @ss}if $fil 1 eq{@pf}{$fil 2 eq{@ff}{$fil 3
eq{@Pf}{$t $c $m $y $k $n $o @scc_5{eofill}{@np}ifelse}ifelse}ifelse}ifelse
$sdf{$dsf $dsa $dsp @ss}if setmatrix}bd/f{@cp F}bd/S{matrix currentmatrix $ctm
setmatrix $SDF{$SCF $SCA $SCP @ss}if $T $C $M $Y $K $N $O @scc_5{matrix
currentmatrix $ptm concat stroke setmatrix}{@np}ifelse $SDF{$dsf $dsa $dsp
@ss}if setmatrix}bd/s{@cp S}bd/B{@gs F @gr S}bd/b{@cp B}bd/_E{5 array astore
exch cvlit xd}bd/@cc{currentfile $dat readhexstring pop}bd/@sm{/$ctm $ctm
currentmatrix def}bd/@E{/Bbury xd/Bburx xd/Bblly xd/Bbllx xd}bd/@c{@cp}bd/@p{
/$fil 1 def 1 eq dup/$vectpat xd{/$pfrg true def}{@gs $t $c $m $y $k $n $o
@scc_5/$pfrg xd @gr}ifelse/$pm xd/$psy xd/$psx xd/$pyf xd/$pxf xd/$pn xd}bd/@P
{/$fil 3 def/$Psn xd/$Psc xd array astore/$Prm xd}bd/@k{/$fil 2 def/$fmp xd
/$roy xd/$rox xd/$pad xd/$fty xd/$fan xd $fty 1 eq{/$fan 0 def}if/$frb xd/$fst
xd/$fsc xd/$fsa xd/$fsit 0 def}bd/@x{/$fil 2 def/$fmp xd/$roy xd/$rox xd/$pad
xd/$fty xd/$fan xd $fty 1 eq{/$fan 0 def}if/$frb xd/$fst xd/$fsc xd/$fsa xd
/$fsit 1 def}bd/@ii{concat 3 index 3 index m 3 index 1 index l 2 copy l 1 index
3 index l 3 index 3 index l clip pop pop pop pop}bd/tcc{@cc}def/@i{@sm @gs @ii
6 index 1 ne{/$frg true def pop pop}{1 eq{s1t s1c s1m s1y s1k s1n $O @scc_5
/$frg xd}{/$frg false def}ifelse 1 eq{@gs $ctm setmatrix F @gr}if}ifelse @np
/$ury xd/$urx xd/$lly xd/$llx xd/$bts xd/$hei xd/$wid xd/$dat $wid $bts mul 8
div ceiling cvi string def $bkg $frg or{$SDF{$SCF $SCA $SCP @ss}if $llx $lly Tl
$urx $llx sub $ury $lly sub scale $bkg{$t $c $m $y $k $n $o @scc_5 pop}if $wid
$hei abs $bts 1 eq{$bkg}{$bts}ifelse[$wid 0 0 $hei neg 0 $hei 0
gt{$hei}{0}ifelse]/tcc load $bts 1 eq{imagemask}{image}ifelse $SDF{$dsf $dsa
$dsp @ss}if}{$hei abs{tcc pop}repeat}ifelse @gr $ctm setmatrix}bd/@I{@sm @gs
@ii @np/$ury xd/$urx xd/$lly xd/$llx xd/$ncl xd/$bts xd/$hei xd/$wid xd/$dat
$wid $bts mul $ncl mul 8 div ceiling cvi string def $ngx $llx $lly Tl $urx $llx
sub $ury $lly sub scale $wid $hei abs $bts[$wid 0 0 $hei neg 0 $hei 0
gt{$hei}{0}ifelse]/@cc load false $ncl ColorImage $SDF{$dsf $dsa $dsp @ss}if
@gr $ctm setmatrix}bd L2?{/@I_2{@sm @gs @ii @np/$ury xd/$urx xd/$lly xd/$llx xd
/$ncl xd/$bts xd/$hei xd/$wid xd/$dat $wid $bts mul $ncl mul 8 div ceiling cvi
string def $ngx $ncl 1 eq{/DeviceGray}{$ncl 3 eq{/DeviceRGB}{/DeviceCMYK}
ifelse}ifelse setcolorspace $llx $lly Tl $urx $llx sub $ury $lly sub scale 8
dict begin/ImageType 1 def/Width $wid def/Height $hei abs def/BitsPerComponent
$bts def/Decode $ncl 1 eq{[0 1]}{$ncl 3 eq{[0 1 0 1 0 1]}{[0 1 0 1 0 1 0 1]}
ifelse}ifelse def/ImageMatrix[$wid 0 0 $hei neg 0 $hei 0 gt{$hei}{0}ifelse]def
/DataSource currentfile/ASCII85Decode filter def currentdict end image $SDF
{$dsf $dsa $dsp @ss}if @gr $ctm setmatrix}bd}{/@I_2{}bd}ifelse/z{exch findfont
exch scalefont setfont}bd/ZB{9 dict dup begin 4 1 roll/FontType 3 def
/FontMatrix xd/FontBBox xd/Encoding 256 array def 0 1 255{Encoding exch
/.notdef put}for/CharStrings 256 dict def CharStrings/.notdef{}put/Metrics 256
dict def Metrics/.notdef 3 -1 roll put/BuildChar{exch dup/$char exch/Encoding
get 3 index get def dup/Metrics get $char get aload pop setcachedevice begin
Encoding exch get CharStrings exch get end exec}def end definefont pop}bd
/ZBAddChar{findfont begin dup 4 1 roll dup 6 1 roll Encoding 3 1 roll put
CharStrings 3 1 roll put Metrics 3 1 roll put end}bd/Z{findfont dup maxlength 2
add dict exch dup{1 index/FID ne{3 index 3 1 roll put}{pop pop}ifelse}forall
pop dup dup/Encoding get 256 array copy dup/$fe xd/Encoding exch put dup
/Fontname 3 index put 3 -1 roll dup length 0 ne{0 exch{dup type 0 type eq{exch
pop}{$fe exch 2 index exch put 1 add}ifelse}forall pop}if dup 256 dict dup
/$met xd/Metrics exch put dup/FontMatrix get 0 get 1000 mul 1 exch div 3 index
length 256 eq{0 1 255{dup $fe exch get dup/.notdef eq{pop pop}{5 index 3 -1
roll get 2 index mul $met 3 1 roll put}ifelse}for}if pop definefont pop pop}bd
/@ftx{{currentpoint 3 -1 roll(0)dup 3 -1 roll 0 exch put dup @gs true charpath
$ctm setmatrix @@txt @gr @np stringwidth pop 3 -1 roll add exch m}forall}bd
/@ft{matrix currentmatrix exch $sdf{$scf $sca $scp @ss}if $fil 1 eq{/@@txt/@pf
ld @ftx}{$fil 2 eq{/@@txt/@ff ld @ftx}{$fil 3 eq{/@@txt/@Pf ld @ftx}{$t $c $m
$y $k $n $o @scc_5{show}{pop}ifelse}ifelse}ifelse}ifelse $sdf{$dsf $dsa $dsp
@ss}if setmatrix}bd/@st{matrix currentmatrix exch $SDF{$SCF $SCA $SCP @ss}if $T
$C $M $Y $K $N $O @scc_5{{currentpoint 3 -1 roll(0)dup 3 -1 roll 0 exch put dup
@gs true charpath $ctm setmatrix $ptm concat stroke @gr @np stringwidth pop 3
-1 roll add exch m}forall}{pop}ifelse $SDF{$dsf $dsa $dsp @ss}if setmatrix}bd
/@te{@ft}bd/@tr{@st}bd/@ta{dup @gs @ft @gr @st}bd/@t@a{dup @gs @st @gr @ft}bd
/@tm{@sm concat}bd/e{/t{@te}def}bd/r{/t{@tr}def}bd/o{/t{pop}def}bd/a{/t{@ta}
def}bd/@a{/t{@t@a}def}bd/t{@te}def/T{@np $ctm setmatrix/$ttm matrix def}bd/ddt
{t}def/@t{/$stm $stm currentmatrix def 3 1 roll m $ttm concat ddt $stm
setmatrix}bd/@n{/$ttm exch matrix rotate def}bd/@s{}bd/@l{}bd/@B{@gs S @gr F}
bd/@b{@cp @B}bd/@sep{CurrentInkName_5(Composite)eq{/$ink_5 -1 def}{
CurrentInkName_5(Cyan)eq{/$ink_5 0 def}{CurrentInkName_5(Magenta)eq{/$ink_5 1
def}{CurrentInkName_5(Yellow)eq{/$ink_5 2 def}{CurrentInkName_5(Black)eq
{/$ink_5 3 def}{/$ink_5 4 def}ifelse}ifelse}ifelse}ifelse}ifelse}bd/@whi{@gs
-72000 dup m -72000 72000 l 72000 dup l 72000 -72000 l @cp 1 SetGry fill @gr}
bd/@neg{[{1 exch sub}/exec cvx currenttransfer/exec cvx]cvx settransfer @whi}
bd/currentscale{1 0 dtransform matrix defaultmatrix idtransform dup mul exch
dup mul add sqrt 0 1 dtransform matrix defaultmatrix idtransform dup mul exch
dup mul add sqrt}bd/@unscale{}bd/@smc{CMYKMarks{0 exch eq{1 1 1 1 1 _ 0 @scc_5
pop}{1 0 0 0 0 _ 0 @scc_5 pop}ifelse}{SetGry}ifelse}bd/@gmc{CMYKMarks{GetCmyk
pop pop pop 1 eq{0}{1}ifelse}{GetGry}ifelse}bd/@sqr{dup 0 rl dup 0 exch rl neg
0 rl @cp}bd/corelsym{@gs @np Tl -90 rotate 7{45 rotate -.75 2 m 1.5 @sqr fill}
repeat @gr}bd/@reg_cor{@gs @np Tl -6 -6 m 12 @sqr @gs 1 @gmc sub @smc fill @gr
4{90 rotate 0 4 m 0 4 rl}repeat stroke 0 0 corelsym @gr}bd/@reg_std{@gs @np Tl
.3 w 0 0 5 0 360 arc @cp @gs 1 @gmc sub @smc fill @gr 4{90 rotate 0 0 m 0 8 rl
}repeat stroke @gr}bd/@reg_inv{@gs @np Tl .3 w 0 0 5 0 360 arc @cp @gs 1 @gmc
sub @smc fill @gr 4{90 rotate 0 0 m 0 8 rl}repeat stroke 0 0 m 0 0 5 90 180 arc
@cp 0 0 5 270 360 arc @cp fill @gr}bd/@reg_sqr{@gs @np Tl .3 w -7 -7 m 14 @sqr
fill @gs 1 @gmc sub @smc 0 0 5 0 360 arc @cp save fill restore 4{90 rotate 0 0
m 0 8 rl}repeat stroke @gr 4{90 rotate 0 0 m 0 5 rl}repeat stroke @gr}bd
/@reg_lng{@gs @np 0 eq{/$Xlen 16 def/$Ylen 8 def}{/$Xlen 8 def/$Ylen 16 def}
ifelse Tl .3 w 0 0 5 0 360 arc @cp @gs 1 @gmc sub @smc fill @gr 90 rotate 0 0 m
0 $Xlen rl 90 rotate 0 0 m 0 $Ylen rl 90 rotate 0 0 m 0 $Xlen rl 90 rotate 0 0
m 0 $Ylen rl stroke @gr}bd/@setdcol{0 $dcol eq{0 exch 1 exch sub 0 0 0 _ 0
@scc_5 pop}{1 $dcol eq{0 exch 0 exch 1 exch sub 0 0 _ 0 @scc_5 pop}{2 $dcol eq
{0 exch 0 exch 0 exch 1 exch sub 0 _ 0 @scc_5 pop}{SetGry}ifelse}ifelse}ifelse
}bd/$corelmeter[1 .95 .75 .50 .25 .05 0]def/@colormeter{@gs @np 0 @setdcol 0.3
w/Courier findfont 5 scalefont setfont/yy xd/xx xd 0 1 6{dup xx 20 sub yy m 20
@sqr @gs $corelmeter exch get dup @setdcol fill @gr stroke xx 18 sub yy 2 add m
exch dup 3 ge{1 SetGry}{0 @setdcol}ifelse 3 eq{pop}{100 mul 100 exch sub cvi 20
string cvs show}ifelse/yy yy 20 add def}for @gr}bd/@calbar{@gs Tl @gs @np 0 0 m
@gs 20 @sqr 1 1 0 0 0 _ 0 @scc_5 pop fill @gr 20 0 Tl 0 0 m @gs 20 @sqr 1 1 0 1
0 _ 0 @scc_5 pop fill @gr 20 0 Tl 0 0 m @gs 20 @sqr 1 0 0 1 0 _ 0 @scc_5 pop
fill @gr 20 0 Tl 0 0 m @gs 20 @sqr 1 0 1 1 0 _ 0 @scc_5 pop fill @gr 20 0 Tl 0
0 m @gs 20 @sqr 1 0 1 0 0 _ 0 @scc_5 pop fill @gr 20 0 Tl 0 0 m @gs 20 @sqr 1 1
1 0 0 _ 0 @scc_5 pop fill @gr 20 0 Tl 0 0 m @gs 20 @sqr 1 1 1 1 0 _ 0 @scc_5
pop fill @gr @gr @np -84 0 Tl @gs 0 0 m 20 @sqr clip 1 1 0 0 0 _ 0 @scc_5 pop
@gain @gr 20 0 Tl @gs 0 0 m 20 @sqr clip 1 0 1 0 0 _ 0 @scc_5 pop @gain @gr 20
0 Tl @gs 0 0 m 20 @sqr clip 1 0 0 1 0 _ 0 @scc_5 pop @gain @gr 20 0 Tl @gs 0 0
m 20 @sqr clip 1 0 0 0 1 _ 0 @scc_5 pop @gain @gr @gr}bd/@gain{10 10 Tl @np 0 0
m 0 10 360{0 0 15 4 -1 roll dup 5 add arc @cp}for fill}bd/@crop{@gs 10 div
/$croplen xd .3 w 0 @smc Tl rotate 0 0 m 0 $croplen neg rl stroke @gr}bd
/deflevel 0 def/@sax{/deflevel deflevel 1 add def}bd/@eax{/deflevel deflevel
dup 0 gt{1 sub}if def deflevel 0 gt{/eax load}{eax}ifelse}bd/eax{{exec}forall}
bd/@rax{deflevel 0 eq{@rs @sv}if}bd/@daq{dup type/arraytype eq{{}forall}if}bd
/@BMP{/@cc xd 12 index 1 gt UseLevel2 true eq and{7 -2 roll pop pop @I_2}{11
index 1 eq{12 -1 roll pop @i}{7 -2 roll pop pop @I}ifelse}ifelse}bd systemdict
/pdfmark known not{/pdfmark/cleartomark ld}if/@BeginEPS{$ngx 0 SetGry 0 J 0 j 1
w[]0 d 10 M false setoverprint @np/EPSDict 200 dict def EPSDict begin @sv
SepMode_5 0 ne{/colorimage{@gs/sepdict 50 dict def sepdict begin[{1 exch sub}
/exec cvx currenttransfer/exec cvx]cvx settransfer 3 eq/$rgb xd{$rgb{/daq0 xd
/daq1 xd/daq2 xd/daq_rgb load}{/daq0 xd/daq1 xd/daq2 xd/daq3 xd/daq_cmyk load}
ifelse}{/daq0 xd/daq_one load}ifelse 2 index 8 eq/8bit xd $ink_5 dup 0 lt exch
3 gt or{}{image}ifelse end @gr}bd/2cmyk{3{255 exch sub 3 1 roll}repeat 3 copy
@MN @MN 3{dup 5 -1 roll sub neg exch}repeat}bd/daq_rgb{/i 0 def/daq2 load exec
/daq1 load exec/daq0 load exec dup dup length 0 exch getinterval/$data xd{8bit
{1 index i get 3 index i get 2cmyk 4 $ink_5 neg roll pop pop pop}{pop 0}ifelse
$data i 3 -1 roll put/i i 1 add def}forall pop pop $data}bd/daq_cmyk{/daq3 load
exec/daq2 load exec/daq1 load exec/daq0 load exec 4 $ink_5 neg roll pop pop pop
}bd/daq_one{/$in 0 def/$out 0 def/daq0 load exec dup dup length $rgb{3}{4}
ifelse idiv 0 exch getinterval/$data xd $data{pop 8bit{$rgb{0 index $in 2 add
get 1 index $in 1 add get 2 index $in get 2cmyk}{0 index $in get 1 index $in 1
add get 2 index $in 2 add get 3 index $in 3 add get}ifelse 4 $ink_5 neg roll
pop pop pop}{0}ifelse $data $out 3 -1 roll put/$in $in $rgb{3}{4}ifelse add def
/$out $out 1 add def}forall pop $data}bd}if}bd/@EndEPS{@rs end}bd end
%%EndResource
%%EndProlog
%%BeginSetup
wCorel6Dict begin
@BeginSysCorelDict
2.6131 setmiterlimit
1.00 setflat
/$fst 128 def
%%EndSetup
%%Page: 1 1
%LogicalPage: 1
%%BeginPageSetup
@sv
@sm
@sv
%%EndPageSetup
@rax %Note: Object
376.90583 229.84243 512.32734 329.07657 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
394.94948 251.19383 m
398.84967 256.36677 406.62539 257.12220 412.25896 252.87477 c
417.89225 248.62706 419.30589 240.94403 415.40570 235.77080 c
411.50580 230.59757 403.72951 229.84243 398.09594 234.08986 c
392.46293 238.33701 391.04929 246.02060 394.94948 251.19383 c
@c
471.13569 236.30598 m
466.84403 241.15918 467.65474 248.92951 472.93994 253.60271 c
478.22542 258.27619 486.03657 258.12907 490.32765 253.27559 c
494.61959 248.42211 493.80888 240.65206 488.52340 235.97858 c
483.23792 231.30539 475.42706 231.45222 471.13569 236.30598 c
@c
501.95225 286.09342 m
495.60406 284.79798 489.27657 289.37962 487.86605 296.29247 c
486.45581 303.20532 490.48299 309.89934 496.83090 311.19506 c
503.17852 312.49020 509.50630 307.90828 510.91682 300.99572 c
512.32734 294.08258 508.30016 287.38857 501.95225 286.09342 c
@c
446.57121 300.99203 m
452.66457 298.79121 455.67978 291.58384 453.28309 284.94822 c
450.88583 278.31288 443.96135 274.69559 437.86800 276.89698 c
431.77465 279.09751 428.75915 286.30488 431.15641 292.94050 c
433.55310 299.57584 440.47786 303.19313 446.57121 300.99203 c
@c
396.46006 326.10983 m
402.21978 323.14252 404.28142 315.60718 401.05020 309.33581 c
397.81899 303.06387 390.48633 300.36841 384.72718 303.33572 c
378.96746 306.30302 376.90583 313.83836 380.13704 320.11030 c
383.36825 326.38167 390.70120 329.07657 396.46006 326.10983 c
@c
S
@rax %Note: Object
485.05805 257.45272 495.08362 286.43839 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
485.05805 257.45272 m
495.08362 286.43839 L
S
@rax %Note: Object
450.41386 253.97235 473.10066 279.63014 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
473.10066 253.97235 m
450.41386 279.63014 L
S
@rax %Note: Object
401.03461 293.24721 431.48098 308.93329 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
401.03461 308.93329 m
431.48098 293.24721 L
S
@rax %Note: Object
444.29074 301.80926 447.88762 335.86894 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
447.88762 335.86894 m
444.29074 301.80926 L
S
@rax %Note: Object
454.06828 289.76910 487.62624 296.61591 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
487.62624 296.61591 m
454.06828 289.76910 L
S
@rax %Note: Object
412.65269 252.79115 433.27106 280.13868 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
412.65269 252.79115 m
433.27106 280.13868 L
S
@rax %Note: Object
390.01663 255.03732 398.83918 302.13950 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
390.01663 302.13950 m
398.83918 255.03732 L
S
@rax %Note: Object
416.88510 240.94687 468.21515 242.55723 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
416.88510 240.94687 m
468.21515 242.55723 L
S
@rax %Note: Object
459.79398 310.19102 491.87537 340.78734 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
491.87537 310.19102 m
459.79398 340.78734 L
S
@rax %Note: Object
399.24028 323.47616 437.73789 341.99518 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
399.24028 323.47616 m
437.73789 341.99518 L
S
@rax %Note: Object
356.97061 91.75266 400.17175 193.59439 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
392.60494 168.00406 m
386.91865 164.89928 379.52306 167.41757 376.14217 173.60986 c
372.76129 179.80243 374.64180 187.38482 380.32809 190.48989 c
386.01468 193.59439 393.40998 191.07581 396.79087 184.88409 c
400.17175 178.69153 398.29124 171.10857 392.60494 168.00406 c
@c
361.14746 97.03644 m
356.97061 101.98942 357.96387 109.73820 363.35764 114.28639 c
368.75140 118.83430 376.55660 118.50378 380.73288 113.55052 c
384.90945 108.59754 383.91619 100.84847 378.52243 96.30085 c
373.12866 91.75266 365.32318 92.08318 361.14746 97.03644 c
@c
S
@rax %Note: Object
345.75704 157.43594 375.81789 173.84854 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
375.81789 173.84854 m
345.75704 157.43594 L
S
@rax %Note: Object
341.44894 114.65178 363.52658 140.83540 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
363.52658 114.65178 m
341.44894 140.83540 L
S
@rax %Note: Object
120.82932 137.80828 462.92258 372.19436 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.21600 0.21600 0.00000 @w
146.89304 284.49354 m
149.49524 278.56035 146.34822 271.40995 139.88693 268.57616 c
133.42592 265.74265 126.03373 268.27058 123.43153 274.20378 c
120.82932 280.13669 123.97663 287.28709 130.43764 290.12088 c
136.89893 292.95468 144.29083 290.42674 146.89304 284.49354 c
@c
184.86085 321.68268 m
187.46306 315.74948 184.31575 308.59909 177.85474 305.76529 c
171.39373 302.93178 164.00154 305.45972 161.39934 311.39291 c
158.79713 317.32583 161.94444 324.47622 168.40545 327.31002 c
174.86674 330.14381 182.25865 327.61587 184.86085 321.68268 c
@c
347.25600 363.73323 m
349.85820 357.80003 346.71090 350.64964 340.24961 347.81584 c
333.78860 344.98205 326.39669 347.50998 323.79449 353.44318 c
321.19200 359.37638 324.33959 366.52677 330.80060 369.36057 c
337.26161 372.19436 344.65351 369.66643 347.25600 363.73323 c
@c
324.07569 158.43997 m
327.57676 163.89128 335.27367 165.22838 341.21027 161.41578 c
347.14658 157.60318 349.13310 150.04772 345.63203 144.59641 c
342.13096 139.14482 334.43376 137.80828 328.49745 141.62060 c
322.56113 145.43291 320.57461 152.98866 324.07569 158.43997 c
@c
462.24227 346.35260 m
461.56195 339.90973 455.28463 335.25921 448.26831 336.00019 c
441.25228 336.74088 436.08472 342.60038 436.76532 349.04324 c
437.44564 355.48611 443.72296 360.13663 450.73899 359.39565 c
457.75531 358.65468 462.92258 352.79546 462.24227 346.35260 c
@c
B
@rax %Note: Object
74.70142 309.85909 142.37150 375.25380 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
100.76542 328.61027 m
103.36734 322.67679 100.22031 315.52639 93.75931 312.69288 c
87.29830 309.85909 79.90583 312.38674 77.30391 318.31994 c
74.70142 324.25313 77.84901 331.40353 84.31002 334.23732 c
90.77102 337.07112 98.16321 334.54318 100.76542 328.61027 c
@c
139.76957 366.79238 m
142.37150 360.85946 139.22447 353.70907 132.76318 350.87556 c
126.30217 348.04148 118.90998 350.56942 116.30778 356.50261 c
113.70557 362.43609 116.85288 369.58620 123.31389 372.42000 c
129.77490 375.25380 137.16709 372.72614 139.76957 366.79238 c
@c
S
@rax %Note: Object
97.27398 333.21855 117.72567 353.34794 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
97.27398 333.21855 m
117.72567 353.34794 L
S
@rax %Note: Object
135.69902 322.64532 164.71729 353.44658 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
135.69902 353.44658 m
164.71729 322.64532 L
S
@rax %Note: Object
143.76217 287.34208 164.27339 307.12224 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
164.27339 307.12224 m
143.76217 287.34208 L
S
@rax %Note: Object
94.68567 282.22469 124.32416 313.83156 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 2.01600 2.01600 0.00000 @w
124.32416 282.22469 m
94.68567 313.83156 L
S
@rax %Note: Object
225.42888 175.73641 254.09480 202.94844 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.21600 0.21600 0.00000 @w
251.49260 194.48731 m
254.09480 188.55411 250.94750 181.40372 244.48649 178.57020 c
238.02548 175.73641 230.63329 178.26435 228.03109 184.19726 c
225.42888 190.13046 228.57619 197.28085 235.03720 200.11465 c
241.49849 202.94844 248.89039 200.42050 251.49260 194.48731 c
@c
B
@rax %Note: Object
145.13641 280.15824 168.97578 307.33483 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 7.20000 7.20000 0.00000 @w
168.18094 307.33483 m
168.97578 288.41811 161.29417 280.15824 145.13641 282.55635 C
S
@rax %Note: Object
184.13433 320.73874 327.42255 355.52183 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 7.20000 7.20000 0.00000 @w
184.13433 320.73874 m
327.42255 355.52183 L
S
@rax %Note: Object
142.54923 193.37839 229.16920 273.16261 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 7.20000 7.20000 0.00000 @w
229.16920 193.37839 m
142.54923 273.16261 L
S
@rax %Note: Object
245.88935 193.72450 332.21083 349.59231 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 7.20000 7.20000 0.00000 @w
332.21083 349.59231 m
245.88935 193.72450 L
S
@rax %Note: Object
248.37732 155.51858 327.31002 183.05546 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 7.20000 7.20000 0.00000 @w
248.37732 183.05546 m
327.31002 155.51858 L
S
@rax %Note: Object
345.32419 348.85219 441.55786 358.37291 @E
0 O 0 @g
0.00 0.00 0.00 1.00 k
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 7.20000 7.20000 0.00000 @w
345.32419 358.37291 m
441.55786 348.85219 L
S
@rax %Note: Object
41.17096 247.83364 217.89666 389.56791 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 3.67200 3.67200 0.00000 @w
129.53395 389.56791 m
178.20227 389.56791 217.89666 357.73285 217.89666 318.70091 c
217.89666 279.66869 178.20227 247.83364 129.53395 247.83364 c
80.86535 247.83364 41.17096 279.66869 41.17096 318.70091 c
41.17096 357.73285 80.86535 389.56791 129.53395 389.56791 c
@c
S
@rax %Note: Object
274.17231 204.22346 562.46202 416.32866 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 3.67200 3.67200 0.00000 @w
418.31717 416.32866 m
497.70964 416.32866 562.46202 368.68791 562.46202 310.27606 c
562.46202 251.86422 497.70964 204.22346 418.31717 204.22346 c
338.92498 204.22346 274.17231 251.86422 274.17231 310.27606 c
274.17231 368.68791 338.92498 416.32866 418.31717 416.32866 c
@c
S
@rax %Note: Object
199.13783 144.75458 275.15962 232.96649 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 3.67200 3.67200 0.00000 @w
237.14901 232.96649 m
258.08457 232.96649 275.15962 213.15345 275.15962 188.86054 c
275.15962 164.56791 258.08457 144.75458 237.14901 144.75458 c
216.21317 144.75458 199.13783 164.56791 199.13783 188.86054 c
199.13783 213.15345 216.21317 232.96649 237.14901 232.96649 c
@c
S
@rax %Note: Object
299.84202 86.27698 442.01225 203.23219 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 3.67200 3.67200 0.00000 @w
370.92728 203.23219 m
410.07940 203.23219 442.01225 176.96296 442.01225 144.75458 c
442.01225 112.54620 410.07940 86.27698 370.92728 86.27698 c
331.77487 86.27698 299.84202 112.54620 299.84202 144.75458 c
299.84202 176.96296 331.77487 203.23219 370.92728 203.23219 c
@c
S
@rax 163.36998 398.81480 204.38646 416.58746 @E
[0.00010238 0.00000000 0.00000000 0.00010238 163.40693983 399.10958467] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 234532.00000 z
%CHAR: 0 0 (A) @t
-365 0 m
64116 167857 L
88056 167857 L
156771 0 L
131460 0 L
111873 50836 L
41669 50836 L
23239 0 L
-365 0 L
@c
48095 68928 m
104990 68928 L
87477 115407 l
82147 129542 78157 141146 75568 150222 C
73436 139471 70421 128780 66522 118181 c
48095 68928 L
@c
F
%CHAR: 156450 0 (S) @t
166988 53943 m
187913 55771 L
188887 47364 191233 40450 194827 35087 c
198454 29727 204119 25341 211733 22051 c
219348 18731 227967 17056 237500 17056 c
245968 17056 253491 18335 259948 20833 c
266435 23330 271278 26803 274448 31189 c
277616 35574 279200 40390 279200 45567 c
279200 50806 277677 55436 274631 59365 c
271582 63294 266496 66613 259491 69263 c
254983 71030 245023 73771 229612 77456 c
214200 81142 203388 84644 197205 87934 c
189192 92137 183192 97345 179293 103559 c
175364 109772 173384 116777 173384 124455 c
173384 132922 175791 140872 180603 148212 c
185415 155583 192451 161187 201682 164994 c
210911 168801 221206 170720 232475 170720 c
244902 170720 255897 168710 265399 164720 c
274905 160730 282215 154821 287332 147055 c
292449 139258 295220 130425 295586 120587 C
274265 118973 L
273136 129572 269237 137613 262658 143004 c
256049 148425 246272 151136 233389 151136 c
219957 151136 210149 148669 204027 143765 c
197875 138831 194796 132892 194796 125948 c
194796 119917 196992 114950 201317 111051 c
205581 107183 216789 103193 234820 99112 c
252851 95030 265278 91436 271978 88391 c
281728 83883 288976 78157 293606 71273 c
298266 64390 300611 56410 300611 47395 c
300611 38468 298053 30031 292936 22143 c
287819 14254 280479 8102 270912 3716 c
261349 -670 250536 -2863 238536 -2863 c
223368 -2863 210606 -640 200373 3777 c
190106 8193 182034 14863 176187 23757 c
170339 32651 167262 42704 166958 53913 C
166988 53943 L
@c
F
%CHAR: 312900 0 (1) @t
400286 0 m
379635 0 L
379635 131339 L
374701 126618 368183 121866 360142 117143 c
352102 112422 344820 108858 338423 106482 C
338423 126404 L
349936 131826 360051 138405 368640 146111 c
377260 153816 383382 161309 386976 168558 C
400255 168558 L
400286 0 L
@c
F
T
@rax 473.57546 426.65244 517.60828 444.37720 @E
[0.00010238 0.00000000 0.00000000 0.00010238 473.61228790 426.94733572] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 233884.00000 z
%CHAR: 0 0 (A) @t
-365 0 m
63930 167395 L
87809 167395 L
156339 0 L
131089 0 L
111566 50681 L
41544 50681 L
23178 0 L
-365 0 L
@c
47971 68743 m
104713 68743 L
87230 115099 l
81931 129171 77941 140775 75352 149821 C
73220 139100 70205 128409 66337 117840 c
47971 68743 L
@c
F
%CHAR: 156000 0 (S) @t
166508 53788 m
187402 55616 L
188376 47240 190691 40356 194285 34996 c
197910 29635 203544 25249 211128 21960 c
218743 18670 227332 16995 236834 16995 c
245271 16995 252764 18275 259221 20772 c
265678 23270 270520 26742 273658 31097 c
276825 35483 278409 40265 278409 45443 c
278409 50681 276886 55311 273840 59210 c
270795 63108 265769 66428 258764 69078 c
254287 70814 244327 73555 228976 77240 c
213595 80926 202783 84428 196630 87687 c
188651 91860 182681 97068 178782 103282 c
174853 109495 172873 116439 172873 124115 c
172873 132551 175280 140470 180061 147811 c
184874 155151 191879 160755 201077 164532 c
210275 168339 220540 170258 231809 170258 c
244205 170258 255170 168248 264642 164258 c
274114 160268 281424 154359 286511 146623 c
291597 138856 294369 130054 294734 120246 C
273505 118632 L
272378 129201 268510 137211 261931 142602 c
255353 148024 245576 150735 232723 150735 c
219321 150735 209544 148267 203453 143364 c
197331 138460 194255 132521 194255 125607 c
194255 119607 196417 114642 200742 110774 c
205006 106876 216154 102886 234154 98835 c
252155 94754 264520 91190 271221 88144 c
280967 83667 288155 77971 292785 71088 c
297414 64205 299760 56225 299760 47270 c
299760 38377 297201 29940 292115 22082 c
287028 14224 279688 8071 270155 3716 c
260591 -670 249809 -2863 237870 -2863 c
222733 -2863 210032 -640 199798 3746 c
189564 8163 181493 14833 175676 23666 c
169858 32529 166782 42580 166477 53788 C
166508 53788 L
@c
F
%CHAR: 312000 0 (2) @t
429749 19767 m
429719 0 L
319066 0 L
318914 4934 319706 9686 321472 14254 c
324274 21777 328782 29209 334995 36519 c
341209 43828 350194 52296 361889 61890 c
380073 76814 392378 88632 398774 97342 c
405170 106053 408368 114307 408368 122074 c
408368 130206 405444 137090 399626 142663 c
393809 148267 386195 151070 376844 151070 c
366976 151070 359026 148085 353118 142176 c
347178 136237 344133 127983 344072 117505 C
322934 119668 L
324396 135414 329848 147445 339290 155699 c
348732 163953 361402 168095 377301 168095 c
393352 168095 406083 163618 415434 154724 c
424815 145831 429505 134775 429505 121617 c
429505 114916 428135 108307 425394 101850 c
422652 95393 418084 88540 411749 81413 c
405413 74256 394814 64418 380042 51961 c
367737 41605 359788 34569 356316 30884 c
352813 27199 349889 23452 347605 19737 C
429749 19767 L
@c
F
T
@rax 152.16265 141.66057 196.49282 159.44570 @E
[0.00010238 0.00000000 0.00000000 0.00010238 152.19946733 141.96769757] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 234532.00000 z
%CHAR: 0 0 (A) @t
-365 0 m
64116 167857 L
88056 167857 L
156771 0 L
131460 0 L
111873 50836 L
41669 50836 L
23239 0 L
-365 0 L
@c
48095 68928 m
104990 68928 L
87477 115407 l
82147 129542 78157 141146 75568 150222 C
73436 139471 70421 128780 66522 118181 c
48095 68928 L
@c
F
%CHAR: 156450 0 (S) @t
166988 53943 m
187913 55771 L
188887 47364 191233 40450 194827 35087 c
198454 29727 204119 25341 211733 22051 c
219348 18731 227967 17056 237500 17056 c
245968 17056 253491 18335 259948 20833 c
266435 23330 271278 26803 274448 31189 c
277616 35574 279200 40390 279200 45567 c
279200 50806 277677 55436 274631 59365 c
271582 63294 266496 66613 259491 69263 c
254983 71030 245023 73771 229612 77456 c
214200 81142 203388 84644 197205 87934 c
189192 92137 183192 97345 179293 103559 c
175364 109772 173384 116777 173384 124455 c
173384 132922 175791 140872 180603 148212 c
185415 155583 192451 161187 201682 164994 c
210911 168801 221206 170720 232475 170720 c
244902 170720 255897 168710 265399 164720 c
274905 160730 282215 154821 287332 147055 c
292449 139258 295220 130425 295586 120587 C
274265 118973 L
273136 129572 269237 137613 262658 143004 c
256049 148425 246272 151136 233389 151136 c
219957 151136 210149 148669 204027 143765 c
197875 138831 194796 132892 194796 125948 c
194796 119917 196992 114950 201317 111051 c
205581 107183 216789 103193 234820 99112 c
252851 95030 265278 91436 271978 88391 c
281728 83883 288976 78157 293606 71273 c
298266 64390 300611 56410 300611 47395 c
300611 38468 298053 30031 292936 22143 c
287819 14254 280479 8102 270912 3716 c
261349 -670 250536 -2863 238536 -2863 c
223368 -2863 210606 -640 200373 3777 c
190106 8193 182034 14863 176187 23757 c
170339 32651 167262 42704 166958 53913 C
166988 53943 L
@c
F
%CHAR: 312900 0 (3) @t
322738 44319 m
343358 47060 L
345703 35392 349754 26955 355422 21808 c
361087 16660 368061 14071 376224 14071 c
385910 14071 394103 17452 400773 24153 c
407443 30854 410793 39202 410793 49100 c
410793 58573 407687 66400 401534 72522 c
395351 78675 387463 81751 377930 81751 c
374031 81751 369188 80989 363401 79467 C
365686 97558 L
367026 97406 368153 97315 369006 97315 c
377777 97315 385696 99599 392702 104168 c
399707 108736 403240 115833 403240 125369 c
403240 132922 400681 139227 395565 144161 c
390448 149095 383838 151593 375767 151593 c
367757 151593 361056 149065 355726 144039 c
350363 139014 346921 131430 345398 121379 C
324809 125034 L
327306 138862 333063 149583 341957 157167 c
350881 164751 362031 168558 375310 168558 c
384448 168558 392915 166578 400590 162679 c
408296 158750 414205 153359 418286 146567 c
422367 139775 424438 132526 424438 124912 c
424438 117663 422489 111051 418591 105112 c
414692 99173 408905 94421 401291 90919 C
411220 88634 418926 83852 424408 76664 c
429890 69446 432665 60400 432665 49557 c
432665 34935 427301 22478 416641 12305 c
405951 2132 392427 -2985 376102 -2985 c
361361 -2985 349114 1401 339398 10173 c
329682 18945 324108 30366 322738 44319 C
@c
F
T
@rax 452.24504 153.16923 496.50775 170.94217 @E
[0.00010238 0.00000000 0.00000000 0.00010238 452.28183306 153.46419486] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 234532.00000 z
%CHAR: 0 0 (A) @t
-365 0 m
64116 167857 L
88056 167857 L
156771 0 L
131460 0 L
111873 50836 L
41669 50836 L
23239 0 L
-365 0 L
@c
48095 68928 m
104990 68928 L
87477 115407 l
82147 129542 78157 141146 75568 150222 C
73436 139471 70421 128780 66522 118181 c
48095 68928 L
@c
F
%CHAR: 156450 0 (S) @t
166988 53943 m
187913 55771 L
188887 47364 191233 40450 194827 35087 c
198454 29727 204119 25341 211733 22051 c
219348 18731 227967 17056 237500 17056 c
245968 17056 253491 18335 259948 20833 c
266435 23330 271278 26803 274448 31189 c
277616 35574 279200 40390 279200 45567 c
279200 50806 277677 55436 274631 59365 c
271582 63294 266496 66613 259491 69263 c
254983 71030 245023 73771 229612 77456 c
214200 81142 203388 84644 197205 87934 c
189192 92137 183192 97345 179293 103559 c
175364 109772 173384 116777 173384 124455 c
173384 132922 175791 140872 180603 148212 c
185415 155583 192451 161187 201682 164994 c
210911 168801 221206 170720 232475 170720 c
244902 170720 255897 168710 265399 164720 c
274905 160730 282215 154821 287332 147055 c
292449 139258 295220 130425 295586 120587 C
274265 118973 L
273136 129572 269237 137613 262658 143004 c
256049 148425 246272 151136 233389 151136 c
219957 151136 210149 148669 204027 143765 c
197875 138831 194796 132892 194796 125948 c
194796 119917 196992 114950 201317 111051 c
205581 107183 216789 103193 234820 99112 c
252851 95030 265278 91436 271978 88391 c
281728 83883 288976 78157 293606 71273 c
298266 64390 300611 56410 300611 47395 c
300611 38468 298053 30031 292936 22143 c
287819 14254 280479 8102 270912 3716 c
261349 -670 250536 -2863 238536 -2863 c
223368 -2863 210606 -640 200373 3777 c
190106 8193 182034 14863 176187 23757 c
170339 32651 167262 42704 166958 53913 C
166988 53943 L
@c
F
%CHAR: 312900 0 (4) @t
388712 0 m
388681 40176 L
315854 40176 L
315854 59090 L
392488 167857 L
409301 167857 L
409301 59090 L
431995 59090 L
431995 40176 L
409301 40176 L
409301 0 L
388712 0 L
@c
388712 59090 m
388681 134780 L
336139 59090 L
388712 59090 L
@c
F
T
%%PageTrailer
@rs
@rs
%%Trailer
@EndSysCorelDict
end
%%DocumentSuppliedResources: procset wCorel6Dict
%%EOF
bird2-2.17.5/doc/slides/obr5.eps 0000664 0000000 0000000 00000266730 15211753245 0016243 0 ustar 00root root 0000000 0000000 %!PS-Adobe-3.0 EPSF-3.0
%%BoundingBox: 12 86 583 414
%%Creator: CorelDRAW
%%Title:
%%CreationDate: Mon Jun 26 15:00:02 2000
%%DocumentProcessColors: Black
%%DocumentSuppliedResources: (atend)
%%EndComments
%%BeginProlog
/AutoFlatness true def
/AutoSteps 0 def
/CMYKMarks true def
/UseLevel2 false def
%Color profile: Disabled
%%BeginResource: procset wCorel6Dict 6.0 0
% Copyright (c)1992-96 Corel Corporation
% All rights reserved. v6.0 r1.1
/wCorel6Dict 300 dict def wCorel6Dict begin/bd{bind def}bind def/ld{load def}
bd/xd{exch def}bd/_ null def/rp{{pop}repeat}bd/@cp/closepath ld/@gs/gsave ld
/@gr/grestore ld/@np/newpath ld/Tl/translate ld/$sv 0 def/@sv{/$sv save def}bd
/@rs{$sv restore}bd/spg/showpage ld/showpage{}bd currentscreen/@dsp xd/$dsp
/@dsp def/$dsa xd/$dsf xd/$sdf false def/$SDF false def/$Scra 0 def/SetScr
/setscreen ld/setscreen{pop pop pop}bd/@ss{2 index 0 eq{$dsf 3 1 roll 4 -1 roll
pop}if exch $Scra add exch load SetScr}bd/SepMode_5 where{pop}{/SepMode_5 0
def}ifelse/CurrentInkName_5 where{pop}{/CurrentInkName_5(Composite)def}ifelse
/$ink_5 where{pop}{/$ink_5 -1 def}ifelse/$c 0 def/$m 0 def/$y 0 def/$k 0 def
/$t 1 def/$n _ def/$o 0 def/$fil 0 def/$C 0 def/$M 0 def/$Y 0 def/$K 0 def/$T 1
def/$N _ def/$O 0 def/$PF false def/s1c 0 def/s1m 0 def/s1y 0 def/s1k 0 def
/s1t 0 def/s1n _ def/$bkg false def/SK 0 def/SM 0 def/SY 0 def/SC 0 def/$op
false def matrix currentmatrix/$ctm xd/$ptm matrix def/$ttm matrix def/$stm
matrix def/$fst 128 def/$pad 0 def/$rox 0 def/$roy 0 def/$fmp 50 def/$ffpnt
true def/CorelDrawReencodeVect[16#0/grave 16#5/breve 16#6/dotaccent 16#8/ring
16#A/hungarumlaut 16#B/ogonek 16#C/caron 16#D/dotlessi 16#27/quotesingle
16#60/grave 16#7C/bar
16#82/quotesinglbase/florin/quotedblbase/ellipsis/dagger/daggerdbl
16#88/circumflex/perthousand/Scaron/guilsinglleft/OE
16#91/quoteleft/quoteright/quotedblleft/quotedblright/bullet/endash/emdash
16#98/tilde/trademark/scaron/guilsinglright/oe 16#9F/Ydieresis
16#A1/exclamdown/cent/sterling/currency/yen/brokenbar/section
16#a8/dieresis/copyright/ordfeminine/guillemotleft/logicalnot/minus/registered/macron
16#b0/degree/plusminus/twosuperior/threesuperior/acute/mu/paragraph/periodcentered
16#b8/cedilla/onesuperior/ordmasculine/guillemotright/onequarter/onehalf/threequarters/questiondown
16#c0/Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE/Ccedilla
16#c8/Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex/Idieresis
16#d0/Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis/multiply
16#d8/Oslash/Ugrave/Uacute/Ucircumflex/Udieresis/Yacute/Thorn/germandbls
16#e0/agrave/aacute/acircumflex/atilde/adieresis/aring/ae/ccedilla
16#e8/egrave/eacute/ecircumflex/edieresis/igrave/iacute/icircumflex/idieresis
16#f0/eth/ntilde/ograve/oacute/ocircumflex/otilde/odieresis/divide
16#f8/oslash/ugrave/uacute/ucircumflex/udieresis/yacute/thorn/ydieresis]def
/L2?/languagelevel where{pop languagelevel 2 ge}{false}ifelse def
/@BeginSysCorelDict{systemdict/Corel30Dict known{systemdict/Corel30Dict get
exec}if}bd/@EndSysCorelDict{systemdict/Corel30Dict known{end}if}bd AutoFlatness
{/@ifl{dup currentflat exch sub 10 gt{
([Error: PathTooComplex; OffendingCommand: AnyPaintingOperator]\n)print flush
@np exit}{currentflat 2 add setflat}ifelse}bd/@fill/fill ld/fill{currentflat{
{@fill}stopped{@ifl}{exit}ifelse}bind loop setflat}bd/@eofill/eofill ld/eofill
{currentflat{{@eofill}stopped{@ifl}{exit}ifelse}bind loop setflat}bd/@clip
/clip ld/clip{currentflat{{@clip}stopped{@ifl}{exit}ifelse}bind loop setflat}
bd/@eoclip/eoclip ld/eoclip{currentflat{{@eoclip}stopped{@ifl}{exit}ifelse}
bind loop setflat}bd/@stroke/stroke ld/stroke{currentflat{{@stroke}stopped
{@ifl}{exit}ifelse}bind loop setflat}bd}if L2?{/@ssa{true setstrokeadjust}bd}{
/@ssa{}bd}ifelse/d/setdash ld/j/setlinejoin ld/J/setlinecap ld/M/setmiterlimit
ld/w/setlinewidth ld/O{/$o xd}bd/R{/$O xd}bd/W/eoclip ld/c/curveto ld/C/c ld/l
/lineto ld/L/l ld/rl/rlineto ld/m/moveto ld/n/newpath ld/N/newpath ld/P{11 rp}
bd/u{}bd/U{}bd/A{pop}bd/q/@gs ld/Q/@gr ld/&{}bd/@j{@sv @np}bd/@J{@rs}bd/g{1
exch sub/$k xd/$c 0 def/$m 0 def/$y 0 def/$t 1 def/$n _ def/$fil 0 def}bd/G{1
sub neg/$K xd _ 1 0 0 0/$C xd/$M xd/$Y xd/$T xd/$N xd}bd/k{1 index type
/stringtype eq{/$t xd/$n xd}{/$t 0 def/$n _ def}ifelse/$k xd/$y xd/$m xd/$c xd
/$fil 0 def}bd/K{1 index type/stringtype eq{/$T xd/$N xd}{/$T 0 def/$N _ def}
ifelse/$K xd/$Y xd/$M xd/$C xd}bd/x/k ld/X/K ld/sf{1 index type/stringtype eq{
/s1t xd/s1n xd}{/s1t 0 def/s1n _ def}ifelse/s1k xd/s1y xd/s1m xd/s1c xd}bd/i{
dup 0 ne{setflat}{pop}ifelse}bd/v{4 -2 roll 2 copy 6 -2 roll c}bd/V/v ld/y{2
copy c}bd/Y/y ld/@w{matrix rotate/$ptm xd matrix scale $ptm dup concatmatrix
/$ptm xd 1 eq{$ptm exch dup concatmatrix/$ptm xd}if 1 w}bd/@g{1 eq dup/$sdf xd
{/$scp xd/$sca xd/$scf xd}if}bd/@G{1 eq dup/$SDF xd{/$SCP xd/$SCA xd/$SCF xd}
if}bd/@D{2 index 0 eq{$dsf 3 1 roll 4 -1 roll pop}if 3 copy exch $Scra add exch
load SetScr/$dsp xd/$dsa xd/$dsf xd}bd/$ngx{$SDF{$SCF SepMode_5 0 eq{$SCA}
{$dsa}ifelse $SCP @ss}if}bd/p{/$pm xd 7 rp/$pyf xd/$pxf xd/$pn xd/$fil 1 def}
bd/@MN{2 copy le{pop}{exch pop}ifelse}bd/@MX{2 copy ge{pop}{exch pop}ifelse}bd
/InRange{3 -1 roll @MN @MX}bd/wDstChck{2 1 roll dup 3 -1 roll eq{1 add}if}bd
/@dot{dup mul exch dup mul add 1 exch sub}bd/@lin{exch pop abs 1 exch sub}bd
/cmyk2rgb{3{dup 5 -1 roll add 1 exch sub dup 0 lt{pop 0}if exch}repeat pop}bd
/rgb2cmyk{3{1 exch sub 3 1 roll}repeat 3 copy @MN @MN 3{dup 5 -1 roll sub neg
exch}repeat}bd/rgb2g{2 index .299 mul 2 index .587 mul add 1 index .114 mul add
4 1 roll pop pop pop}bd/WaldoColor_5 where{pop}{/SetRgb/setrgbcolor ld/GetRgb
/currentrgbcolor ld/SetGry/setgray ld/GetGry/currentgray ld/SetRgb2 systemdict
/setrgbcolor get def/GetRgb2 systemdict/currentrgbcolor get def/SetHsb
systemdict/sethsbcolor get def/GetHsb systemdict/currenthsbcolor get def
/rgb2hsb{SetRgb2 GetHsb}bd/hsb2rgb{3 -1 roll dup floor sub 3 1 roll SetHsb
GetRgb2}bd/setcmykcolor where{pop/SetCmyk_5/setcmykcolor ld}{/SetCmyk_5{
cmyk2rgb SetRgb}bd}ifelse/currentcmykcolor where{pop/GetCmyk/currentcmykcolor
ld}{/GetCmyk{GetRgb rgb2cmyk}bd}ifelse/setoverprint where{pop}{/setoverprint{
/$op xd}bd}ifelse/currentoverprint where{pop}{/currentoverprint{$op}bd}ifelse
/@tc_5{5 -1 roll dup 1 ge{pop}{4{dup 6 -1 roll mul exch}repeat pop}ifelse}bd
/@trp{exch pop 5 1 roll @tc_5}bd/setprocesscolor_5{SepMode_5 0 eq{SetCmyk_5}{0
4 $ink_5 sub index exch pop 5 1 roll pop pop pop pop SepsColor true eq{$ink_5 3
gt{1 sub neg SetGry}{0 0 0 4 $ink_5 roll SetCmyk_5}ifelse}{1 sub neg SetGry}
ifelse}ifelse}bd/findcmykcustomcolor where{pop}{/findcmykcustomcolor{5 array
astore}bd}ifelse/setcustomcolor where{pop}{/setcustomcolor{exch aload pop
SepMode_5 0 eq{pop @tc_5 setprocesscolor_5}{CurrentInkName_5 eq{4 index}{0}
ifelse 6 1 roll 5 rp 1 sub neg SetGry}ifelse}bd}ifelse/@scc_5{dup type
/booleantype eq{setoverprint}{1 eq setoverprint}ifelse dup _ eq{pop
setprocesscolor_5 pop}{findcmykcustomcolor exch setcustomcolor}ifelse SepMode_5
0 eq{true}{GetGry 1 eq currentoverprint and not}ifelse}bd/colorimage where{pop
/ColorImage{colorimage}def}{/ColorImage{/ncolors xd pop/dataaq xd{dataaq
ncolors dup 3 eq{/$dat xd 0 1 $dat length 3 div 1 sub{dup 3 mul $dat 1 index
get 255 div $dat 2 index 1 add get 255 div $dat 3 index 2 add get 255 div rgb2g
255 mul cvi exch pop $dat 3 1 roll put}for $dat 0 $dat length 3 idiv
getinterval pop}{4 eq{/$dat xd 0 1 $dat length 4 div 1 sub{dup 4 mul $dat 1
index get 255 div $dat 2 index 1 add get 255 div $dat 3 index 2 add get 255 div
$dat 4 index 3 add get 255 div cmyk2rgb rgb2g 255 mul cvi exch pop $dat 3 1
roll put}for $dat 0 $dat length ncolors idiv getinterval}if}ifelse}image}bd
}ifelse/setcmykcolor{1 5 1 roll _ currentoverprint @scc_5/$ffpnt xd}bd
/currentcmykcolor{0 0 0 0}bd/setrgbcolor{rgb2cmyk setcmykcolor}bd
/currentrgbcolor{currentcmykcolor cmyk2rgb}bd/sethsbcolor{hsb2rgb setrgbcolor}
bd/currenthsbcolor{currentrgbcolor rgb2hsb}bd/setgray{dup dup setrgbcolor}bd
/currentgray{currentrgbcolor rgb2g}bd}ifelse/WaldoColor_5 true def/@sft{$tllx
$pxf add dup $tllx gt{$pwid sub}if/$tx xd $tury $pyf sub dup $tury lt{$phei
add}if/$ty xd}bd/@stb{pathbbox/$ury xd/$urx xd/$lly xd/$llx xd}bd/@ep{{cvx exec
}forall}bd/@tp{@sv/$in true def 2 copy dup $lly le{/$in false def}if $phei sub
$ury ge{/$in false def}if dup $urx ge{/$in false def}if $pwid add $llx le{/$in
false def}if $in{@np 2 copy m $pwid 0 rl 0 $phei neg rl $pwid neg 0 rl 0 $phei
rl clip @np $pn cvlit load aload pop 7 -1 roll 5 index sub 7 -1 roll 3 index
sub Tl matrix currentmatrix/$ctm xd @ep pop pop pop pop}{pop pop}ifelse @rs}bd
/@th{@sft 0 1 $tly 1 sub{dup $psx mul $tx add{dup $llx gt{$pwid sub}{exit}
ifelse}loop exch $phei mul $ty exch sub 0 1 $tlx 1 sub{$pwid mul 3 copy 3 -1
roll add exch @tp pop}for pop pop}for}bd/@tv{@sft 0 1 $tlx 1 sub{dup $pwid mul
$tx add exch $psy mul $ty exch sub{dup $ury lt{$phei add}{exit}ifelse}loop 0 1
$tly 1 sub{$phei mul 3 copy sub @tp pop}for pop pop}for}bd/@pf{@gs $ctm
setmatrix $pm concat @stb eoclip Bburx Bbury $pm itransform/$tury xd/$turx xd
Bbllx Bblly $pm itransform/$tlly xd/$tllx xd/$wid $turx $tllx sub def/$hei
$tury $tlly sub def @gs $vectpat{1 0 0 0 0 _ $o @scc_5{eofill}if}{$t $c $m $y
$k $n $o @scc_5{SepMode_5 0 eq $pfrg or{$tllx $tlly Tl $wid $hei scale <00> 8 1
false[8 0 0 1 0 0]{}imagemask}{/$bkg true def}ifelse}if}ifelse @gr $wid 0 gt
$hei 0 gt and{$pn cvlit load aload pop/$pd xd 3 -1 roll sub/$phei xd exch sub
/$pwid xd $wid $pwid div ceiling 1 add/$tlx xd $hei $phei div ceiling 1 add
/$tly xd $psx 0 eq{@tv}{@th}ifelse}if @gr @np/$bkg false def}bd/@dlt_hsb{$fco
nff ge{/$fco nff 1 sub def}if sub neg 2 div dup $fco div/kdb xd nff $fco sub
div/kdb2 xd sub neg 2 div dup $fco div/kds xd nff $fco sub div/kds2 xd sub neg
dup 0 eq{pop $frb 2 eq{.99}{-.99}ifelse}if dup $frb 2 eq exch 0 lt and{1 add}
if dup $frb 1 eq exch 0 gt and{1 sub}if 2 div dup $fco div/kdh xd nff $fco sub
div/kdh2 xd}bd/@dlt_cmyk{$fmp 50 eq{sub neg nff dup 1 gt{1 sub}if div/$dk xd
sub neg nff dup 1 gt{1 sub}if div/$dy xd sub neg nff dup 1 gt{1 sub}if div/$dm
xd sub neg nff dup 1 gt{1 sub}if div/$dc xd sub neg nff dup 1 gt{1 sub}if div
/$dt xd}{$fco nff ge{/$fco nff 1 sub def}if sub neg 2 div dup $fco div/$dk xd
nff $fco sub div/$dk2 xd sub neg 2 div dup $fco div/$dy xd nff $fco sub div
/$dy2 xd sub neg 2 div dup $fco div/$dm xd nff $fco sub div/$dm2 xd sub neg 2
div dup $fco div/$dc xd nff $fco sub div/$dc2 xd sub neg 2 div dup $fco div
/$dt xd nff $fco sub div/$dt2 xd}ifelse}bd/@dlt{$fse $fss sub dup/nff xd $fmp
mul $fmp add 100 div round cvi dup 0 le{pop 1}if/$fco xd/$fi 0 def $frb dup 1
eq exch 2 eq or{$frt dup $frc $frm $fry $frk @tc_5 4 copy cmyk2rgb rgb2hsb 3
copy/myb xd/mys xd/myh xd $tot $toc $tom $toy $tok @tc_5 cmyk2rgb rgb2hsb 3 1
roll 4 1 roll 5 1 roll @dlt_hsb}{$frt dup $frc $frm $fry $frk @tc_5 5 copy $tot
dup $toc $tom $toy $tok @tc_5 5 1 roll 6 1 roll 7 1 roll 8 1 roll 9 1 roll
@dlt_cmyk}ifelse}bd/@ffnxt{/$fi $fi 1 add def $frb dup 1 eq exch 2 eq or{pop
pop pop pop myh mys myb $fi $fco lt{kdb add 3 1 roll kds add 3 1 roll kdh add 3
1 roll}{kdb2 add 3 1 roll kds2 add 3 1 roll kdh2 add 3 1 roll}ifelse 3 copy
/myb xd/mys xd/myh xd hsb2rgb rgb2cmyk}{$fi $fco lt $fmp 50 eq or{$dk add 5 1
roll $dy add 5 1 roll $dm add 5 1 roll $dc add 5 1 roll $dt add 5 1 roll}{$dk2
add 5 1 roll $dy2 add 5 1 roll $dm2 add 5 1 roll $dc2 add 5 1 roll $dt2 add 5 1
roll}ifelse}ifelse}bd/ffcol{5 copy $fsit 0 eq{setcmykcolor pop}{SepMode_5 0 ne
{$frn findcmykcustomcolor exch setcustomcolor}{pop pop pop pop $frc $frm $fry
$frk $frn findcmykcustomcolor exch setcustomcolor}ifelse}ifelse}bd/@ftl{1 index
4 index sub dup $pad mul dup/$pdw xd 2 mul sub $fst div/$wid xd 2 index sub
/$hei xd pop Tl @dlt $fss 0 eq{ffcol n 0 0 m 0 $hei l $pdw $hei l $pdw 0 l @cp
$ffpnt{fill}{@np}ifelse}if $fss $wid mul $pdw add 0 Tl nff{ffcol n 0 0 m 0 $hei
l $wid $hei l $wid 0 l @cp $ffpnt{fill}{@np}ifelse $wid 0 Tl @ffnxt}repeat 5 rp
$tot dup $toc $tom $toy $tok @tc_5 ffcol n 0 0 m 0 $hei l $pdw $hei l $pdw 0 l
@cp $ffpnt{fill}{@np}ifelse 5 rp}bd/@ftrs{1 index 4 index sub dup $rox mul
/$row xd 2 div 1 index 4 index sub dup $roy mul/$roh xd 2 div 2 copy dup mul
exch dup mul add sqrt $row dup mul $roh dup mul add sqrt add dup/$hei xd $fst
div/$wid xd 4 index add $roh add exch 5 index add $row add exch Tl $fan rotate
pop pop pop pop @dlt $fss 0 eq{ffcol $fty 3 eq{$hei dup neg dup m 2 mul @sqr}{
0 0 m 0 0 $hei 0 360 arc}ifelse $ffpnt{fill}{@np}ifelse}if 1.0 $pad 2 mul sub
dup scale $hei $fss $wid mul sub/$hei xd nff{ffcol $fty 3 eq{n $hei dup neg dup
m 2 mul @sqr}{n 0 0 m 0 0 $hei 0 360 arc}ifelse $ffpnt{fill}{@np}ifelse/$hei
$hei $wid sub def @ffnxt}repeat 5 rp}bd/@ftc{1 index 4 index sub dup $rox mul
/$row xd 2 div 1 index 4 index sub dup $roy mul/$roh xd 2 div 2 copy dup mul
exch dup mul add sqrt $row dup mul $roh dup mul add sqrt add dup/$hei xd $fst
div/$wid xd 4 index add $roh add exch 5 index add $row add exch Tl pop pop pop
pop @dlt $fss 0 eq{ffcol $ffpnt{fill}{@np}ifelse}{n}ifelse/$dang 180 $fst 1 sub
div def/$sang $dang -2 div 180 add def/$eang $dang 2 div 180 add def/$sang
$sang $dang $fss mul add def/$eang $eang $dang $fss mul add def/$sang $eang
$dang sub def nff{ffcol n 0 0 m 0 0 $hei $sang $fan add $eang $fan add arc
$ffpnt{fill}{@np}ifelse 0 0 m 0 0 $hei $eang neg $fan add $sang neg $fan add
arc $ffpnt{fill}{@np}ifelse/$sang $eang def/$eang $eang $dang add def @ffnxt}
repeat 5 rp}bd/@fstAdjust{72 0 matrix defaultmatrix dtransform exch dup mul
exch dup mul add sqrt currentscreen pop pop div dup mul 1 add cvi 2 256 InRange
$fsc 1 sub dup 0 le{pop 1}if mul/opt$fst xd AutoSteps dup 1 eq exch 3 eq or{
opt$fst dup dup $fst dup 3 1 roll div exch 3 -1 roll gt{/$adj xd/$fst xd}{pop
pop}ifelse}if AutoSteps dup 2 eq exch 3 eq or{opt$fst dup dup $fst dup 3 1 roll
div exch 3 -1 roll lt{/$adj xd/$fst xd}{pop pop}ifelse}if}bd/@ff{/old$fst $fst
def/$adj 1 def/$fss 0 def $o 1 eq setoverprint AutoSteps 0 gt{@fstAdjust}if 1 1
$fsc 1 sub{dup 1 sub $fsit 0 eq{$fsa exch 5 mul 5 getinterval aload pop pop
/$frk xd/$fry xd/$frm xd/$frc xd/$frn _ def/$frt 1 def $fsa exch 5 mul 5
getinterval aload pop $adj mul cvi $fss add/$fse xd/$tok xd/$toy xd/$tom xd
/$toc xd/$ton _ def/$tot 1 def}{$fsa exch 7 mul 7 getinterval aload pop pop
/$frt xd/$frn xd/$frk xd/$fry xd/$frm xd/$frc xd $fsa exch 7 mul 7 getinterval
aload pop $adj mul cvi $fss add/$fse xd/$tot xd/$ton xd/$tok xd/$toy xd/$tom xd
/$toc xd}ifelse $fsit 0 eq SepMode_5 0 eq or dup not CurrentInkName_5 $frn eq
and or{@sv $ctm setmatrix eoclip Bbllx Bblly Bburx Bbury $fty 2 eq{@ftc}{1
index 3 index m 2 copy l 3 index 1 index l 3 index 3 index l @cp $fty dup 1 eq
exch 3 eq or{@ftrs}{pop pop pop pop $fan rotate pathbbox @ftl}ifelse}ifelse @rs
/$fss $fse def}{1 0 0 0 0 _ $o @scc_5{fill}if}ifelse}for @np/$fst old$fst def}
bd/@Pf{@sv SepMode_5 0 eq $Psc 0 ne or $ink_5 3 eq or{0 J 0 j[]0 d $t $c $m $y
$k $n $o @scc_5 pop $ctm setmatrix 72 1000 div dup matrix scale dup concat dup
Bburx exch Bbury exch itransform ceiling cvi/Bbury xd ceiling cvi/Bburx xd
Bbllx exch Bblly exch itransform floor cvi/Bblly xd floor cvi/Bbllx xd $Prm
aload pop $Psn load exec}{1 SetGry eofill}ifelse @rs @np}bd/F{matrix
currentmatrix $sdf{$scf $sca $scp @ss}if $fil 1 eq{@pf}{$fil 2 eq{@ff}{$fil 3
eq{@Pf}{$t $c $m $y $k $n $o @scc_5{eofill}{@np}ifelse}ifelse}ifelse}ifelse
$sdf{$dsf $dsa $dsp @ss}if setmatrix}bd/f{@cp F}bd/S{matrix currentmatrix $ctm
setmatrix $SDF{$SCF $SCA $SCP @ss}if $T $C $M $Y $K $N $O @scc_5{matrix
currentmatrix $ptm concat stroke setmatrix}{@np}ifelse $SDF{$dsf $dsa $dsp
@ss}if setmatrix}bd/s{@cp S}bd/B{@gs F @gr S}bd/b{@cp B}bd/_E{5 array astore
exch cvlit xd}bd/@cc{currentfile $dat readhexstring pop}bd/@sm{/$ctm $ctm
currentmatrix def}bd/@E{/Bbury xd/Bburx xd/Bblly xd/Bbllx xd}bd/@c{@cp}bd/@p{
/$fil 1 def 1 eq dup/$vectpat xd{/$pfrg true def}{@gs $t $c $m $y $k $n $o
@scc_5/$pfrg xd @gr}ifelse/$pm xd/$psy xd/$psx xd/$pyf xd/$pxf xd/$pn xd}bd/@P
{/$fil 3 def/$Psn xd/$Psc xd array astore/$Prm xd}bd/@k{/$fil 2 def/$fmp xd
/$roy xd/$rox xd/$pad xd/$fty xd/$fan xd $fty 1 eq{/$fan 0 def}if/$frb xd/$fst
xd/$fsc xd/$fsa xd/$fsit 0 def}bd/@x{/$fil 2 def/$fmp xd/$roy xd/$rox xd/$pad
xd/$fty xd/$fan xd $fty 1 eq{/$fan 0 def}if/$frb xd/$fst xd/$fsc xd/$fsa xd
/$fsit 1 def}bd/@ii{concat 3 index 3 index m 3 index 1 index l 2 copy l 1 index
3 index l 3 index 3 index l clip pop pop pop pop}bd/tcc{@cc}def/@i{@sm @gs @ii
6 index 1 ne{/$frg true def pop pop}{1 eq{s1t s1c s1m s1y s1k s1n $O @scc_5
/$frg xd}{/$frg false def}ifelse 1 eq{@gs $ctm setmatrix F @gr}if}ifelse @np
/$ury xd/$urx xd/$lly xd/$llx xd/$bts xd/$hei xd/$wid xd/$dat $wid $bts mul 8
div ceiling cvi string def $bkg $frg or{$SDF{$SCF $SCA $SCP @ss}if $llx $lly Tl
$urx $llx sub $ury $lly sub scale $bkg{$t $c $m $y $k $n $o @scc_5 pop}if $wid
$hei abs $bts 1 eq{$bkg}{$bts}ifelse[$wid 0 0 $hei neg 0 $hei 0
gt{$hei}{0}ifelse]/tcc load $bts 1 eq{imagemask}{image}ifelse $SDF{$dsf $dsa
$dsp @ss}if}{$hei abs{tcc pop}repeat}ifelse @gr $ctm setmatrix}bd/@I{@sm @gs
@ii @np/$ury xd/$urx xd/$lly xd/$llx xd/$ncl xd/$bts xd/$hei xd/$wid xd/$dat
$wid $bts mul $ncl mul 8 div ceiling cvi string def $ngx $llx $lly Tl $urx $llx
sub $ury $lly sub scale $wid $hei abs $bts[$wid 0 0 $hei neg 0 $hei 0
gt{$hei}{0}ifelse]/@cc load false $ncl ColorImage $SDF{$dsf $dsa $dsp @ss}if
@gr $ctm setmatrix}bd L2?{/@I_2{@sm @gs @ii @np/$ury xd/$urx xd/$lly xd/$llx xd
/$ncl xd/$bts xd/$hei xd/$wid xd/$dat $wid $bts mul $ncl mul 8 div ceiling cvi
string def $ngx $ncl 1 eq{/DeviceGray}{$ncl 3 eq{/DeviceRGB}{/DeviceCMYK}
ifelse}ifelse setcolorspace $llx $lly Tl $urx $llx sub $ury $lly sub scale 8
dict begin/ImageType 1 def/Width $wid def/Height $hei abs def/BitsPerComponent
$bts def/Decode $ncl 1 eq{[0 1]}{$ncl 3 eq{[0 1 0 1 0 1]}{[0 1 0 1 0 1 0 1]}
ifelse}ifelse def/ImageMatrix[$wid 0 0 $hei neg 0 $hei 0 gt{$hei}{0}ifelse]def
/DataSource currentfile/ASCII85Decode filter def currentdict end image $SDF
{$dsf $dsa $dsp @ss}if @gr $ctm setmatrix}bd}{/@I_2{}bd}ifelse/z{exch findfont
exch scalefont setfont}bd/ZB{9 dict dup begin 4 1 roll/FontType 3 def
/FontMatrix xd/FontBBox xd/Encoding 256 array def 0 1 255{Encoding exch
/.notdef put}for/CharStrings 256 dict def CharStrings/.notdef{}put/Metrics 256
dict def Metrics/.notdef 3 -1 roll put/BuildChar{exch dup/$char exch/Encoding
get 3 index get def dup/Metrics get $char get aload pop setcachedevice begin
Encoding exch get CharStrings exch get end exec}def end definefont pop}bd
/ZBAddChar{findfont begin dup 4 1 roll dup 6 1 roll Encoding 3 1 roll put
CharStrings 3 1 roll put Metrics 3 1 roll put end}bd/Z{findfont dup maxlength 2
add dict exch dup{1 index/FID ne{3 index 3 1 roll put}{pop pop}ifelse}forall
pop dup dup/Encoding get 256 array copy dup/$fe xd/Encoding exch put dup
/Fontname 3 index put 3 -1 roll dup length 0 ne{0 exch{dup type 0 type eq{exch
pop}{$fe exch 2 index exch put 1 add}ifelse}forall pop}if dup 256 dict dup
/$met xd/Metrics exch put dup/FontMatrix get 0 get 1000 mul 1 exch div 3 index
length 256 eq{0 1 255{dup $fe exch get dup/.notdef eq{pop pop}{5 index 3 -1
roll get 2 index mul $met 3 1 roll put}ifelse}for}if pop definefont pop pop}bd
/@ftx{{currentpoint 3 -1 roll(0)dup 3 -1 roll 0 exch put dup @gs true charpath
$ctm setmatrix @@txt @gr @np stringwidth pop 3 -1 roll add exch m}forall}bd
/@ft{matrix currentmatrix exch $sdf{$scf $sca $scp @ss}if $fil 1 eq{/@@txt/@pf
ld @ftx}{$fil 2 eq{/@@txt/@ff ld @ftx}{$fil 3 eq{/@@txt/@Pf ld @ftx}{$t $c $m
$y $k $n $o @scc_5{show}{pop}ifelse}ifelse}ifelse}ifelse $sdf{$dsf $dsa $dsp
@ss}if setmatrix}bd/@st{matrix currentmatrix exch $SDF{$SCF $SCA $SCP @ss}if $T
$C $M $Y $K $N $O @scc_5{{currentpoint 3 -1 roll(0)dup 3 -1 roll 0 exch put dup
@gs true charpath $ctm setmatrix $ptm concat stroke @gr @np stringwidth pop 3
-1 roll add exch m}forall}{pop}ifelse $SDF{$dsf $dsa $dsp @ss}if setmatrix}bd
/@te{@ft}bd/@tr{@st}bd/@ta{dup @gs @ft @gr @st}bd/@t@a{dup @gs @st @gr @ft}bd
/@tm{@sm concat}bd/e{/t{@te}def}bd/r{/t{@tr}def}bd/o{/t{pop}def}bd/a{/t{@ta}
def}bd/@a{/t{@t@a}def}bd/t{@te}def/T{@np $ctm setmatrix/$ttm matrix def}bd/ddt
{t}def/@t{/$stm $stm currentmatrix def 3 1 roll m $ttm concat ddt $stm
setmatrix}bd/@n{/$ttm exch matrix rotate def}bd/@s{}bd/@l{}bd/@B{@gs S @gr F}
bd/@b{@cp @B}bd/@sep{CurrentInkName_5(Composite)eq{/$ink_5 -1 def}{
CurrentInkName_5(Cyan)eq{/$ink_5 0 def}{CurrentInkName_5(Magenta)eq{/$ink_5 1
def}{CurrentInkName_5(Yellow)eq{/$ink_5 2 def}{CurrentInkName_5(Black)eq
{/$ink_5 3 def}{/$ink_5 4 def}ifelse}ifelse}ifelse}ifelse}ifelse}bd/@whi{@gs
-72000 dup m -72000 72000 l 72000 dup l 72000 -72000 l @cp 1 SetGry fill @gr}
bd/@neg{[{1 exch sub}/exec cvx currenttransfer/exec cvx]cvx settransfer @whi}
bd/currentscale{1 0 dtransform matrix defaultmatrix idtransform dup mul exch
dup mul add sqrt 0 1 dtransform matrix defaultmatrix idtransform dup mul exch
dup mul add sqrt}bd/@unscale{}bd/@smc{CMYKMarks{0 exch eq{1 1 1 1 1 _ 0 @scc_5
pop}{1 0 0 0 0 _ 0 @scc_5 pop}ifelse}{SetGry}ifelse}bd/@gmc{CMYKMarks{GetCmyk
pop pop pop 1 eq{0}{1}ifelse}{GetGry}ifelse}bd/@sqr{dup 0 rl dup 0 exch rl neg
0 rl @cp}bd/corelsym{@gs @np Tl -90 rotate 7{45 rotate -.75 2 m 1.5 @sqr fill}
repeat @gr}bd/@reg_cor{@gs @np Tl -6 -6 m 12 @sqr @gs 1 @gmc sub @smc fill @gr
4{90 rotate 0 4 m 0 4 rl}repeat stroke 0 0 corelsym @gr}bd/@reg_std{@gs @np Tl
.3 w 0 0 5 0 360 arc @cp @gs 1 @gmc sub @smc fill @gr 4{90 rotate 0 0 m 0 8 rl
}repeat stroke @gr}bd/@reg_inv{@gs @np Tl .3 w 0 0 5 0 360 arc @cp @gs 1 @gmc
sub @smc fill @gr 4{90 rotate 0 0 m 0 8 rl}repeat stroke 0 0 m 0 0 5 90 180 arc
@cp 0 0 5 270 360 arc @cp fill @gr}bd/@reg_sqr{@gs @np Tl .3 w -7 -7 m 14 @sqr
fill @gs 1 @gmc sub @smc 0 0 5 0 360 arc @cp save fill restore 4{90 rotate 0 0
m 0 8 rl}repeat stroke @gr 4{90 rotate 0 0 m 0 5 rl}repeat stroke @gr}bd
/@reg_lng{@gs @np 0 eq{/$Xlen 16 def/$Ylen 8 def}{/$Xlen 8 def/$Ylen 16 def}
ifelse Tl .3 w 0 0 5 0 360 arc @cp @gs 1 @gmc sub @smc fill @gr 90 rotate 0 0 m
0 $Xlen rl 90 rotate 0 0 m 0 $Ylen rl 90 rotate 0 0 m 0 $Xlen rl 90 rotate 0 0
m 0 $Ylen rl stroke @gr}bd/@setdcol{0 $dcol eq{0 exch 1 exch sub 0 0 0 _ 0
@scc_5 pop}{1 $dcol eq{0 exch 0 exch 1 exch sub 0 0 _ 0 @scc_5 pop}{2 $dcol eq
{0 exch 0 exch 0 exch 1 exch sub 0 _ 0 @scc_5 pop}{SetGry}ifelse}ifelse}ifelse
}bd/$corelmeter[1 .95 .75 .50 .25 .05 0]def/@colormeter{@gs @np 0 @setdcol 0.3
w/Courier findfont 5 scalefont setfont/yy xd/xx xd 0 1 6{dup xx 20 sub yy m 20
@sqr @gs $corelmeter exch get dup @setdcol fill @gr stroke xx 18 sub yy 2 add m
exch dup 3 ge{1 SetGry}{0 @setdcol}ifelse 3 eq{pop}{100 mul 100 exch sub cvi 20
string cvs show}ifelse/yy yy 20 add def}for @gr}bd/@calbar{@gs Tl @gs @np 0 0 m
@gs 20 @sqr 1 1 0 0 0 _ 0 @scc_5 pop fill @gr 20 0 Tl 0 0 m @gs 20 @sqr 1 1 0 1
0 _ 0 @scc_5 pop fill @gr 20 0 Tl 0 0 m @gs 20 @sqr 1 0 0 1 0 _ 0 @scc_5 pop
fill @gr 20 0 Tl 0 0 m @gs 20 @sqr 1 0 1 1 0 _ 0 @scc_5 pop fill @gr 20 0 Tl 0
0 m @gs 20 @sqr 1 0 1 0 0 _ 0 @scc_5 pop fill @gr 20 0 Tl 0 0 m @gs 20 @sqr 1 1
1 0 0 _ 0 @scc_5 pop fill @gr 20 0 Tl 0 0 m @gs 20 @sqr 1 1 1 1 0 _ 0 @scc_5
pop fill @gr @gr @np -84 0 Tl @gs 0 0 m 20 @sqr clip 1 1 0 0 0 _ 0 @scc_5 pop
@gain @gr 20 0 Tl @gs 0 0 m 20 @sqr clip 1 0 1 0 0 _ 0 @scc_5 pop @gain @gr 20
0 Tl @gs 0 0 m 20 @sqr clip 1 0 0 1 0 _ 0 @scc_5 pop @gain @gr 20 0 Tl @gs 0 0
m 20 @sqr clip 1 0 0 0 1 _ 0 @scc_5 pop @gain @gr @gr}bd/@gain{10 10 Tl @np 0 0
m 0 10 360{0 0 15 4 -1 roll dup 5 add arc @cp}for fill}bd/@crop{@gs 10 div
/$croplen xd .3 w 0 @smc Tl rotate 0 0 m 0 $croplen neg rl stroke @gr}bd
/deflevel 0 def/@sax{/deflevel deflevel 1 add def}bd/@eax{/deflevel deflevel
dup 0 gt{1 sub}if def deflevel 0 gt{/eax load}{eax}ifelse}bd/eax{{exec}forall}
bd/@rax{deflevel 0 eq{@rs @sv}if}bd/@daq{dup type/arraytype eq{{}forall}if}bd
/@BMP{/@cc xd 12 index 1 gt UseLevel2 true eq and{7 -2 roll pop pop @I_2}{11
index 1 eq{12 -1 roll pop @i}{7 -2 roll pop pop @I}ifelse}ifelse}bd systemdict
/pdfmark known not{/pdfmark/cleartomark ld}if/@BeginEPS{$ngx 0 SetGry 0 J 0 j 1
w[]0 d 10 M false setoverprint @np/EPSDict 200 dict def EPSDict begin @sv
SepMode_5 0 ne{/colorimage{@gs/sepdict 50 dict def sepdict begin[{1 exch sub}
/exec cvx currenttransfer/exec cvx]cvx settransfer 3 eq/$rgb xd{$rgb{/daq0 xd
/daq1 xd/daq2 xd/daq_rgb load}{/daq0 xd/daq1 xd/daq2 xd/daq3 xd/daq_cmyk load}
ifelse}{/daq0 xd/daq_one load}ifelse 2 index 8 eq/8bit xd $ink_5 dup 0 lt exch
3 gt or{}{image}ifelse end @gr}bd/2cmyk{3{255 exch sub 3 1 roll}repeat 3 copy
@MN @MN 3{dup 5 -1 roll sub neg exch}repeat}bd/daq_rgb{/i 0 def/daq2 load exec
/daq1 load exec/daq0 load exec dup dup length 0 exch getinterval/$data xd{8bit
{1 index i get 3 index i get 2cmyk 4 $ink_5 neg roll pop pop pop}{pop 0}ifelse
$data i 3 -1 roll put/i i 1 add def}forall pop pop $data}bd/daq_cmyk{/daq3 load
exec/daq2 load exec/daq1 load exec/daq0 load exec 4 $ink_5 neg roll pop pop pop
}bd/daq_one{/$in 0 def/$out 0 def/daq0 load exec dup dup length $rgb{3}{4}
ifelse idiv 0 exch getinterval/$data xd $data{pop 8bit{$rgb{0 index $in 2 add
get 1 index $in 1 add get 2 index $in get 2cmyk}{0 index $in get 1 index $in 1
add get 2 index $in 2 add get 3 index $in 3 add get}ifelse 4 $ink_5 neg roll
pop pop pop}{0}ifelse $data $out 3 -1 roll put/$in $in $rgb{3}{4}ifelse add def
/$out $out 1 add def}forall pop $data}bd}if}bd/@EndEPS{@rs end}bd end
%%EndResource
%%EndProlog
%%BeginSetup
wCorel6Dict begin
@BeginSysCorelDict
2.6131 setmiterlimit
1.00 setflat
/$fst 128 def
%%EndSetup
%%Page: 1 1
%LogicalPage: 1
%%BeginPageSetup
@sv
@sm
@sv
%%EndPageSetup
@rax %Note: Object
148.15559 236.18041 202.52778 314.02828 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
148.15559 314.02828 m
202.52778 314.02828 L
202.52778 236.18041 L
148.15559 236.18041 L
148.15559 314.02828 L
@c
S
@rax %Note: Object
127.74643 87.86835 225.97002 110.77342 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
127.74643 110.77342 m
225.97002 110.77342 L
225.97002 87.86835 L
127.74643 87.86835 L
127.74643 110.77342 L
@c
S
@rax %Note: Object
404.84353 218.57187 449.83956 283.44501 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
404.84353 283.44501 m
449.83956 283.44501 L
449.83956 218.57187 L
404.84353 218.57187 L
404.84353 283.44501 L
@c
S
@rax %Note: Object
254.33943 339.97748 318.04980 378.90142 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
286.19461 378.90142 m
303.73965 378.90142 318.04980 370.15852 318.04980 359.43931 c
318.04980 348.72009 303.73965 339.97748 286.19461 339.97748 c
268.64929 339.97748 254.33943 348.72009 254.33943 359.43931 c
254.33943 370.15852 268.64929 378.90142 286.19461 378.90142 c
@c
S
@rax %Note: Object
283.88636 227.83946 347.59672 266.76340 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
315.74154 266.76340 m
333.28658 266.76340 347.59672 258.02079 347.59672 247.30129 c
347.59672 236.58208 333.28658 227.83946 315.74154 227.83946 c
298.19622 227.83946 283.88636 236.58208 283.88636 247.30129 c
283.88636 258.02079 298.19622 266.76340 315.74154 266.76340 c
@c
S
@rax %Note: Object
363.46677 264.98721 378.50910 280.74189 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
363.46677 280.74189 m
378.50910 280.74189 L
378.50910 264.98721 L
363.46677 264.98721 L
363.46677 280.74189 L
@c
S
@rax 369.60293 270.39317 372.73408 277.68898 @E
[0.00009574 0.00000000 0.00000000 0.00009574 369.60280442 270.39307508] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 104680.00000 z
%CHAR: 0 0 (f) @t
9104 0 m
9089 47122 L
962 47122 L
962 54272 L
9089 54272 L
9089 60045 l
9089 63687 9415 66410 10066 68172 c
10940 70555 12509 72495 14729 73975 c
16965 75455 20103 76195 24115 76195 c
26708 76195 29580 75885 32703 75278 C
31327 67254 L
29432 67595 27611 67772 25906 67772 c
23123 67772 21139 67165 19984 65981 c
18830 64797 18238 62547 18238 59290 c
18238 54272 L
28825 54272 L
28825 47122 L
18238 47122 L
18238 0 L
9104 0 L
@c
F
T
@rax %Note: Object
233.27575 220.22504 248.31808 235.97943 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
233.27575 235.97943 m
248.31808 235.97943 L
248.31808 220.22504 L
233.27575 220.22504 L
233.27575 235.97943 L
@c
S
@rax 239.41162 225.63071 242.53342 232.90526 @E
[0.00009574 0.00000000 0.00000000 0.00009574 239.41169297 225.63077961] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 104370.00000 z
%CHAR: 0 0 (f) @t
9074 0 m
9060 46974 L
962 46974 L
962 54109 L
9060 54109 L
9060 59867 l
9060 63509 9385 66218 10037 67980 c
10910 70348 12464 72287 14685 73753 c
16905 75233 20044 75973 24041 75973 c
26619 75973 29491 75663 32615 75056 C
31238 67062 L
29343 67387 27522 67565 25832 67565 c
23049 67565 21080 66973 19925 65789 c
18771 64604 18178 62369 18178 59112 c
18178 54109 L
28736 54109 L
28736 46974 L
18178 46974 L
18178 0 L
9074 0 L
@c
F
T
@rax %Note: Object
245.27934 310.39852 260.32195 326.15291 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
245.27934 326.15291 m
260.32195 326.15291 L
260.32195 310.39852 L
245.27934 310.39852 L
245.27934 326.15291 L
@c
S
@rax 251.41550 315.80419 254.53729 323.07874 @E
[0.00009574 0.00000000 0.00000000 0.00009574 251.41547591 315.80427630] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 104370.00000 z
%CHAR: 0 0 (f) @t
9074 0 m
9060 46974 L
962 46974 L
962 54109 L
9060 54109 L
9060 59867 l
9060 63509 9385 66218 10037 67980 c
10910 70348 12464 72287 14685 73753 c
16905 75233 20044 75973 24041 75973 c
26619 75973 29491 75663 32615 75056 C
31238 67062 L
29343 67387 27522 67565 25832 67565 c
23049 67565 21080 66973 19925 65789 c
18771 64604 18178 62369 18178 59112 c
18178 54109 L
28736 54109 L
28736 46974 L
18178 46974 L
18178 0 L
9074 0 L
@c
F
T
@rax %Note: Object
219.42595 326.15320 234.46828 341.90787 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
219.42595 341.90787 m
234.46828 341.90787 L
234.46828 326.15320 L
219.42595 326.15320 L
219.42595 341.90787 L
@c
S
@rax 225.56211 331.55915 228.68391 338.83370 @E
[0.00009574 0.00000000 0.00000000 0.00009574 225.56196189 331.55921021] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 104370.00000 z
%CHAR: 0 0 (f) @t
9074 0 m
9060 46974 L
962 46974 L
962 54109 L
9060 54109 L
9060 59867 l
9060 63509 9385 66218 10037 67980 c
10910 70348 12464 72287 14685 73753 c
16905 75233 20044 75973 24041 75973 c
26619 75973 29491 75663 32615 75056 C
31238 67062 L
29343 67387 27522 67565 25832 67565 c
23049 67565 21080 66973 19925 65789 c
18771 64604 18178 62369 18178 59112 c
18178 54109 L
28736 54109 L
28736 46974 L
18178 46974 L
18178 0 L
9074 0 L
@c
F
T
@rax 265.98557 353.55515 307.54658 366.64101 @E
[0.00009574 0.00000000 0.00000000 0.00009574 265.98552164 353.76659884] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 187867.00000 z
%CHAR: 0 0 (s) @t
5779 29085 m
22098 31643 L
22998 25106 25580 20061 29749 16603 c
33941 13122 39815 11369 47323 11369 c
54902 11369 60539 12908 64187 15988 c
67858 19067 69706 22714 69706 26859 c
69706 30601 68071 33538 64850 35670 c
62576 37138 56939 39010 47963 41260 c
35859 44315 27451 46968 22785 49194 c
18119 51421 14566 54523 12151 58455 c
9735 62387 8527 66769 8527 71529 c
8527 75864 9521 79890 11487 83585 c
13477 87280 16201 90383 19611 92822 c
22169 94714 25698 96325 30128 97628 c
34557 98954 39318 99617 44386 99617 c
52013 99617 58739 98504 64519 96325 c
70298 94122 74561 91117 77309 87375 c
80056 83609 81975 78564 83017 72264 C
66863 70085 L
66129 75082 63998 79014 60492 81809 c
56987 84604 51989 86025 45570 86025 c
37991 86025 32567 84770 29346 82283 c
26125 79772 24491 76835 24491 73472 c
24491 71340 25177 69398 26504 67692 c
27830 65916 29962 64424 32828 63287 c
34486 62671 39365 61250 47418 59071 c
59095 55945 67266 53387 71861 51397 c
76456 49407 80104 46518 82733 42728 c
85362 38939 86688 34225 86688 28612 c
86688 23117 85077 17906 81880 13074 c
78659 8219 74016 4453 67977 1800 c
61913 -853 55045 -2203 47418 -2203 c
34770 -2203 25106 426 18474 5684 c
11843 10943 7603 18735 5779 29062 c
5779 29085 L
@c
F
%CHAR: 93936 0 (t) @t
142372 14780 m
144741 166 L
140099 -805 135930 -1303 132259 -1303 c
126290 -1303 121624 -355 118332 1540 c
115040 3434 112695 5945 111368 9024 c
110018 12103 109331 18617 109331 28517 c
109331 84556 L
97228 84556 L
97228 97414 L
109331 97414 L
109331 121526 L
125745 131450 L
125745 97414 L
142349 97414 L
142349 84556 L
125745 84556 L
125745 27593 l
125745 22904 126053 19848 126622 18522 c
127190 17195 128161 16106 129464 15324 c
130790 14519 132685 14116 135125 14116 c
136948 14116 139364 14330 142349 14756 C
142372 14780 L
@c
F
%CHAR: 143472 0 (a) @t
219431 12008 m
213320 6821 207398 3150 201761 1018 c
196124 -1113 190037 -2203 183547 -2203 c
172842 -2203 164599 426 158867 5637 c
153136 10848 150246 17551 150246 25675 c
150246 30436 151336 34817 153491 38749 c
155670 42681 158536 45878 162041 48247 c
165547 50615 169526 52439 173908 53647 c
177152 54500 182055 55329 188592 56134 c
201904 57721 211733 59639 218033 61819 C
218081 64069 218128 65513 218128 66129 c
218128 72856 216565 77593 213462 80340 c
209246 84083 202946 85954 194656 85954 c
186887 85954 181155 84580 177460 81880 c
173765 79156 170994 74324 169242 67408 C
153088 69611 L
154557 76527 156973 82117 160336 86356 c
163699 90596 168578 93888 174926 96159 c
181274 98457 188663 99617 197024 99617 c
205338 99617 212112 98622 217299 96680 c
222510 94738 226347 92254 228763 89293 c
231202 86333 232931 82567 233902 78043 c
234447 75248 234731 70156 234731 62837 c
234731 40810 l
234731 25462 235087 15751 235773 11701 c
236484 7627 237878 3719 239963 0 C
222723 0 L
221018 3411 219881 7413 219407 12008 C
219431 12008 L
@c
218057 48886 m
212064 46447 203064 44339 191079 42633 c
184305 41686 179474 40573 176679 39365 c
173860 38133 171681 36333 170165 33988 c
168649 31620 167868 28991 167868 26125 c
167868 21719 169549 18048 172865 15135 c
176181 12198 181084 10729 187503 10729 c
193851 10729 199511 12127 204462 14898 c
209412 17669 213059 21483 215380 26314 c
217133 30033 218033 35552 218033 42823 c
218057 48886 L
@c
F
%CHAR: 247968 0 (t) @t
296404 14780 m
298773 166 L
294131 -805 289962 -1303 286291 -1303 c
280322 -1303 275656 -355 272364 1540 c
269072 3434 266727 5945 265400 9024 c
264050 12103 263363 18617 263363 28517 c
263363 84556 L
251260 84556 L
251260 97414 L
263363 97414 L
263363 121526 L
279777 131450 L
279777 97414 L
296381 97414 L
296381 84556 L
279777 84556 L
279777 27593 l
279777 22904 280085 19848 280654 18522 c
281222 17195 282193 16106 283496 15324 c
284822 14519 286717 14116 289157 14116 c
290980 14116 293396 14330 296381 14756 C
296404 14780 L
@c
F
%CHAR: 300168 0 (i) @t
312650 115486 m
312626 134458 L
329135 134458 L
329135 115486 L
312650 115486 L
@c
312650 0 m
312626 97414 L
329135 97414 L
329135 0 L
312650 0 L
@c
F
%CHAR: 341904 0 (c) @t
417863 35694 m
434087 33562 L
432334 22383 427763 13595 420468 7295 c
413173 971 404173 -2203 393538 -2203 c
380227 -2203 369497 2155 361397 10848 c
353297 19564 349223 32070 349223 48342 c
349223 58858 350975 68071 354457 75935 c
357939 83822 363268 89767 370374 93699 c
377479 97628 385248 99617 393633 99617 c
404196 99617 412865 96941 419592 91591 c
426318 86238 430629 78635 432524 68782 C
416465 66319 L
414949 72856 412226 77782 408365 81075 c
404480 84367 399767 86025 394272 86025 c
385959 86025 379185 83040 373998 77095 c
368810 71127 366205 61676 366205 48792 c
366205 35717 368716 26196 373713 20275 c
378735 14353 385295 11369 393348 11369 c
399838 11369 405262 13358 409596 17314 c
413931 21293 416702 27428 417839 35670 C
417863 35694 L
@c
F
T
@rax 533.81083 244.73735 571.01499 258.05310 @E
[0.00009574 0.00000000 0.00000000 0.00009574 533.81074996 244.95794069] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 187867.00000 z
%CHAR: 0 0 (B) @t
13761 0 m
13737 134458 L
64211 134458 l
74466 134458 82709 133084 88914 130384 c
95117 127684 99996 123468 103502 117831 c
107007 112170 108783 106225 108783 100067 c
108783 94335 107220 88914 104117 83846 c
100991 78777 96278 74656 89980 71529 C
98101 69161 104378 65063 108736 59332 c
113094 53600 115297 46802 115297 38986 c
115297 32686 113970 26812 111318 21411 c
108665 16011 105349 11819 101441 8882 c
97533 5945 92609 3719 86735 2250 c
80838 758 73590 0 65016 0 c
13761 0 L
@c
31549 77972 m
60634 77972 l
68498 77972 74182 78493 77593 79511 c
82117 80861 85551 83112 87825 86214 c
90099 89341 91259 93273 91259 97959 c
91259 102412 90193 106367 88062 109754 c
85930 113141 82851 115486 78896 116718 c
74916 117950 68095 118589 58432 118589 c
31549 118589 L
31549 77972 L
@c
31549 15869 m
65016 15869 l
70772 15869 74822 16082 77143 16509 c
81217 17219 84651 18451 87399 20156 c
90146 21861 92444 24372 94193 27641 c
95946 30909 96846 34699 96846 38986 c
96846 43984 95567 48342 93012 52036 c
90454 55731 86877 58360 82330 59853 c
77782 61345 71198 62103 62647 62103 c
31549 62103 L
31549 15869 L
@c
F
%CHAR: 125304 0 (G) @t
202731 52747 m
202707 68521 L
259691 68616 L
259691 18711 L
250951 11748 241904 6490 232619 2984 c
223334 -521 213768 -2297 204010 -2297 c
190794 -2297 178785 545 168009 6182 c
157208 11819 149060 20014 143565 30720 c
138070 41426 135299 53387 135299 66579 c
135299 79653 138047 91899 143494 103217 c
148966 114563 156853 122995 167108 128490 c
177388 133984 189230 136756 202613 136756 c
212324 136756 221132 135169 228995 132042 c
236859 128892 243017 124487 247470 118873 c
251922 113260 255333 105894 257654 96846 C
241619 92467 L
239606 99286 237072 104686 234087 108594 c
231103 112502 226792 115652 221250 117997 c
215687 120342 209481 121526 202707 121526 c
194583 121526 187549 120294 181628 117831 c
175706 115368 170898 112076 167274 108049 c
163627 104023 160785 99570 158771 94738 c
155361 86451 153632 77403 153632 67692 c
153632 55708 155692 45665 159813 37612 c
163935 29536 169974 23519 177838 19611 c
185725 15703 194133 13737 202992 13737 c
210689 13737 218221 15230 225561 18190 c
232903 21151 238469 24325 242259 27688 C
242259 52747 L
202731 52747 L
@c
F
%CHAR: 271440 0 (P) @t
285935 0 m
285912 134458 L
336645 134458 l
345575 134458 352420 134032 357110 133179 c
363694 132090 369257 129982 373710 126903 c
378163 123824 381787 119465 384487 113923 c
387187 108357 388561 102223 388561 95567 c
388561 84154 384913 74466 377665 66556 c
370394 58645 357228 54666 338209 54666 c
303723 54666 L
303723 0 L
285935 0 L
@c
303723 70535 m
338493 70535 l
349980 70535 358152 72690 362983 76953 c
367812 81217 370228 87256 370228 95022 c
370228 100636 368807 105467 365965 109470 c
363126 113473 359360 116126 354717 117405 c
351733 118186 346167 118589 338114 118589 c
303723 118589 L
303723 70535 L
@c
F
T
@rax 408.45628 264.29074 446.56838 277.41373 @E
[0.00009574 0.00000000 0.00000000 0.00009574 408.45620689 264.50210637] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 188424.00000 z
%CHAR: 0 0 (t) @t
48581 14803 m
50950 166 L
46308 -805 42115 -1303 38444 -1303 c
32428 -1303 27759 -355 24467 1540 c
21151 3434 18806 5969 17480 9048 c
16130 12127 15443 18664 15443 28612 c
15443 84820 L
3292 84820 L
3292 97708 L
15443 97708 L
15443 121890 L
31907 131838 L
31907 97708 L
48558 97708 L
48558 84820 L
31907 84820 L
31907 27688 l
31907 22975 32215 19919 32783 18593 c
33352 17243 34323 16153 35626 15372 c
36952 14566 38847 14164 41310 14164 c
43134 14164 45573 14377 48558 14803 c
48581 14803 L
@c
F
%CHAR: 49680 0 (a) @t
125855 12056 m
119720 6845 113799 3126 108138 995 c
102477 -1137 96367 -2226 89877 -2226 c
79144 -2226 70878 403 65123 5637 c
59367 10872 56478 17598 56478 25746 c
56478 30530 57567 34915 59746 38847 c
61925 42802 64791 46000 68297 48368 c
71802 50760 75805 52584 80210 53816 c
83458 54669 88385 55498 94945 56303 c
108304 57890 118157 59808 124457 62011 C
124505 64261 124552 65706 124552 66322 c
124552 73048 122989 77833 119862 80580 c
115646 84322 109346 86194 101009 86194 c
93240 86194 87461 84820 83766 82096 c
80068 79372 77297 74517 75521 67601 C
59320 69827 L
60788 76743 63228 82357 66591 86620 c
69955 90883 74857 94176 81232 96452 c
87603 98750 95017 99910 103401 99910 c
111738 99910 118512 98916 123723 96973 c
128934 95007 132795 92518 135234 89557 c
137674 86573 139403 82807 140374 78283 c
140919 75464 141203 70348 141203 63006 c
141203 40931 l
141203 25533 141558 15798 142269 11724 c
142979 7650 144380 3719 146464 0 C
129171 0 L
127465 3411 126328 7437 125855 12032 c
125855 12056 L
@c
124481 49031 m
118465 46568 109441 44484 97409 42779 c
90611 41807 85779 40694 82984 39463 c
80163 38231 77960 36431 76444 34086 c
74928 31718 74147 29085 74147 26220 c
74147 21814 75829 18119 79144 15182 c
82487 12245 87390 10753 93832 10753 c
100204 10753 105888 12151 110838 14922 c
115812 17717 119483 21554 121805 26385 c
123557 30128 124457 35649 124457 42944 c
124481 49031 L
@c
F
%CHAR: 154464 0 (b) @t
182152 0 m
166780 0 L
166780 134870 L
183336 134870 L
183336 86738 L
190326 95505 199256 99910 210104 99910 c
216120 99910 221828 98702 227181 96286 c
232534 93868 236963 90433 240421 86075 c
243879 81693 246626 76388 248568 70206 c
250514 64001 251508 57369 251508 50310 c
251508 33589 247361 20630 239094 11487 c
230828 2345 220880 -2226 209298 -2226 c
197764 -2226 188692 2605 182152 12222 C
182152 0 L
@c
181963 49600 m
181963 37876 183573 29393 186750 24183 c
191961 15656 199019 11393 207901 11393 c
215149 11393 221425 14543 226683 20819 c
231941 27096 234594 36478 234594 48937 c
234594 61679 232060 71106 227015 77170 c
221946 83233 215812 86288 208635 86288 c
201411 86288 195135 83138 189876 76862 c
184615 70585 181963 61466 181963 49576 C
181963 49600 L
@c
F
%CHAR: 259248 0 (l) @t
271304 0 m
271280 134870 L
287860 134870 L
287860 0 L
271304 0 L
@c
F
%CHAR: 301104 0 (e) @t
380405 31457 m
397509 29346 L
394806 19351 389808 11558 382513 6063 c
375218 545 365886 -2226 354541 -2226 c
340259 -2226 328910 2179 320550 10966 c
312189 19777 307996 32144 307996 48013 c
307996 64451 312236 77217 320692 86288 c
329147 95363 340140 99910 353617 99910 c
366691 99910 377373 95457 385640 86573 c
393929 77667 398077 65137 398077 49031 c
398077 48060 398030 46568 397983 44602 C
325097 44602 L
325713 33897 328768 25651 334219 19967 c
339667 14259 346488 11393 354636 11393 c
360699 11393 365910 13003 370173 16177 c
374460 19351 377895 24467 380405 31457 C
@c
326045 58245 m
380595 58221 L
379860 66440 377752 72622 374318 76719 c
369060 83091 362191 86288 353807 86288 c
346227 86288 339809 83730 334645 78662 c
329455 73569 326566 66748 326021 58221 C
326045 58245 L
@c
F
T
@rax 423.75231 241.71732 432.80759 254.64472 @E
[0.00009574 0.00000000 0.00000000 0.00009574 423.75216172 241.71732029] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 187867.00000 z
%CHAR: 0 0 (2) @t
94572 15869 m
94572 0 L
5684 0 L
5566 3955 6206 7792 7603 11464 c
9853 17503 13501 23472 18474 29346 c
23448 35220 30672 42018 40075 49715 c
54689 61700 64590 71198 69706 78185 c
74822 85196 77403 91828 77403 98054 c
77403 104591 75059 110110 70393 114610 c
65727 119110 59616 121360 52084 121360 c
44149 121360 37778 118968 33017 114207 c
28257 109423 25817 102815 25770 94383 C
8787 96112 L
9948 108760 14330 118423 21909 125055 c
29488 131687 39673 135027 52463 135027 c
65348 135027 75580 131450 83088 124297 c
90620 117144 94383 108239 94383 97675 c
94383 92301 93273 86996 91093 81809 c
88891 76622 85220 71127 80127 65395 c
75011 59663 66508 51752 54666 41733 c
44765 33420 38370 27759 35575 24798 c
32780 21838 30436 18853 28612 15869 C
94572 15869 L
@c
F
T
@rax 298.38246 239.60665 331.64362 256.05865 @E
[0.00009574 0.00000000 0.00000000 0.00009574 298.38255753 243.18428450] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 187867.00000 z
%CHAR: 0 0 (p) @t
12387 -37352 m
12364 97414 L
27428 97414 L
27428 84746 L
30957 89696 34983 93438 39436 95899 c
43889 98362 49313 99617 55660 99617 c
63974 99617 71340 97462 77688 93201 c
84035 88914 88867 82851 92088 75082 c
95306 67290 96941 58716 96941 49431 c
96941 39483 95141 30483 91591 22525 c
88014 14543 82804 8408 75982 4169 c
69161 -71 61984 -2203 54476 -2203 c
48981 -2203 44031 -1042 39673 1279 c
35315 3600 31691 6537 28896 10090 C
28896 -37352 L
12387 -37352 L
@c
27333 48152 m
27333 35623 29867 26338 34936 20369 c
40004 14377 46186 11369 53387 11369 c
60705 11369 67006 14472 72216 20677 c
77451 26883 80080 36499 80080 49526 c
80080 61937 77522 71245 72429 77403 c
67313 83585 61203 86688 54121 86688 c
47086 86688 40857 83396 35457 76835 c
30057 70250 27333 60682 27333 48152 c
@c
F
%CHAR: 104496 0 (i) @t
116978 115486 m
116954 134458 L
133463 134458 L
133463 115486 L
116978 115486 L
@c
116978 0 m
116954 97414 L
133463 97414 L
133463 0 L
116978 0 L
@c
F
%CHAR: 146232 0 (p) @t
158619 -37352 m
158596 97414 L
173660 97414 L
173660 84746 L
177189 89696 181215 93438 185668 95899 c
190121 98362 195545 99617 201892 99617 c
210206 99617 217572 97462 223920 93201 c
230267 88914 235099 82851 238320 75082 c
241538 67290 243173 58716 243173 49431 c
243173 39483 241373 30483 237823 22525 c
234246 14543 229036 8408 222214 4169 c
215393 -71 208216 -2203 200708 -2203 c
195213 -2203 190263 -1042 185905 1279 c
181547 3600 177923 6537 175128 10090 C
175128 -37352 L
158619 -37352 L
@c
173565 48152 m
173565 35623 176099 26338 181168 20369 c
186236 14377 192418 11369 199619 11369 c
206937 11369 213238 14472 218448 20677 c
223683 26883 226312 36499 226312 49526 c
226312 61937 223754 71245 218661 77403 c
213545 83585 207435 86688 200353 86688 c
193318 86688 187089 83396 181689 76835 c
176289 70250 173565 60682 173565 48152 c
@c
F
%CHAR: 250728 0 (e) @t
329813 31383 m
346840 29251 L
344166 19303 339169 11558 331897 6063 c
324626 568 315318 -2203 304020 -2203 c
289761 -2203 278463 2179 270126 10943 c
261789 19706 257597 32046 257597 47868 c
257597 64258 261813 76977 270245 86025 c
278677 95070 289643 99617 303096 99617 c
316123 99617 326781 95164 335024 86309 c
343266 77451 347408 64945 347408 48886 c
347408 47915 347361 46423 347313 44481 C
274650 44481 L
275266 33775 278298 25580 283745 19896 c
289193 14211 295991 11369 304115 11369 c
310154 11369 315341 12956 319605 16130 c
323868 19303 327279 24396 329789 31359 C
329813 31383 L
@c
275598 58076 m
329979 58053 L
329245 66248 327137 72406 323726 76503 c
318468 82851 311646 86025 303286 86025 c
295706 86025 289335 83491 284172 78422 c
279008 73353 276119 66556 275574 58053 C
275598 58076 L
@c
F
T
@rax 130.51502 92.83266 222.77140 105.95565 @E
[0.00009574 0.00000000 0.00000000 0.00009574 130.51500994 93.04400499] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 188424.00000 z
%CHAR: 0 0 (k) @t
12506 0 m
12506 134870 L
29062 134870 L
29062 57961 L
68264 97708 L
89699 97708 L
52347 61442 L
93465 0 L
73048 0 L
40742 49955 L
29062 38728 L
29062 0 L
12506 0 L
@c
F
%CHAR: 94224 0 (e) @t
173525 31457 m
190629 29346 L
187926 19351 182928 11558 175633 6063 c
168338 545 159006 -2226 147661 -2226 c
133379 -2226 122030 2179 113670 10966 c
105309 19777 101116 32144 101116 48013 c
101116 64451 105356 77217 113812 86288 c
122267 95363 133260 99910 146737 99910 c
159811 99910 170493 95457 178760 86573 c
187049 77667 191197 65137 191197 49031 c
191197 48060 191150 46568 191103 44602 C
118217 44602 L
118833 33897 121888 25651 127339 19967 c
132787 14259 139608 11393 147756 11393 c
153819 11393 159030 13003 163293 16177 c
167580 19351 171015 24467 173525 31457 C
@c
119165 58245 m
173715 58221 L
172980 66440 170872 72622 167438 76719 c
162180 83091 155311 86288 146927 86288 c
139347 86288 132929 83730 127765 78662 c
122575 73569 119686 66748 119141 58221 C
119165 58245 L
@c
F
%CHAR: 199008 0 (r) @t
211253 0 m
211230 97708 L
226128 97708 L
226128 82878 L
229917 89794 233449 94392 236671 96594 c
239892 98797 243444 99910 247305 99910 c
252871 99910 258556 98134 264311 94581 C
258627 79206 L
254577 81575 250503 82783 246476 82783 c
242876 82783 239607 81693 236742 79538 c
233852 77359 231791 74327 230560 70467 c
228709 64593 227786 58127 227786 51139 c
227786 0 L
211253 0 L
@c
F
%CHAR: 261744 0 (n) @t
274155 0 m
274155 97708 L
289053 97708 L
289053 83801 L
296233 94534 306607 99910 320155 99910 c
326029 99910 331453 98844 336379 96736 c
341306 94628 345024 91831 347464 88420 c
349927 84986 351656 80888 352627 76175 c
353243 73096 353551 67719 353551 60069 c
353551 0 L
336995 0 L
336995 59429 l
336995 66156 336355 71225 335076 74540 c
333797 77880 331476 80556 328208 82546 c
324939 84536 321055 85554 316649 85554 c
309615 85554 303528 83304 298412 78851 c
293296 74375 290711 65848 290711 53342 c
290711 0 L
274155 0 L
@c
F
%CHAR: 366528 0 (e) @t
445829 31457 m
462933 29346 L
460230 19351 455232 11558 447937 6063 c
440642 545 431310 -2226 419965 -2226 c
405683 -2226 394334 2179 385974 10966 c
377613 19777 373420 32144 373420 48013 c
373420 64451 377660 77217 386116 86288 c
394571 95363 405564 99910 419041 99910 c
432115 99910 442797 95457 451064 86573 c
459353 77667 463501 65137 463501 49031 c
463501 48060 463454 46568 463407 44602 C
390521 44602 L
391137 33897 394192 25651 399643 19967 c
405091 14259 411912 11393 420060 11393 c
426123 11393 431334 13003 435597 16177 c
439884 19351 443319 24467 445829 31457 C
@c
391469 58245 m
446019 58221 L
445284 66440 443176 72622 439742 76719 c
434484 83091 427615 86288 419231 86288 c
411651 86288 405233 83730 400069 78662 c
394879 73569 391990 66748 391445 58221 C
391469 58245 L
@c
F
%CHAR: 471312 0 (l) @t
483368 0 m
483344 134870 L
499924 134870 L
499924 0 L
483368 0 L
@c
F
%CHAR: 565512 0 (t) @t
614093 14803 m
616462 166 L
611820 -805 607627 -1303 603956 -1303 c
597940 -1303 593271 -355 589979 1540 c
586663 3434 584318 5969 582992 9048 c
581642 12127 580955 18664 580955 28612 c
580955 84820 L
568804 84820 L
568804 97708 L
580955 97708 L
580955 121890 L
597419 131838 L
597419 97708 L
614070 97708 L
614070 84820 L
597419 84820 L
597419 27688 l
597419 22975 597727 19919 598295 18593 c
598864 17243 599835 16153 601138 15372 c
602464 14566 604359 14164 606822 14164 c
608646 14164 611085 14377 614070 14803 c
614093 14803 L
@c
F
%CHAR: 615192 0 (a) @t
691367 12056 m
685232 6845 679311 3126 673650 995 c
667989 -1137 661879 -2226 655389 -2226 c
644656 -2226 636390 403 630635 5637 c
624879 10872 621990 17598 621990 25746 c
621990 30530 623079 34915 625258 38847 c
627437 42802 630303 46000 633809 48368 c
637314 50760 641317 52584 645722 53816 c
648970 54669 653897 55498 660457 56303 c
673816 57890 683669 59808 689969 62011 C
690017 64261 690064 65706 690064 66322 c
690064 73048 688501 77833 685374 80580 c
681158 84322 674858 86194 666521 86194 c
658752 86194 652973 84820 649278 82096 c
645580 79372 642809 74517 641033 67601 C
624832 69827 L
626300 76743 628740 82357 632103 86620 c
635467 90883 640369 94176 646744 96452 c
653115 98750 660529 99910 668913 99910 c
677250 99910 684024 98916 689235 96973 c
694446 95007 698307 92518 700746 89557 c
703186 86573 704915 82807 705886 78283 c
706431 75464 706715 70348 706715 63006 c
706715 40931 l
706715 25533 707070 15798 707781 11724 c
708491 7650 709892 3719 711976 0 C
694683 0 L
692977 3411 691840 7437 691367 12032 c
691367 12056 L
@c
689993 49031 m
683977 46568 674953 44484 662921 42779 c
656123 41807 651291 40694 648496 39463 c
645675 38231 643472 36431 641956 34086 c
640440 31718 639659 29085 639659 26220 c
639659 21814 641341 18119 644656 15182 c
647999 12245 652902 10753 659344 10753 c
665716 10753 671400 12151 676350 14922 c
681324 17717 684995 21554 687317 26385 c
689069 30128 689969 35649 689969 42944 c
689993 49031 L
@c
F
%CHAR: 719976 0 (b) @t
747664 0 m
732292 0 L
732292 134870 L
748848 134870 L
748848 86738 L
755838 95505 764768 99910 775616 99910 c
781632 99910 787340 98702 792693 96286 c
798046 93868 802475 90433 805933 86075 c
809391 81693 812138 76388 814080 70206 c
816026 64001 817020 57369 817020 50310 c
817020 33589 812873 20630 804606 11487 c
796340 2345 786392 -2226 774810 -2226 c
763276 -2226 754204 2605 747664 12222 C
747664 0 L
@c
747475 49600 m
747475 37876 749085 29393 752262 24183 c
757473 15656 764531 11393 773413 11393 c
780661 11393 786937 14543 792195 20819 c
797453 27096 800106 36478 800106 48937 c
800106 61679 797572 71106 792527 77170 c
787458 83233 781324 86288 774147 86288 c
766923 86288 760647 83138 755388 76862 c
750127 70585 747475 61466 747475 49576 C
747475 49600 L
@c
F
%CHAR: 824760 0 (l) @t
836816 0 m
836792 134870 L
853372 134870 L
853372 0 L
836816 0 L
@c
F
%CHAR: 866616 0 (e) @t
945917 31457 m
963021 29346 L
960318 19351 955320 11558 948025 6063 c
940730 545 931398 -2226 920053 -2226 c
905771 -2226 894422 2179 886062 10966 c
877701 19777 873508 32144 873508 48013 c
873508 64451 877748 77217 886204 86288 c
894659 95363 905652 99910 919129 99910 c
932203 99910 942885 95457 951152 86573 c
959441 77667 963589 65137 963589 49031 c
963589 48060 963542 46568 963495 44602 C
890609 44602 L
891225 33897 894280 25651 899731 19967 c
905179 14259 912000 11393 920148 11393 c
926211 11393 931422 13003 935685 16177 c
939972 19351 943407 24467 945917 31457 C
@c
891557 58245 m
946107 58221 L
945372 66440 943264 72622 939830 76719 c
934572 83091 927703 86288 919319 86288 c
911739 86288 905321 83730 900157 78662 c
894967 73569 892078 66748 891533 58221 C
891557 58245 L
@c
F
T
@rax 157.43339 289.66932 195.43748 302.75518 @E
[0.00009574 0.00000000 0.00000000 0.00009574 157.43351915 289.88077355] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 187867.00000 z
%CHAR: 0 0 (t) @t
48436 14780 m
50805 166 L
46163 -805 41994 -1303 38323 -1303 c
32354 -1303 27688 -355 24396 1540 c
21104 3434 18759 5945 17432 9024 c
16082 12103 15395 18617 15395 28517 c
15395 84556 L
3292 84556 L
3292 97414 L
15395 97414 L
15395 121526 L
31809 131450 L
31809 97414 L
48413 97414 L
48413 84556 L
31809 84556 L
31809 27593 l
31809 22904 32117 19848 32686 18522 c
33254 17195 34225 16106 35528 15324 c
36854 14519 38749 14116 41189 14116 c
43012 14116 45428 14330 48413 14756 C
48436 14780 L
@c
F
%CHAR: 49536 0 (a) @t
125495 12008 m
119384 6821 113462 3150 107825 1018 c
102188 -1113 96101 -2203 89611 -2203 c
78906 -2203 70663 426 64931 5637 c
59200 10848 56310 17551 56310 25675 c
56310 30436 57400 34817 59555 38749 c
61734 42681 64600 45878 68105 48247 c
71611 50615 75590 52439 79972 53647 c
83216 54500 88119 55329 94656 56134 c
107968 57721 117797 59639 124097 61819 C
124145 64069 124192 65513 124192 66129 c
124192 72856 122629 77593 119526 80340 c
115310 84083 109010 85954 100720 85954 c
92951 85954 87219 84580 83524 81880 c
79829 79156 77058 74324 75306 67408 C
59152 69611 L
60621 76527 63037 82117 66400 86356 c
69763 90596 74642 93888 80990 96159 c
87338 98457 94727 99617 103088 99617 c
111402 99617 118176 98622 123363 96680 c
128574 94738 132411 92254 134827 89293 c
137266 86333 138995 82567 139966 78043 c
140511 75248 140795 70156 140795 62837 c
140795 40810 l
140795 25462 141151 15751 141837 11701 c
142548 7627 143942 3719 146027 0 C
128787 0 L
127082 3411 125945 7413 125471 12008 C
125495 12008 L
@c
124121 48886 m
118128 46447 109128 44339 97143 42633 c
90369 41686 85538 40573 82743 39365 c
79924 38133 77745 36333 76229 33988 c
74713 31620 73932 28991 73932 26125 c
73932 21719 75613 18048 78929 15135 c
82245 12198 87148 10729 93567 10729 c
99915 10729 105575 12127 110526 14898 c
115476 17669 119123 21483 121444 26314 c
123197 30033 124097 35552 124097 42823 c
124121 48886 L
@c
F
%CHAR: 154032 0 (b) @t
181649 0 m
166301 0 L
166301 134458 L
182833 134458 L
182833 86499 L
189797 95235 198702 99617 209527 99617 c
215495 99617 221180 98409 226533 95993 c
231885 93580 236291 90170 239749 85812 c
243207 81454 245931 76148 247873 69990 c
249812 63808 250807 57176 250807 50165 c
250807 33491 246665 20559 238423 11464 c
230180 2369 220256 -2203 208698 -2203 c
197210 -2203 188162 2605 181625 12198 C
181649 0 L
@c
181460 49455 m
181460 37754 183046 29299 186220 24112 c
191407 15632 198466 11369 207324 11369 c
214524 11369 220777 14519 226035 20772 c
231293 27025 233922 36381 233922 48792 c
233922 61511 231388 70914 226367 76953 c
221322 82993 215211 86025 208058 86025 c
200858 86025 194605 82875 189347 76622 c
184089 70369 181460 61274 181460 49431 C
181460 49455 L
@c
F
%CHAR: 258528 0 (l) @t
270536 0 m
270536 134458 L
287045 134458 L
287045 0 L
270536 0 L
@c
F
%CHAR: 300264 0 (e) @t
379349 31383 m
396376 29251 L
393702 19303 388705 11558 381433 6063 c
374162 568 364854 -2203 353556 -2203 c
339297 -2203 327999 2179 319662 10943 c
311325 19706 307133 32046 307133 47868 c
307133 64258 311349 76977 319781 86025 c
328213 95070 339179 99617 352632 99617 c
365659 99617 376317 95164 384560 86309 c
392802 77451 396944 64945 396944 48886 c
396944 47915 396897 46423 396849 44481 C
324186 44481 L
324802 33775 327834 25580 333281 19896 c
338729 14211 345527 11369 353651 11369 c
359690 11369 364877 12956 369141 16130 c
373404 19303 376815 24396 379325 31359 C
379349 31383 L
@c
325134 58076 m
379515 58053 L
378781 66248 376673 72406 373262 76503 c
368004 82851 361182 86025 352822 86025 c
345242 86025 338871 83491 333708 78422 c
328544 73353 325655 66556 325110 58053 C
325134 58076 L
@c
F
T
@rax 171.73219 261.55389 178.43244 274.48129 @E
[0.00009574 0.00000000 0.00000000 0.00009574 171.73210693 261.55399179] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 187867.00000 z
%CHAR: 0 0 (1) @t
69990 0 m
53458 0 L
53458 105207 L
49502 101417 44291 97628 37849 93841 c
31407 90051 25580 87185 20440 85291 C
20440 101251 L
29678 105586 37754 110868 44647 117026 c
51563 123208 56466 129224 59332 135027 C
69990 135027 L
69990 0 L
@c
F
T
@rax %Note: Object
176.16189 109.68406 176.16302 135.58394 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
176.16246 135.58394 m
176.16246 126.95074 176.16246 118.31754 176.16246 109.68406 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
176.16246 139.13008 m
179.18646 132.07408 L
177.17046 133.08208 175.15446 133.08208 173.13846 132.07408 C
176.16246 139.13008 L
f
@J
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
176.16246 106.13792 m
179.18646 113.19392 L
177.17046 112.18592 175.15446 112.18592 173.13846 113.19392 C
176.16246 106.13792 L
f
@J
@rax %Note: Object
14.27131 255.64224 77.98167 294.56617 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
46.12649 294.56617 m
63.67181 294.56617 77.98167 285.82356 77.98167 275.10406 c
77.98167 264.38485 63.67181 255.64224 46.12649 255.64224 c
28.58117 255.64224 14.27131 264.38485 14.27131 275.10406 c
14.27131 285.82356 28.58117 294.56617 46.12649 294.56617 c
@c
S
@rax %Note: Object
101.23852 287.22954 116.28085 302.98422 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
101.23852 302.98422 m
116.28085 302.98422 L
116.28085 287.22954 L
101.23852 287.22954 L
101.23852 302.98422 L
@c
S
@rax 107.37468 292.63521 110.49647 299.90976 @E
[0.00009574 0.00000000 0.00000000 0.00009574 107.37463338 292.63532344] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 104370.00000 z
%CHAR: 0 0 (f) @t
9074 0 m
9060 46974 L
962 46974 L
962 54109 L
9060 54109 L
9060 59867 l
9060 63509 9385 66218 10037 67980 c
10910 70348 12464 72287 14685 73753 c
16905 75233 20044 75973 24041 75973 c
26619 75973 29491 75663 32615 75056 C
31238 67062 L
29343 67387 27522 67565 25832 67565 c
23049 67565 21080 66973 19925 65789 c
18771 64604 18178 62369 18178 59112 c
18178 54109 L
28736 54109 L
28736 46974 L
18178 46974 L
18178 0 L
9074 0 L
@c
F
T
@rax 107.37468 292.63521 110.49647 299.90976 @E
[0.00009574 0.00000000 0.00000000 0.00009574 107.37463338 292.63532344] @tm
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.21600 0.21600 0.00000 @w
r
% FontChange:/_Arial 104370.00000 z
%CHAR: 0 0 (f) @t
9074 0 m
9060 46974 L
962 46974 L
962 54109 L
9060 54109 L
9060 59867 l
9060 63509 9385 66218 10037 67980 c
10910 70348 12464 72287 14685 73753 c
16905 75233 20044 75973 24041 75973 c
26619 75973 29491 75663 32615 75056 C
31238 67062 L
29343 67387 27522 67565 25832 67565 c
23049 67565 21080 66973 19925 65789 c
18771 64604 18178 62369 18178 59112 c
18178 54109 L
28736 54109 L
28736 46974 L
18178 46974 L
18178 0 L
9074 0 L
@c
S
T
@rax %Note: Object
101.23852 248.30561 116.28085 264.06028 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
101.23852 264.06028 m
116.28085 264.06028 L
116.28085 248.30561 L
101.23852 248.30561 L
101.23852 264.06028 L
@c
S
@rax 107.66806 252.82857 110.79921 260.12438 @E
[0.00009574 0.00000000 0.00000000 0.00009574 107.66801920 252.82844459] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 104680.00000 z
%CHAR: 0 0 (f) @t
9104 0 m
9089 47122 L
962 47122 L
962 54272 L
9089 54272 L
9089 60045 l
9089 63687 9415 66410 10066 68172 c
10940 70555 12509 72495 14729 73975 c
16965 75455 20103 76195 24115 76195 c
26708 76195 29580 75885 32703 75278 C
31327 67254 L
29432 67595 27611 67772 25906 67772 c
23123 67772 21139 67165 19984 65981 c
18830 64797 18238 62547 18238 59290 c
18238 54272 L
28825 54272 L
28825 47122 L
18238 47122 L
18238 0 L
9104 0 L
@c
F
T
@rax 23.04680 269.16321 71.19326 282.48576 @E
[0.00009574 0.00000000 0.00000000 0.00009574 23.04673119 269.38384725] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 187867.00000 z
%CHAR: 0 0 (O) @t
9071 65490 m
9071 87801 15064 105302 27049 117902 c
39033 130526 54523 136850 73472 136850 c
85883 136850 97083 133890 107031 127968 c
117002 122047 124629 113757 129840 103146 c
135050 92538 137679 80506 137679 67053 c
137679 53410 134932 41212 129437 30459 c
123942 19706 116126 11535 106036 6016 c
95946 474 85054 -2297 73377 -2297 c
60729 -2297 49384 758 39436 6869 c
29488 12980 21909 21340 16793 31904 c
11653 42468 9071 53694 9071 65490 c
@c
27428 65229 m
27428 49028 31786 36238 40478 26930 c
49194 17598 60137 12932 73282 12932 c
86664 12932 97699 17646 106344 27049 c
114989 36475 119323 49857 119323 67148 c
119323 78090 117476 87659 113781 95804 c
110086 103952 104662 110299 97557 114776 c
90430 119276 82425 121526 73566 121526 c
60966 121526 50118 117192 41047 108547 c
31975 99901 27428 85433 27428 65205 C
27428 65229 L
@c
F
%CHAR: 146136 0 (S) @t
154568 43202 m
171361 44670 L
172142 37944 174014 32425 176903 28114 c
179793 23804 184317 20322 190427 17669 c
196538 15016 203431 13666 211081 13666 c
217855 13666 223871 14685 229058 16674 c
234245 18688 238130 21483 240637 24988 c
243172 28493 244451 32354 244451 36499 c
244451 40715 243219 44410 240803 47536 c
238366 50686 234316 53363 228679 55495 c
225079 56892 217097 59095 204757 62032 c
192393 64992 183724 67811 178774 70440 c
172379 73803 167571 77972 164445 82946 c
161295 87920 159708 93533 159708 99712 c
159708 106486 161650 112834 165487 118731 c
169324 124629 174961 129129 182351 132161 c
189741 135216 197983 136756 207031 136756 c
217002 136756 225813 135145 233416 131948 c
241016 128750 246890 124013 250964 117784 c
255062 111531 257288 104449 257572 96585 C
240519 95306 L
239622 103786 236495 110228 231213 114563 c
225932 118897 218092 121076 207765 121076 c
197012 121076 189172 119086 184246 115155 c
179319 111223 176856 106439 176856 100896 c
176856 96064 178608 92088 182090 88962 c
185501 85859 194478 82662 208926 79393 c
223374 76124 233321 73235 238674 70819 c
246487 67219 252290 62624 256009 57105 c
259751 51563 261622 45168 261622 37967 c
261622 30815 259562 24064 255488 17740 c
251390 11416 245493 6490 237822 2984 c
230148 -521 221502 -2297 211886 -2297 c
199736 -2297 189527 -521 181309 3008 c
173090 6561 166624 11914 161958 19019 c
157268 26125 154805 34202 154568 43202 C
@c
F
%CHAR: 271440 0 (P) @t
285935 0 m
285912 134458 L
336645 134458 l
345575 134458 352420 134032 357110 133179 c
363694 132090 369257 129982 373710 126903 c
378163 123824 381787 119465 384487 113923 c
387187 108357 388561 102223 388561 95567 c
388561 84154 384913 74466 377665 66556 c
370394 58645 357228 54666 338209 54666 c
303723 54666 L
303723 0 L
285935 0 L
@c
303723 70535 m
338493 70535 l
349980 70535 358152 72690 362983 76953 c
367812 81217 370228 87256 370228 95022 c
370228 100636 368807 105467 365965 109470 c
363126 113473 359360 116126 354717 117405 c
351733 118186 346167 118589 338114 118589 c
303723 118589 L
303723 70535 L
@c
F
%CHAR: 396744 0 (F) @t
412163 0 m
412139 134458 L
502875 134458 L
502875 118589 L
429951 118589 L
429951 76953 L
493045 76953 L
493045 61084 L
429951 61084 L
429951 0 L
412163 0 L
@c
F
T
@rax %Note: Object
143.10198 137.01685 206.81235 175.94079 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
174.95717 175.94079 m
192.50249 175.94079 206.81235 167.19817 206.81235 156.47896 c
206.81235 145.75975 192.50249 137.01685 174.95717 137.01685 c
157.41184 137.01685 143.10198 145.75975 143.10198 156.47896 c
143.10198 167.19817 157.41184 175.94079 174.95717 175.94079 c
@c
S
@rax %Note: Object
149.25203 193.62671 164.29436 209.38139 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
149.25203 209.38139 m
164.29436 209.38139 L
164.29436 193.62671 L
149.25203 193.62671 L
149.25203 209.38139 L
@c
S
@rax 155.38819 199.03266 158.50998 206.30693 @E
[0.00009574 0.00000000 0.00000000 0.00009574 155.38815181 199.03261601] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 104370.00000 z
%CHAR: 0 0 (f) @t
9074 0 m
9060 46974 L
962 46974 L
962 54109 L
9060 54109 L
9060 59867 l
9060 63509 9385 66218 10037 67980 c
10910 70348 12464 72287 14685 73753 c
16905 75233 20044 75973 24041 75973 c
26619 75973 29491 75663 32615 75056 C
31238 67062 L
29343 67387 27522 67565 25832 67565 c
23049 67565 21080 66973 19925 65789 c
18771 64604 18178 62369 18178 59112 c
18178 54109 L
28736 54109 L
28736 46974 L
18178 46974 L
18178 0 L
9074 0 L
@c
F
T
@rax %Note: Object
184.33899 192.70006 199.38132 208.45474 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
184.33899 208.45474 m
199.38132 208.45474 L
199.38132 192.70006 L
184.33899 192.70006 L
184.33899 208.45474 L
@c
S
@rax 190.47515 198.10602 193.60630 205.40183 @E
[0.00009574 0.00000000 0.00000000 0.00009574 190.47510473 198.10591152] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 104680.00000 z
%CHAR: 0 0 (f) @t
9104 0 m
9089 47122 L
962 47122 L
962 54272 L
9089 54272 L
9089 60045 l
9089 63687 9415 66410 10066 68172 c
10940 70555 12509 72495 14729 73975 c
16965 75455 20103 76195 24115 76195 c
26708 76195 29580 75885 32703 75278 C
31327 67254 L
29432 67595 27611 67772 25906 67772 c
23123 67772 21139 67165 19984 65981 c
18830 64797 18238 62547 18238 59290 c
18238 54272 L
28825 54272 L
28825 47122 L
18238 47122 L
18238 0 L
9104 0 L
@c
F
T
@rax 151.10872 150.36265 198.97285 163.48564 @E
[0.00009574 0.00000000 0.00000000 0.00009574 151.10863718 150.57399333] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 188424.00000 z
%CHAR: 0 0 (k) @t
12506 0 m
12506 134870 L
29062 134870 L
29062 57961 L
68264 97708 L
89699 97708 L
52347 61442 L
93465 0 L
73048 0 L
40742 49955 L
29062 38728 L
29062 0 L
12506 0 L
@c
F
%CHAR: 94224 0 (e) @t
173525 31457 m
190629 29346 L
187926 19351 182928 11558 175633 6063 c
168338 545 159006 -2226 147661 -2226 c
133379 -2226 122030 2179 113670 10966 c
105309 19777 101116 32144 101116 48013 c
101116 64451 105356 77217 113812 86288 c
122267 95363 133260 99910 146737 99910 c
159811 99910 170493 95457 178760 86573 c
187049 77667 191197 65137 191197 49031 c
191197 48060 191150 46568 191103 44602 C
118217 44602 L
118833 33897 121888 25651 127339 19967 c
132787 14259 139608 11393 147756 11393 c
153819 11393 159030 13003 163293 16177 c
167580 19351 171015 24467 173525 31457 C
@c
119165 58245 m
173715 58221 L
172980 66440 170872 72622 167438 76719 c
162180 83091 155311 86288 146927 86288 c
139347 86288 132929 83730 127765 78662 c
122575 73569 119686 66748 119141 58221 C
119165 58245 L
@c
F
%CHAR: 199008 0 (r) @t
211253 0 m
211230 97708 L
226128 97708 L
226128 82878 L
229917 89794 233449 94392 236671 96594 c
239892 98797 243444 99910 247305 99910 c
252871 99910 258556 98134 264311 94581 C
258627 79206 L
254577 81575 250503 82783 246476 82783 c
242876 82783 239607 81693 236742 79538 c
233852 77359 231791 74327 230560 70467 c
228709 64593 227786 58127 227786 51139 c
227786 0 L
211253 0 L
@c
F
%CHAR: 261744 0 (n) @t
274155 0 m
274155 97708 L
289053 97708 L
289053 83801 L
296233 94534 306607 99910 320155 99910 c
326029 99910 331453 98844 336379 96736 c
341306 94628 345024 91831 347464 88420 c
349927 84986 351656 80888 352627 76175 c
353243 73096 353551 67719 353551 60069 c
353551 0 L
336995 0 L
336995 59429 l
336995 66156 336355 71225 335076 74540 c
333797 77880 331476 80556 328208 82546 c
324939 84536 321055 85554 316649 85554 c
309615 85554 303528 83304 298412 78851 c
293296 74375 290711 65848 290711 53342 c
290711 0 L
274155 0 L
@c
F
%CHAR: 366528 0 (e) @t
445829 31457 m
462933 29346 L
460230 19351 455232 11558 447937 6063 c
440642 545 431310 -2226 419965 -2226 c
405683 -2226 394334 2179 385974 10966 c
377613 19777 373420 32144 373420 48013 c
373420 64451 377660 77217 386116 86288 c
394571 95363 405564 99910 419041 99910 c
432115 99910 442797 95457 451064 86573 c
459353 77667 463501 65137 463501 49031 c
463501 48060 463454 46568 463407 44602 C
390521 44602 L
391137 33897 394192 25651 399643 19967 c
405091 14259 411912 11393 420060 11393 c
426123 11393 431334 13003 435597 16177 c
439884 19351 443319 24467 445829 31457 C
@c
391469 58245 m
446019 58221 L
445284 66440 443176 72622 439742 76719 c
434484 83091 427615 86288 419231 86288 c
411651 86288 405233 83730 400069 78662 c
394879 73569 391990 66748 391445 58221 C
391469 58245 L
@c
F
%CHAR: 471312 0 (l) @t
483368 0 m
483344 134870 L
499924 134870 L
499924 0 L
483368 0 L
@c
F
T
@rax %Note: Object
156.33184 175.77836 160.21587 193.70778 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
160.21587 175.77836 m
157.05383 181.43631 156.33184 187.48346 156.83357 193.70778 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
161.94586 172.68293 m
155.86384 177.36718 L
158.11540 177.47065 159.87515 178.45427 161.14337 180.31748 C
161.94586 172.68293 L
f
@J
@rax %Note: Object
186.77820 174.80296 192.64479 192.07956 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
192.64479 192.07956 m
192.61757 185.59814 190.27446 179.97676 186.77820 174.80296 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
192.65953 195.62570 m
195.65376 188.55694 L
193.64202 189.57345 191.62602 189.58195 189.60605 188.58246 C
192.65953 195.62570 L
f
@J
@rax %Note: Object
186.16592 209.22151 192.40214 235.74387 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
192.40214 209.22151 m
191.88510 218.80375 190.64098 227.74337 186.16592 235.74387 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
192.59320 205.68076 m
189.19332 212.56356 L
191.26091 211.66554 193.27380 211.77439 195.23254 212.88954 C
192.59320 205.68076 L
f
@J
@rax %Note: Object
155.67080 209.51518 161.90702 236.03754 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
155.67080 209.51518 m
156.18784 219.09742 157.43197 228.03704 161.90702 236.03754 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
155.47975 205.97443 m
152.84041 213.18321 L
154.79915 212.06806 156.81203 211.95921 158.87962 212.85723 C
155.47975 205.97443 L
f
@J
@rax %Note: Object
144.15562 373.91301 207.86598 412.83694 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
176.01080 373.91301 m
193.55613 373.91301 207.86598 382.65562 207.86598 393.37483 c
207.86598 404.09405 193.55613 412.83694 176.01080 412.83694 c
158.46548 412.83694 144.15562 404.09405 144.15562 393.37483 c
144.15562 382.65562 158.46548 373.91301 176.01080 373.91301 c
@c
S
@rax %Note: Object
150.30567 340.47241 165.34800 356.22709 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
150.30567 340.47241 m
165.34800 340.47241 L
165.34800 356.22709 L
150.30567 356.22709 L
150.30567 340.47241 L
@c
S
@rax 156.44183 343.54687 159.56362 350.82113 @E
[0.00009574 0.00000000 0.00000000 0.00009574 156.44178957 343.54681545] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 104370.00000 z
%CHAR: 0 0 (f) @t
9074 0 m
9060 46974 L
962 46974 L
962 54109 L
9060 54109 L
9060 59867 l
9060 63509 9385 66218 10037 67980 c
10910 70348 12464 72287 14685 73753 c
16905 75233 20044 75973 24041 75973 c
26619 75973 29491 75663 32615 75056 C
31238 67062 L
29343 67387 27522 67565 25832 67565 c
23049 67565 21080 66973 19925 65789 c
18771 64604 18178 62369 18178 59112 c
18178 54109 L
28736 54109 L
28736 46974 L
18178 46974 L
18178 0 L
9074 0 L
@c
F
T
@rax %Note: Object
185.39263 341.39906 200.43496 357.15373 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
185.39263 341.39906 m
200.43496 341.39906 L
200.43496 357.15373 L
185.39263 357.15373 L
185.39263 341.39906 L
@c
S
@rax 191.52879 344.45197 194.65994 351.74778 @E
[0.00009574 0.00000000 0.00000000 0.00009574 191.52874248 344.45185892] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 104680.00000 z
%CHAR: 0 0 (f) @t
9104 0 m
9089 47122 L
962 47122 L
962 54272 L
9089 54272 L
9089 60045 l
9089 63687 9415 66410 10066 68172 c
10940 70555 12509 72495 14729 73975 c
16965 75455 20103 76195 24115 76195 c
26708 76195 29580 75885 32703 75278 C
31327 67254 L
29432 67595 27611 67772 25906 67772 c
23123 67772 21139 67165 19984 65981 c
18830 64797 18238 62547 18238 59290 c
18238 54272 L
28825 54272 L
28825 47122 L
18238 47122 L
18238 0 L
9104 0 L
@c
F
T
@rax 158.32602 387.61228 195.64072 400.96517 @E
[0.00009574 0.00000000 0.00000000 0.00009574 158.32592826 387.83297677] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 188424.00000 z
%CHAR: 0 0 (B) @t
13809 0 m
13785 134870 L
64403 134870 l
74683 134870 82972 133496 89178 130772 c
95410 128048 100313 123832 103818 118172 c
107324 112511 109100 106566 109100 100360 c
109100 94605 107537 89154 104411 84086 c
101284 78993 96547 74872 90244 71746 C
98394 69377 104695 65280 109053 59524 c
113435 53768 115637 46947 115637 39084 c
115637 32783 114287 26883 111635 21483 c
108982 16059 105666 11866 101758 8929 c
97826 5992 92897 3742 86975 2250 c
81054 758 73783 0 65208 0 c
13809 0 L
@c
31646 78212 m
60803 78188 l
68714 78188 74398 78709 77833 79751 c
82357 81101 85791 83351 88065 86478 c
90362 89604 91523 93536 91523 98252 c
91523 102705 90433 106661 88302 110071 c
86170 113482 83091 115827 79112 117058 c
75133 118314 68288 118953 58600 118953 c
31646 118953 L
31646 78212 L
@c
31646 15916 m
65208 15893 l
70988 15893 75038 16130 77359 16556 c
81457 17267 84915 18522 87662 20227 c
90410 21933 92707 24443 94463 27712 c
96239 30980 97139 34797 97139 39084 c
97139 44105 95836 48510 93275 52205 c
90717 55900 87117 58529 82570 60021 c
77998 61514 71390 62271 62816 62271 c
31646 62271 L
31646 15916 L
@c
F
%CHAR: 125688 0 (G) @t
203331 52892 m
203331 68714 L
260463 68809 L
260463 18759 L
251699 11772 242652 6490 233343 2984 c
224011 -545 214416 -2321 204610 -2321 c
191370 -2321 179314 521 168514 6182 c
157690 11866 149492 20085 143997 30791 c
138478 41523 135707 53532 135707 66772 c
135707 79893 138454 92162 143926 103534 c
149421 114903 157334 123382 167614 128877 c
177917 134396 189807 137167 203236 137167 c
212995 137167 221832 135580 229696 132430 c
237559 129280 243765 124875 248218 119237 c
252694 113600 256129 106211 258450 97139 C
242344 92731 L
240331 99602 237796 105003 234812 108911 c
231804 112842 227493 115993 221927 118337 c
216334 120706 210129 121890 203331 121890 c
195183 121890 188102 120635 182180 118172 c
176235 115708 171427 112416 167780 108390 c
164132 104339 161266 99863 159253 95031 c
155839 86691 154110 77643 154110 67885 c
154110 55876 156195 45810 160319 37710 c
164440 29607 170480 23591 178391 19682 c
186302 15751 194710 13785 203592 13785 c
211313 13785 218892 15277 226238 18238 c
233580 21222 239194 24419 242983 27783 C
242983 52892 L
203331 52892 L
@c
F
%CHAR: 272256 0 (P) @t
286799 0 m
286775 134870 L
337654 134870 l
346607 134870 353452 134420 358165 133567 c
364797 132478 370366 130370 374819 127290 c
379296 124188 382919 119830 385643 114264 c
388367 108674 389741 102539 389741 95860 c
389741 84394 386093 74683 378798 66748 c
371503 58813 358284 54834 339217 54834 c
304637 54834 L
304637 0 L
286799 0 L
@c
304637 70751 m
339501 70751 l
351012 70751 359231 72906 364063 77170 c
368898 81457 371337 87520 371337 95315 c
371337 100952 369916 105784 367074 109787 c
364229 113814 360439 116466 355773 117745 c
352789 118551 347223 118953 339122 118953 c
304637 118953 L
304637 70751 L
@c
F
T
@rax %Note: Object
157.38548 356.14602 161.26951 374.07543 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
161.26951 374.07543 m
158.10746 368.41748 157.38548 362.37033 157.88721 356.14602 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
162.99950 377.17087 m
162.19701 369.53631 L
160.92879 371.39953 159.16904 372.38315 156.91748 372.48661 C
162.99950 377.17087 L
f
@J
@rax %Note: Object
187.83184 357.77424 193.69843 375.05083 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
193.69843 357.77424 m
193.67121 364.25565 191.32809 369.87704 187.83184 375.05083 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
193.71317 354.22809 m
190.65969 361.27134 L
192.67965 360.27184 194.69565 360.28035 196.70740 361.29685 C
193.71317 354.22809 L
f
@J
@rax %Note: Object
187.21956 314.10992 193.45578 340.63228 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
193.45578 340.63228 m
192.93874 331.05005 191.69461 322.11043 187.21956 314.10992 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
193.64683 344.17304 m
196.28617 336.96425 L
194.32743 338.07940 192.31455 338.18825 190.24696 337.29024 C
193.64683 344.17304 L
f
@J
@rax %Note: Object
156.72444 313.81625 162.96066 340.33861 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
156.72444 340.33861 m
157.24148 330.75638 158.48561 321.81676 162.96066 313.81625 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
156.53339 343.87937 m
159.93326 336.99657 L
157.86567 337.89458 155.85279 337.78573 153.89405 336.67058 C
156.53339 343.87937 L
f
@J
@rax %Note: Object
116.11531 294.66454 147.83074 294.66567 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
116.11531 294.66510 m
126.68712 294.66510 137.25893 294.66510 147.83074 294.66510 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
112.56917 294.66510 m
119.62517 297.68910 L
118.61717 295.67310 118.61717 293.65710 119.62517 291.64110 C
112.56917 294.66510 L
f
@J
@rax %Note: Object
116.11531 255.80353 147.97049 255.80466 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
116.11531 255.80409 m
126.73389 255.80409 137.35219 255.80409 147.97049 255.80409 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
151.51663 255.80409 m
144.46063 258.82809 L
145.46863 256.81209 145.46863 254.79609 144.46063 252.78009 C
151.51663 255.80409 L
f
@J
@rax %Note: Object
72.73020 255.29386 101.01288 264.48576 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
101.01288 255.66633 m
90.53603 255.29386 81.64772 256.94901 72.73020 264.48576 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
104.55676 255.79219 m
97.61272 252.51931 L
98.54844 254.56989 98.47672 256.58476 97.39786 258.56362 C
104.55676 255.79219 L
f
@J
@rax %Note: Object
72.83934 286.43357 101.03329 296.55014 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
72.83934 286.43357 m
81.18510 292.77808 89.40161 296.55014 101.03329 295.53307 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
70.01631 284.28746 m
73.80340 290.96504 L
74.22094 288.75005 75.44098 287.14507 77.46350 286.15039 C
70.01631 284.28746 L
f
@J
@rax %Note: Object
518.84844 231.84850 582.55880 270.77244 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
550.70362 270.77244 m
533.15830 270.77244 518.84844 262.02983 518.84844 251.31033 c
518.84844 240.59112 533.15830 231.84850 550.70362 231.84850 c
568.24894 231.84850 582.55880 240.59112 582.55880 251.31033 c
582.55880 262.02983 568.24894 270.77244 550.70362 270.77244 c
@c
S
@rax %Note: Object
480.54926 263.43581 495.59159 279.19049 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
495.59159 279.19049 m
480.54926 279.19049 L
480.54926 263.43581 L
495.59159 263.43581 L
495.59159 279.19049 L
@c
S
@rax 486.33335 268.84148 489.45515 276.11603 @E
[0.00009574 0.00000000 0.00000000 0.00009574 486.33329669 268.84159203] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 104370.00000 z
%CHAR: 0 0 (f) @t
9074 0 m
9060 46974 L
962 46974 L
962 54109 L
9060 54109 L
9060 59867 l
9060 63509 9385 66218 10037 67980 c
10910 70348 12464 72287 14685 73753 c
16905 75233 20044 75973 24041 75973 c
26619 75973 29491 75663 32615 75056 C
31238 67062 L
29343 67387 27522 67565 25832 67565 c
23049 67565 21080 66973 19925 65789 c
18771 64604 18178 62369 18178 59112 c
18178 54109 L
28736 54109 L
28736 46974 L
18178 46974 L
18178 0 L
9074 0 L
@c
F
T
@rax 486.33335 268.84148 489.45515 276.11603 @E
[0.00009574 0.00000000 0.00000000 0.00009574 486.33329669 268.84159203] @tm
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.21600 0.21600 0.00000 @w
r
% FontChange:/_Arial 104370.00000 z
%CHAR: 0 0 (f) @t
9074 0 m
9060 46974 L
962 46974 L
962 54109 L
9060 54109 L
9060 59867 l
9060 63509 9385 66218 10037 67980 c
10910 70348 12464 72287 14685 73753 c
16905 75233 20044 75973 24041 75973 c
26619 75973 29491 75663 32615 75056 C
31238 67062 L
29343 67387 27522 67565 25832 67565 c
23049 67565 21080 66973 19925 65789 c
18771 64604 18178 62369 18178 59112 c
18178 54109 L
28736 54109 L
28736 46974 L
18178 46974 L
18178 0 L
9074 0 L
@c
S
T
@rax %Note: Object
480.54926 224.51187 495.59159 240.26655 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
495.59159 240.26655 m
480.54926 240.26655 L
480.54926 224.51187 L
495.59159 224.51187 L
495.59159 240.26655 L
@c
S
@rax 486.03090 229.03483 489.16205 236.33065 @E
[-0.00009574 0.00000000 0.00000000 0.00009574 489.16206920 229.03471317] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 104680.00000 z
%CHAR: 0 0 (f) @t
9104 0 m
9089 47122 L
962 47122 L
962 54272 L
9089 54272 L
9089 60045 l
9089 63687 9415 66410 10066 68172 c
10940 70555 12509 72495 14729 73975 c
16965 75455 20103 76195 24115 76195 c
26708 76195 29580 75885 32703 75278 C
31327 67254 L
29432 67595 27611 67772 25906 67772 c
23123 67772 21139 67165 19984 65981 c
18830 64797 18238 62547 18238 59290 c
18238 54272 L
28825 54272 L
28825 47122 L
18238 47122 L
18238 0 L
9104 0 L
@c
F
T
@rax 486.03090 229.03483 489.16205 236.33065 @E
[0.00009574 0.00000000 0.00000000 0.00009574 486.03084000 229.03471317] @tm
0 O 0 @g
0.00 0.00 0.00 1.00 k
e
% FontChange:/_Arial 104680.00000 z
%CHAR: 0 0 (f) @t
9104 0 m
9089 47122 L
962 47122 L
962 54272 L
9089 54272 L
9089 60045 l
9089 63687 9415 66410 10066 68172 c
10940 70555 12509 72495 14729 73975 c
16965 75455 20103 76195 24115 76195 c
26708 76195 29580 75885 32703 75278 C
31327 67254 L
29432 67595 27611 67772 25906 67772 c
23123 67772 21139 67165 19984 65981 c
18830 64797 18238 62547 18238 59290 c
18238 54272 L
28825 54272 L
28825 47122 L
18238 47122 L
18238 0 L
9104 0 L
@c
F
T
@rax %Note: Object
450.37474 270.87080 480.71480 270.87194 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
480.71480 270.87137 m
470.60135 270.87137 460.48819 270.87137 450.37474 270.87137 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
446.82860 270.87137 m
453.88460 267.84737 L
452.87660 269.86337 452.87660 271.87937 453.88460 273.89537 C
446.82860 270.87137 L
f
@J
@rax %Note: Object
378.82743 272.41370 404.45915 272.41398 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
404.45915 272.41398 m
395.91524 272.41370 387.37134 272.41370 378.82743 272.41370 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
375.28129 272.41370 m
382.33729 269.38970 L
381.32929 271.40570 381.32929 273.42170 382.33729 275.43770 C
375.28129 272.41370 L
f
@J
@rax %Note: Object
202.21795 251.00362 284.23559 269.60060 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
284.23559 251.00362 m
270.50513 269.60060 234.56976 264.83471 202.21795 265.88239 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
198.67380 265.99691 m
205.62831 262.74614 L
204.68608 264.79361 204.75128 266.80876 205.82391 268.79102 C
198.67380 265.99691 L
f
@J
@rax %Note: Object
449.83956 232.00980 480.71480 232.01093 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
480.71480 232.01036 m
470.42277 232.01036 460.13131 232.01036 449.83956 232.01036 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
484.26094 232.01036 m
477.20494 228.98636 L
478.21294 231.00236 478.21294 233.01836 477.20494 235.03436 C
484.26094 232.01036 L
f
@J
@rax %Note: Object
495.81723 231.50013 524.09991 240.69203 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
495.81723 231.87260 m
506.29408 231.50013 515.18239 233.15528 524.09991 240.69203 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
526.80813 242.98101 m
519.46696 240.73597 L
521.53824 239.84702 522.83962 238.30724 523.37112 236.11663 C
526.80813 242.98101 L
f
@J
@rax %Note: Object
495.79682 262.63984 523.99077 272.75641 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
523.99077 262.63984 m
515.64501 268.98435 507.42850 272.75641 495.79682 271.73934 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
492.26428 271.43065 m
499.55698 269.03282 L
498.37720 270.95329 498.20145 272.96164 499.03002 275.05786 C
492.26428 271.43065 L
f
@J
@rax %Note: Object
202.30639 308.22151 221.73250 326.40208 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
202.30639 308.22151 m
206.36674 313.24309 208.30932 321.67701 221.73250 326.40208 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
200.07694 305.46397 m
202.16183 312.85219 L
203.09584 310.80076 204.66340 309.53310 206.86479 309.04951 C
200.07694 305.46397 L
f
@J
@rax %Note: Object
202.30639 283.71713 251.65899 310.32935 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
202.30639 283.71713 m
223.93077 288.26050 239.49468 297.87307 251.65899 310.32935 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
254.13647 312.86636 m
247.04306 309.93109 L
249.18973 309.24369 250.63200 307.83515 251.37014 305.70548 C
254.13647 312.86636 L
f
@J
@rax %Note: Object
234.59556 337.20520 256.90932 351.69704 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
234.59556 337.20520 m
239.96381 345.49795 246.81005 351.31776 256.90932 351.69704 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
232.66857 334.22854 m
233.96428 341.79506 L
235.10891 339.85332 236.80148 338.75773 239.04142 338.50857 C
232.66857 334.22854 L
f
@J
@rax %Note: Object
260.05946 317.97071 282.37323 340.63058 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
260.05946 317.97071 m
269.71455 323.29843 277.44775 330.55512 282.37323 340.63058 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
283.93058 343.81644 m
278.11502 338.80535 L
280.36885 338.82576 282.17991 337.94022 283.54847 336.14929 C
283.93058 343.81644 L
f
@J
@rax %Note: Object
248.68148 226.69200 287.32762 239.99924 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
287.32762 239.99924 m
279.29424 232.91178 269.32167 228.01946 248.68148 226.69200 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
289.98680 242.34520 m
286.69635 235.40939 L
286.11836 237.58809 284.78466 239.09981 282.69496 239.94482 C
289.98680 242.34520 L
f
@J
@rax %Note: Object
202.30639 226.69200 233.44753 244.72120 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
233.44753 226.69200 m
221.54258 228.51865 210.95915 233.97080 202.30639 244.72120 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
236.95257 226.15427 m
229.51956 224.23550 L
230.82151 226.07518 231.12737 228.06794 230.43685 230.21348 C
236.95257 226.15427 L
f
@J
@rax %Note: Object
340.91376 259.21304 363.22753 272.12372 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
340.91376 259.21304 m
346.87361 266.48391 354.11471 271.18290 363.22753 272.12372 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
338.66589 256.47052 m
340.80009 263.84457 L
341.72022 261.78690 343.27956 260.50904 345.47754 260.01043 C
338.66589 256.47052 L
f
@J
@rax %Note: Object
346.74633 225.84472 403.75928 242.78428 @E
0 J 0 j [] 0 d 0 R 0 @G
0.00 0.00 0.00 1.00 K
0 0.72000 0.72000 0.00000 @w
346.74633 242.78428 m
360.65537 232.21843 381.47924 225.84472 403.75928 228.17792 C
S
@j
0.00 0.00 0.00 1.00 K
0.00 0.00 0.00 1.00 k
0 @g
0 @G
[] 0 d 0 J 0 j
0 R 0 O
0 1.00800 1.00800 0 @w
407.28614 228.54699 m
399.95348 230.81953 L
401.16614 228.91946 401.37591 226.91452 400.58334 224.80441 C
407.28614 228.54699 L
f
@J
%%PageTrailer
@rs
@rs
%%Trailer
@EndSysCorelDict
end
%%DocumentSuppliedResources: procset wCorel6Dict
%%EOF
bird2-2.17.5/doc/slides/slides.tex 0000664 0000000 0000000 00000010425 15211753245 0016654 0 ustar 00root root 0000000 0000000 \input epsf.tex
\language=\czech
\chyph
\hsize=170mm
\vsize=250mm
\nopagenumbers
\font\srm=csss12 scaled \magstep3
\font\stit=csb12 scaled \magstep3
\font\sem=csssbx12 scaled \magstep3
\font\sit=csssi12 scaled \magstep3
\font\stt=cstt12 scaled \magstep3
\font\stitle=cscsc12 scaled \magstep4
\baselineskip=25pt
\lineskip=2.1pt
\parindent=0pt
\parskip=4pt
\def\em#1{{\emfont #1}}
\srm
\font\rmfont=cmr10 scaled \magstep4
\font\ttfont=cmtt10 scaled \magstep4
\font\ifont=cmmi10 scaled \magstep4
\font\symfont=cmsy10 scaled \magstep4
\font\exfont=cmex10 scaled \magstep4
\font\rmfonts=cmr7 scaled \magstep4
\font\ifonts=cmmi7 scaled \magstep4
\font\symfonts=cmsy7 scaled \magstep4
\font\exfonts=cmex7 scaled \magstep4
\textfont0=\rmfont
\textfont1=\ifont
\textfont2=\symfont
\textfont3=\exfont
\scriptfont0=\rmfonts
\scriptfont1=\ifonts
\scriptfont2=\symfonts
\scriptfont3=\exfonts
\newbox\birdbox
{\epsfxsize=2em\global\setbox\birdbox=\hbox{\epsfbox{logo.eps}}}
\def\slide#1{\begingroup
\ifx:#1:\else
\line{\vrule width 0pt height 25pt depth 4pt \stit #1\hfill\smash{\lower1ex\copy\birdbox}}
\medskip
\hrule height 2pt
\bigskip
\fi
}
\def\endslide{\vfill\eject\endgroup}
\def\\{\hfil\break}
\def\itemize#1{\par{\advance\leftskip by 35pt{\parskip=5pt #1}\par}}
\def\:{\par\leavevmode\llap{$\bullet$\hskip 7pt}}
\def\>{\par\leavevmode\llap{$\circ$\hskip 7pt}}
\slide{}
\vglue 1in
\centerline{\epsfxsize=0.6\hsize\epsfbox{logo.eps}}
\centerline{\vbox{\offinterlineskip\halign{#\cr
\stitle Bird Internet Routing Daemon\cr
\noalign{\medskip}%
\leaders\hrule height 2pt\hfil\cr}}}
\vskip 0.5in
\centerline{\vbox{\sit\halign{\hfil # & # \hfil \cr
Vedouc: & RNDr. Libor Forst \cr
Tm: & Ondej Filip, Pavel Machek, Martin Mare \cr
Home: & http:/\kern-0.2em/bird.network.cz/ \cr
E-mail: & bird@bird.network.cz \cr}}}
\endslide
\slide{Propojovn st a routing}
\medskip
\centerline{\epsfxsize=0.9\hsize\epsfbox{obr1.eps}}
\endslide
\slide{St jsou pli velk $\Rightarrow$ Autonomn systmy}
\medskip
\centerline{\epsfxsize=0.9\hsize\epsfbox{obr2.eps}}
\endslide
\slide{Cle projektu}
\itemize{
\:podpora vech bnch routovacch protokol\\a snadn pidvn novch
\:IPv4 i IPv6
\:vmna dat mezi rznmi protokoly
\:policy routing
\:snadn konfigurace a drba
\:kvalitn dokumentace
\:minimln zvislost na pouitm OS
}
\endslide
\slide{Implementovan protokoly}
\itemize{
\:RIP v2 (Routing Information Protocol)
\itemize{
\>intern protokol
\>distance vector (Bellman-Ford)
\>pomal konvergence, omezen prmru st
\>IPv4 i IPv6
}
\:OSPF v2 (Open Shortest Path First)
\itemize{
\>intern protokol
\>link state algorithm (Dijkstra)
\>rychl konvergence, ale velmi sloit
\>zatm pouze IPv4
}
\:BGP v4 (Border Gateway Protocol)
\itemize{
\>extern protokol (jedin dnes pouvan)
\>path vector
\>rychl konvergence, neomezen filtrace
\>IPv4 i IPv6
}
}
\endslide
\slide{Propojen protokol}
\medskip
\centerline{\epsfxsize=0.9\hsize\epsfbox{obr5.eps}}
\endslide
\slide{Sprva routeru}
\itemize{
\:konfiguran soubory a on-line rekonfigurace:
\medskip
{\stt\advance\leftskip by 1cm
protocol ospf \char123 \\
\hbox{}~~~area 0 \char123\ interface "eth*"; \char125; \\
\hbox{}~~~export where source=RTS\char95STATIC; \\
\hbox{}~~~import all; \\
\char125
\medskip
}
\:filtry: jednoduch procedurln jazyk
\:logovn udlost a tracing protokol
\:dlkov ovldn
\:jednoduch client
}
\endslide
\slide{Architektura}
\itemize{
\:modulrn architektura se striktnm rozdlenm\\kompetenc:
\itemize{
\>jdro
\>protokoly
\>filtry
\>knihovny
}
\:oddlen platformn zvislho kdu
\:vlastn datov typy: pesn integery, IP adresy, \dots
\:zen udlostmi
\:``chytr'' datov struktury
}
\bigskip
Platformy:
\itemize{
\:Zatm pouze Linux 2.0, Linux 2.1--2.4
\:sten port na FreeBSD
}
\endslide
\slide{Testovn}
``Laboratorn'' testy:
\itemize{
\:testovac s na~MFF: 3 potae a router Cisco 7000
\:test zte (BGP, pten tabulka s~$72\,000$ polokami)
\:test spoluprce (Cisco, GateD, Cyclades)
\:test portability: Linux 2.0--2.4; i386, Sparc, M680x0
}
\bigskip
``Real world'' testy -- praktick pouit:
\itemize{
\:nasazen ve~firm Ipex (s s~cca 1000 potai)
\:distribuovno veejn pod GPL:
\itemize{
\>236 download, 2244 shldnut strnek (k~26. 6.)
\>kladn ohlasy (zejmna na konfiguraci)
\>5 bug report, vyeeny
}
}
\endslide
\end
bird2-2.17.5/doc/slt2001/ 0000775 0000000 0000000 00000000000 15211753245 0014467 5 ustar 00root root 0000000 0000000 bird2-2.17.5/doc/slt2001/Makefile 0000664 0000000 0000000 00000000232 15211753245 0016124 0 ustar 00root root 0000000 0000000 all: slt.dvi
slt.dvi: slt.tex
csplain slt.tex
slt.ps: slt.dvi
dvips -o slt.ps -D600 -ta4 slt.dvi
clean:
rm -f *~ *.log *.tfm *.*pk *.*gf *.ps *.dvi
bird2-2.17.5/doc/slt2001/slt.tex 0000664 0000000 0000000 00000032234 15211753245 0016017 0 ustar 00root root 0000000 0000000 \magnification=\magstep1
\input epsf.tex
\input mjmac.tex
\language=\czech
\chyph
\hsize=160truemm % A4 with 25mm margins
\vsize=247truemm
\parindent=2em
\nopagenumbers
\def\hdr#1{\medskip\leftline{\bf #1}\smallskip}
\def\\{\hfil\break}
\def\BIRD{{\sc Bird}}
\def\inititemize{\vskip 1pt\begingroup
\parskip=1pt plus 0.3pt minus 0.1pt
\advance\leftskip by 3em
\advance\rightskip by 3em
\parindent=0pt
}
%%% vod a historie projektu
\hdr{Na potku bylo vejce aneb vodem}
\noindent Internet i UNIX jsou na svt ji pknch pr ptk. Potae pracujc
pod nepebernm mnostvm unixovskch systm od nepamti funguj jako
internetov potovn servery, name-servery a men routery. Skoro by se zdlo, e
si tyto dva svty u nemaj co novho ci. V~poslednch letech ovem
vrazn vzrostl vkon bnch PC-ek a objevily se pro n karty podporujc
nejrznj sov technologie, a~tak se tyto potae staly vhodnmi
kandidty i~pro funkci router. Na~mnoha mstech tak star PC-ko
s~voln iitelnm softwarem pedstihlo svho starho a draho
komernho sourozence. Akoliv podpora routingu, firewallingu a inteligentn
queue management v~jdrech tchto~OS (a~zejmna Linuxu) je ji velice
vyspl, jet nedvno byly notn zanedbvny protokoly pro dynamick
routing, tradin unixovskou koncepc umstn do~uivatelskho prostoru
v~podob routovacch daemon.
Tento nedostatek se pokouela mezi jinmi napravit tak skupina nadenc
na~prask Matematicko-fyzikln fakult UK, kter se rozhodla jako svj
studijn projekt vytvoit novho routovacho daemona, kter by se stal
nm vc ne jen dstojnm konkurentem komernch router -- nejen
koproval u znm een, ale tak pispl nm novm; na~jedn stran
bt stabilnm a efektivnm programem pro praxi, na~stran druh ovem
i~laborato pro snadn experimentovn s~novmi mylenkami. A~tak se
narodil projekt {\it BIRD Internet Routing Daemon} (zkrcen \BIRD\footnote{$^0$}{Projekt
si samozejm vyslouil nejrznj pezdvky -- od Ptete a po~Ptkovinu.}).
Pvodn plny byly sml a rozhodn: Vytvoit nejlepho routovacho
daemona na svt, kter by fungoval na~vech platformch, vyadoval
minimum strojovho asu a pamti, podporoval vechny routovac protokoly
atd., zkrtka sen, jak m bt. Peskome nyn dva roky vvoje\footnote{$^1$}{bhem nich
z~nkterch poadavk samozejm selo -- napklad logem projektu
se nakonec nestal ptek nesouc v~zobku sntku byliny een routa \dots}
a podvejme se, co z~toho vzelo.
%%% Svt routingu
%% v~titn verzi peskome
%%% Co BIRD doke
\hdr{Kdy ptka lapaj, pkn mu zpvaj aneb Feature list}
\noindent \BIRD\ dostal od svch sudiek do~vnku mnoh dary:
\def\icirc{\raise0.2ex\hbox{$\circ$}} % Signs frequently used for \itemize
\itemize\ibull
\:Schopnost komunikovat protokoly IPv4 i IPv6.
\:Podporu vech zkladnch routovacch protokol:
\itemize\icirc
\:RIPv2 (Routing Information Protocol, viz RFC 1723 a 2080)\\
Uren pro intern routing, dnes vznamu spe historickho.\\
Algoritmus: distance vector (Bellman-Ford).\\
Velmi pomal konvergence, pouitel pouze pro malik st.
\:OSPFv2 (Open Shortest Path First, viz RFC 2328)\\
Uren pro intern routing, v~souasn dob asi nejbnj.\\
Algoritmus: link state (Dijkstra).\\
Rychl konvergence, ale velice komplikovan.\\
Zatm podporujeme pouze pro IPv4.
\:BGP4 (Border Gateway Protocol, viz RFC 1771 a 2283)\\
Standardn protokol pro extern routing mezi AS.\\
Rychl konvergence, monost administrativn filtrace.\\
Algoritmus: path vector (upraven Bellman-Ford).
\endlist
\:Propojovn protokol a vmnu dat mezi nimi.
\:Schopnost uplatovat routing policy -- urovat, kter routovac informace
budou od~kterch protokol pijmny a do~kterch protokol vyslny.
\:Snadnou konfiguraci a drbu, ale o~tom a pozdji.
\:Modulrn architekturu umoujc snadn doplovn novch protokol,
filtr i jednoduch portovn na~dal systmy. (Interface k~routovacm
slubm jdra je bohuel i mezi jednotlivmi unixovskmi systmy natolik
rznorod, e dokonce i~Linux 2.0 a Linux 2.2 jsou naprogramovny jako dva
odlin porty.)
\:A v~neposledn ad kvalitn dokumentaci jak uivatelskou, tak
programtorskou (to je vtan dsledek byt kolnm projektem).
\endlist
%%% A jak to vechno propojit
\hdr{Svt z~pta perspektivy aneb Jak to vechno dt dohromady?}
\noindent Hlavnm problmem ovem nen ani tak vechny tyto vymoenosti naprogramovat
a popropojovat, nbr udlat to tak, aby z~toho nevznikl neudrovateln
a neefektivn zmatek\footnote{$^2$}{Ndhernm pkladem je Mendelv pes,
jak ho kdysi nakreslil pan Kantorek.}. Z~toho se zrodil modulrn pohled
na~svt routingu a nsledn i cel modulrn architektura programu:
\bigskip
\centerline{\epsfxsize=0.9\hsize\epsfbox{../slides/obr5.eps}}
\medskip
Zkladem pohledu na~Internet z~na \uv{pta perspektivy} je routovac
tabulka. Na~n jsou pipojeny jednotliv routovac protokoly -- jak
protokoly reln, tak i nkolik virtulnch, jako je napklad protokol
Kernel zajiujc synchronizaci tabulky s~tabulkou jdra nebo protokol
Static generujc podle sv konfigurace statick smrovn. Kad z~protokol
posl do~tabulky poloky pro vechny routy, kter se na~zklad svch informac
o~topologii st dozvd. Tabulka pro kadou s vybr na zklad preferenc
jednotlivch protokol a jejich metrik optimln smr a ten oznamuje
zpt protokolm. V~cest ovem v~obou smrech stoj filtry, kter mohou
tok dat regulovat -- nkter poloky odmtat, jin upravovat (napklad
jim penastavovat metriky i tagy; to se dokonce vztahuje i~na
atributy doplovan clovm protokolem, protoe nejprve clov protokol
nastav implicitn hodnoty svch atribut, pokud je ji poloka neobsahovala,
a teprve pak dojde k~filtrovn).
Routovacch tabulek me dokonce existovat vcero a pomoc protokolu Pipe
si mohou peposlat vybran poloky. Tm meme zajistit napklad
routing zvisl na~zdrojov adrese i vstupnm interfacu: u~Linuxu 2.2
i novjho nakonfigurujeme jdru vce routovacch tabulek a kadou
z~nich pipojme na~jednu tabulku nai.
\hdr{Pta zpv aneb User interface}
%%% User interface: konfigurace, logging a filtry. Remote control.
\noindent S se mn a s~n se mus mnit i konfigurace sovch
komponent. Ta se pozvolna stala tradinm kamenem razu vtiny router.
U~tohoto kamene se toti schzej dva odvc neptel:
snaha o~snadnost a flexibilitu konfigurace a snaha o~nepetrit
provoz st. A~jednou slev ten, podruh onen -- autoi nkterch
router vsadili na~slu textovch konfiguranch soubor za~cenu
toho, e se po~kad zmn konfigurace mus router restartovat
a po~njakou dobu neroutuje, jin zase poddili non-stop provozu
ve ostatn a stvoili konfigurovn nepebernm mnostvm online
pkaz, pomoc nich se nkter vci provdj snadno, jin,
na~kter autoi speciln pkaz nevymysleli, u obtnji a jet jin
vyaduj do~vslednho stavu dospt postupnm provedenm mnoha zmn,
co m obvykle za~dsledek daleko del vpadek ne jak by byl vznikl
reloadem celho routeru.
\BIRD\ se sna doshnout obojho: pouv textov konfiguran soubory,
uivateli tak dv monost vytvet konfiguraci vcemn libovolnm
zpsobem -- a ji runm editovnm, interaktivnmi programy i
automatickm generovnm pomoc script. Po~zmn konfigurace je
ovem schopen si novou verzi souboru pest, porovnat s~prv
pouvanou konfigurac a zmnm se za bhu pzpsobit (pokud
jsou zmny pli velk, me to zpsobit restart
nkterho z~protokol, ale provoz tch, kterch se zmna
netkala, to nijak neohroz).
Konfigurace kadho protokolu (lpe eeno kad jeho instance --
protokoly mohou bt sputny nkolikrt na~rznch rozhranch
i nad rznmi tabulkami) vypad piblin takto:
\verbatim{ protocol bgp TestBGP { # instanci si meme nazvat
local as 65000; # n AS
neighbor 195.39.3.64 as 5588; # sousedn AS
export all; # poslat budeme vechno
import filter { # na vstupu nkter odmtneme
if !(bgp_path ~ / ? 5588 ? /) then reject;
if net ~ [ 10.0.0.0/8+, 192.168.0.0/16+ ] then reject;
preference = 101; # zbylm nastavme preferenci
accept; # a pijmeme je
};
}}
\noindent Vdy popisuje protokol, jeho parametry, pipojen k~tabulkm
(v~naem ppad pouvme tabulku implicitn) a nastaven vstupnch
i~vstupnch filtr.
Filtry jsou popisovny jednoduchm procedurlnm programovacm jazykem,
kter m k~dispozici vechny informace o~prv zpracovvan poloce, me
se podle nich rozhodovat a libovoln je mnit. Dky tomu je mon jednodue
zadvat i velice sloit pravidla, definovat si podprogramy sdlen
filtry patcmi k~vce protokolm, i~potat metriky pro jeden protokol
na zklad metrik protokol ostatnch.
Vtanm pomocnkem pi odhalovn problm v~stch je rovn voliteln
logovn dleitch udlost a trasovn innosti protokol: zde si je
mono pro kad protokol vydat prakticky cokoliv ponaje zkladnmi informacemi o~bhu
protokolu (pipojovn a odpojovn soused apod.), pes vmnu poloek
mezi protokolem, filtry a jeho tabulkou, a kone detailnm vpisem vech
pijatch i odeslanch paket.
Mimo to \BIRD\ disponuje \uv{dlkovm ovldnm} -- jednoduchm pkazovm
rozhranm, pes kter se mohou pipojovat rzn klienti a vydvat jak
nkter dc pkazy (restarty protokol, reload konfigurace, pepnn
trasovn, \dots), tak poadavky na~vypisovn stavu routovacch tabulek
a protokol. U~tchto pkaz je mono vyuvat pln sly filtrovacho
jazyka, take chceme-li napklad znt vechny routy smrovan pomoc
BGP na jednoho konkrtnho souseda, sta poloit dotaz typu
\verbatim{ bird> show route where source=RTS_BGP && gw=62.168.0.1}
\noindent a dozvme se ihned ve, co jsme potebovali. Ladn filtr
navc usnadn i~to, e se meme zeptat na~obsah routovac tabulky
z~pohledu nkterho z~bcch protokol.
%%% BIRD uvnit
%\hdr{Pta anatomie}
%% existuje progdoc
%%% Netradicni pouziti
\hdr{Cesty tanch ptk aneb Za hranicemi vednch dn}
\noindent Hotov modulrn implementace routovacho daemona samozejm
svd i k~mn tradinmu vyuit. Zde se fantazii meze nekladou, autory
sam bhem vvoje napadly napklad tyto triky:
\itemize\ibull
\:{\I multirouter} -- \uv{schizofrenn} zazen pracujc na rznch
skupinch interfac jako rzn routery dc se rznmi pravidly,
lec teba i v~rznch autonomnch systmech. To je mono zadit
patinm nastavenm jdra a buto vce bcmi \BIRD{}y nebo dokonce
jednm pracujcm s~nkolika rznmi routovacmi tabulkami. Tak by
mohl napklad cel prask NIX bet na jedinm routeru (pravda,
bn PC by na to nestalo), a pesto by si kad provider mohl sm
urovat a konfigurovat svou vlastn routovac politiku.
\:{\I ed eminence} -- \BIRD\ by ani nemusel bet pmo na~stroji, kter
pakety routuje, mohl by tak hotov routovac tabulky diktovat
njakmu dedikovanmu routeru disponujcm vkonnjm hardwarem,
a tak skloubit pikovou propustnost \uv{velkho eleza}
s~flexibilitou routeru becho pod unixovskm systmem.
\:{\I inteligentn mirror} -- aplikace se nemus zastavovat u~routingu
jako takovho, mnohdy je mono informace zskan z~provozu routeru
vyuvat k~dalm elm, napklad k~inteligentnmu pesmrovvn
klient na~nejbli mirror vaeho archivu.
\endlist
%%% A co dal?
\hdr{as ptat aneb Co dl?}
Pestoe po~spnm obhjen projektu a prvnch nkolika destkch
spokojench uivatel (a samozejm i~pr opravench chybch) nyn vvoj
spe stagnuje, autoi ji spdaj plny do~budoucnosti, kter
by mly \BIRD{}ovi pinst mimo jin tak routovn multicast, agregaci
sovch prefix, OSPFv3 pro IPv6, on-demand linky a porty na~dal systmy.
%%% Reference na ns a ostatn routery
\hdr{Snka odkaz na zvr}
\noindent {\sc Bird Team} pod vedenm RNDr. Libora Forsta ({\I forst@cuni.cz}) tvoili:
$$\vbox{\halign{#\hfil & \quad \it # \hfil & \quad \it # \hfil\cr
Ondej Filip&feela@ipex.cz&http:/$\!$/feela.ipex.cz/\cr
Martin Mare&mj@ucw.cz&http:/$\!$/atrey.karlin.mff.cuni.cz/\char126mj/\cr
Pavel Machek&pavel@ucw.cz&http:/$\!$/atrey.karlin.mff.cuni.cz/\char126pavel/\cr}}$$
Domc strnku projektu najdete na {\it http:/$\!$/bird.network.cz/,} odtamtud ji
vedou odkazy na~aktuln verzi, online dokumentaci i mailing list
uivatel.
Vechna zmiovan RFC i mnoho dalch naleznete na {\it http:/$\!$/www.rfc-editor.org/},
prvn mylenky o~vyuvn ptactva v~Internetu sahaj a k~RFC~1149.
\BIRD\ nen na~svt sm, m i~pbuzn; mezi nimi za zmnku stoj
daemoni {\sc GateD} ({\I http:/$\!$/www.gated.org/}), \hbox{\sc Zebra} ({\I http:/$\!$/www.zebra.org/})
a {\sc Mrtd} ({\I http:/$\!$/www.mrtd.net/}).
O~IPv6 se bohuel zatm jen pe, na~jeho celointernetov nasazen se stle
ek a mezitm pibv address-translator a dalch zvrstev. Snad jedin
vt s pouvajc tento protokol je experimentln virtuln s 6-bone
(viz {\it http:/$\!$/www.6bone.net/} a odkazy odtamtud).
Dotazy a pipomnky poslejte buto autorovi nebo celmu {\sc Bird Team}u na~adresu
{\I bird@bird.network.cz}.
\bye
bird2-2.17.5/doc/tex/ 0000775 0000000 0000000 00000000000 15211753245 0014162 5 ustar 00root root 0000000 0000000 bird2-2.17.5/doc/tex/birddoc.sty 0000664 0000000 0000000 00000007533 15211753245 0016341 0 ustar 00root root 0000000 0000000 %% This is a LaTeX style file for typesetting BIRD documentation.
%% Hacked up by Martin Mares
%%
%% This is a modified version of linuxdoc-qwertz.sty, for use with SGML-generated LaTeX
%% by Matt Welsh (mdw@sunsite.unc.edu)
%%
%% Based on linuxdoc.sty by Michael K. Johnson, and latex.tex by
%% Leslie Lamport.
\NeedsTeXFormat{LaTeX2e}
\ProvidesClass{birddoc}
%%% GLOBAL LAYOUT THINGS
\marginparwidth 0.0 in
\parindent=0 in
\parskip=0.5ex
%\parindent=0.5in
%\parskip=0pt
\topmargin -0.5 in
\setlength{\textheight}{\paperheight}
\addtolength{\textheight}{-2 in}
%\advance\headsep 2 ex
\advance\textheight -2 ex
%\renewcommand{\baselinestretch}{1.14}
\setcounter{tocdepth}{1}
\oddsidemargin 0.15 in
\evensidemargin -0.35 in
\textwidth 6.5in
\def\ps@headings{\let\@mkboth\markboth
\def\@oddfoot{}\def\@evenfoot{}% No feet.
\def\@evenhead{\protect\rule[-4pt]{\textwidth}{.5pt}\kern-\textwidth
\rm \thepage\hfil \bf \leftmark} % Left heading.
\def\@oddhead{\protect\rule[-4pt]{\textwidth}{.5pt}\kern-\textwidth
{\bf \rightmark}\hfil \rm\thepage} % Right heading.
\def\chaptermark##1{\markboth {{\ifnum \c@secnumdepth >\m@ne
\@chapapp\ \thechapter. \ \fi ##1}}{}}%
\def\sectionmark##1{\markright {{\ifnum \c@secnumdepth >\z@
\thesection. \ \fi ##1}}}}
\def\@makechapterhead#1{%
{\parindent \z@ \raggedright \normalfont
\huge \bfseries \@chapapp\space\thechapter: #1\par\nobreak
\vskip 20\p@
}}
\def\@makeschapterhead#1{%
{\parindent \z@ \raggedright \normalfont
\huge \bfseries #1\par\nobreak
\vskip 20\p@
}}
%% Titlepage stuff
\gdef\@title{}
\gdef\title#1{\gdef\@title{#1}}
\gdef\@date{}
\gdef\date#1{\gdef\@date{#1}}
\gdef\@author{}
\gdef\author#1{\gdef\@author{#1}}
\gdef\@abstract{}
\gdef\abstract#1{\gdef\@abstract{#1}}
\def\maketitle{\thispagestyle{empty}\let\footnotesize\small%
\let\footnoterule\relax
%\setcounter{page}{0}%
%\null
%\vskip 3 in
\noindent
{\huge\sf \@title}\\
\rule{\textwidth}{1mm}\\
\mbox{}\@author\ \hfill \@date\ \\
\vskip 1 ex
\noindent{\sf \@abstract}
\setcounter{footnote}{0}%
\gdef\@author{}\gdef\@title{}\gdef\@years{}\gdef\@abstract{}
\let\maketitle\relax}
\def\birdnarrow{\advance\@totalleftmargin by 0.5in}
%% Needs to be here for the previous ps@headings defs to work.
\pagestyle{headings}
\def\progdoc{
\raggedbottom
}
%%% USEFUL MACROS
\newcommand{\linux}{Linux} % Always use this when
% refering to the \linux\
% operating system, like that.
\newcommand{\key}[1]{{\fbox{\small\tt #1}}} % Use this to mark keys, like
% \key{del} for the delete key.
\newcommand{\ret}{\fbox{\sf return}} % Special case for the return key.
\newcommand{\st}{\small\tt} % Small typewriter -- comes in handy.
%\newcommand{\lb}{{\tt\char '173}} % Left Brace '{'
%\newcommand{\rb}{{\tt\char '175}} % Right Brace '}'
\newcommand{\lbr}{$\langle$} % Left Bracket '<'
\newcommand{\rbr}{$\rangle$} % Right Bracket '>'
\newcommand{\bs}{{\tt\char '134}} % BackSlash '\'
\newcommand{\tm}{${}^{\mbox{\tiny\sf TM}}$}
\newcommand{\TM}{\tm} % TM trademark symbol in
% either case
\newcommand{\cparam}[1]{{\rm \lbr{\sl #1}\rbr}}
% Metavariables.
%% Define NAMEURL macro to handle the optional name argument
%% This calls on the \url macro from the url.sty package so the
%% URL will be hyphenated correctly.
\def\nameurl#1#2{{\em #2} {\tt <\url{#1}>}}
\def\onlynameurl#1{{\em #1}}
%% the tscreen environment automatically goes into typewriter type,
%% but is otherwise like the screen environment
\newenvironment{tscreen}%
{\begin{quote}\bgroup\small\tt}%
{\egroup\end{quote}}
%% Typesetting of function descriptions
\def\function{\bigbreak\hrule\nobreak\bigskip\nobreak\leftline{\bf Function}\nobreak\smallskip\nobreak\parskip=0pt\relax}
\def\funcsect#1{\medbreak\leftline{\bf #1}\nobreak}
bird2-2.17.5/doc/tex/null.sty 0000664 0000000 0000000 00000000000 15211753245 0015663 0 ustar 00root root 0000000 0000000 bird2-2.17.5/doc/tex/qwertz.sty 0000664 0000000 0000000 00000001105 15211753245 0016254 0 ustar 00root root 0000000 0000000
% qwertz TeX macros
\catcode`\"=12
\sloppy
\newtheorem{definition}{Definition}
\newtheorem{proposition}{Proposition}
\newtheorem{lemma}{Lemma}
\newtheorem{corollary}{Corollary}
\newtheorem{theorem}{Theorem}
\newcommand{\mch}[1]{{\ifmmode#1 \else\(#1\)\fi}}
\newcommand{\lt}{{\ifmmode{<}\else{\verb+<+}\fi}}
\newcommand{\gt}{{\ifmmode{>}\else{\verb+>+}\fi}}
\newcommand{\verbar}{{\ifmmode{|}\else{\tt|}\fi}}
\newcommand{\idx}[1]{#1\index{#1}}
\newcommand{\cdx}[1]{#1\index{#1@{\tt #1}}}
\newcommand{\nidx}[1]{\index{#1}}
\newcommand{\ncdx}[1]{\index{#1@{\tt #1}}}
bird2-2.17.5/doc/tex/url.sty 0000664 0000000 0000000 00000033205 15211753245 0015530 0 ustar 00root root 0000000 0000000 % url.sty ver 1.2 19-Oct-1996 Donald Arseneau asnd@triumf.ca
%
% A form of \verb that allows linebreaks at certain characters or
% combinations of characters, accepts reconfiguration, and can usually
% be used in the argument to another command. It is intended for email
% addresses, hypertext links, directories/paths, etc., which normally
% have no spaces. The font may be selected using the \urlstyle command,
% and new url-like commands can be defined using \urldef.
%
% Usage: Conditions:
% \url{ } If the argument contains any "%", "#", or "^^", or ends with
% "\", it can't be used in the argument to another command.
% The argument must not contain unbalanced braces.
% \url| | ...where "|" is any character not used in the argument and not
% "{". The same restrictions as above except that the argument
% may contain unbalanced braces.
% \xyz for "\xyz" a defined-url; this can be used anywhere, no matter
% what characters it contains.
%
% See further instructions after "\endinput"
%
\def\Url@ttdo{% style assignments for tt fonts or T1 encoding
\def\UrlBreaks{\do\.\do\@\do\\\do\/\do\!\do\_\do\|\do\%\do\;\do\>\do\]%
\do\)\do\,\do\?\do\'\do\+\do\=}%
\def\UrlBigBreaks{\do\:\do@url@hyp}%
\def\UrlNoBreaks{\do\(\do\[\do\{\do\<}% (unnecessary)
\def\UrlSpecials{\do\ {\ }}%
\def\UrlOrds{\do\*\do\-\do\~}% any ordinary characters that aren't usually
}
\def\Url@do{% style assignments for OT1 fonts except tt
\def\UrlBreaks{\do\.\do\@\do\/\do\!\do\%\do\;\do\]\do\)\do\,\do\?\do\+\do\=}%
\def\UrlBigBreaks{\do\:\do@url@hyp}%
\def\UrlNoBreaks{\do\(\do\[\do\{}% prevents breaks after *next* character
\def\UrlSpecials{\do\<{\langle}\do\>{\mathbin{\rangle}}\do\_{\_%
\penalty\@m}\do\|{\mid}\do\{{\lbrace}\do\}{\mathbin{\rbrace}}\do
\\{\mathbin{\backslash}}\do\~{\mathord{{}^{\textstyle\sim}}}\do\ {\ }}%
\def\UrlOrds{\do\'\do\"\do\-}%
}
\def\url@ttstyle{%
\@ifundefined{selectfont}{\def\UrlFont{\tt}}{\def\UrlFont{\ttfamily}}\Url@ttdo
}
\def\url@rmstyle{%
\@ifundefined{selectfont}{\def\UrlFont{\rm}}{\def\UrlFont{\rmfamily}}\Url@do
}
\def\url@sfstyle{%
\@ifundefined{selectfont}{\def\UrlFont{\sf}}{\def\UrlFont{\sffamily}}\Url@do
}
\def\url@samestyle{\ifdim\fontdimen\thr@@\font=\z@ \url@ttstyle \else
\url@rmstyle \fi \def\UrlFont{}}
\@ifundefined{strip@prefix}{\def\strip@prefix#1>{}}{}
\@ifundefined{verbatim@nolig@list}{\def\verbatim@nolig@list{\do\`}}{}
\def\Url{\relax\ifmmode\@nomatherr$\fi
\UrlFont $\fam\z@ \textfont\z@\font
\let\do\@makeother \dospecials % verbatim catcodes
\catcode`{\@ne \catcode`}\tw@ % except braces
\medmuskip0mu \thickmuskip\medmuskip \thinmuskip\medmuskip
\@tempcnta\fam\multiply\@tempcnta\@cclvi
\let\do\set@mathcode \UrlOrds % ordinary characters that were special
\advance\@tempcnta 8192 \UrlBreaks % bin
\advance\@tempcnta 4096 \UrlBigBreaks % rel
\advance\@tempcnta 4096 \UrlNoBreaks % open
\let\do\set@mathact \UrlSpecials % active
\let\do\set@mathnolig \verbatim@nolig@list % prevent ligatures
\@ifnextchar\bgroup\Url@z\Url@y}
\def\Url@y#1{\catcode`{11 \catcode`}11
\def\@tempa##1#1{\Url@z{##1}}\@tempa}
\def\Url@z#1{\def\@tempa{#1}\expandafter\expandafter\expandafter\Url@Hook
\expandafter\strip@prefix\meaning\@tempa\UrlRight\m@th$\endgroup}
\def\Url@Hook{\UrlLeft}
\let\UrlRight\@empty
\let\UrlLeft\@empty
\def\set@mathcode#1{\count@`#1\advance\count@\@tempcnta\mathcode`#1\count@}
\def\set@mathact#1#2{\mathcode`#132768 \lccode`\~`#1\lowercase{\def~{#2}}}
\def\set@mathnolig#1{\ifnum\mathcode`#1<32768
\lccode`\~`#1\lowercase{\edef~{\mathchar\number\mathcode`#1_{\/}}}%
\mathcode`#132768 \fi}
\def\urldef#1#2{\begingroup \setbox\z@\hbox\bgroup
\def\Url@z{\Url@def{#1}{#2}}#2}
\expandafter\ifx\csname DeclareRobustCommand\endcsname\relax
\def\Url@def#1#2#3{\m@th$\endgroup\egroup\endgroup
\def#1{#2{#3}}}
\else
\def\Url@def#1#2#3{\m@th$\endgroup\egroup\endgroup
\DeclareRobustCommand{#1}{#2{#3}}}
\fi
\def\urlstyle#1{\csname url@#1style\endcsname}
% Sample (and default) configuration:
%
\newcommand\url{\begingroup \Url}
%
\newcommand\path{\begingroup \urlstyle{tt}\Url}
%
% too many styles define \email like \address, so I will not define it.
% \newcommand\email{\begingroup \urlstyle{rm}\Url}
% Process LaTeX \package options
%
\urlstyle{tt}
\let\Url@sppen\@M
\def\do@url@hyp{}% by default, no breaks after hyphens
\@ifundefined{ProvidesPackage}{}{
\ProvidesPackage{url}[1996/10/19 \space ver 1.2 \space
Verb mode for urls, email addresses, and file names]
\DeclareOption{hyphens}{\def\do@url@hyp{\do\-}}% allow breaks after hyphens
\DeclareOption{obeyspaces}{\let\Url@Hook\relax}% a flag for later
\DeclareOption{spaces}{\let\Url@sppen\relpenalty}
\DeclareOption{T1}{\let\Url@do\Url@ttdo}
\ProcessOptions
\ifx\Url@Hook\relax % [obeyspaces] was declared
\def\Url@Hook#1\UrlRight\m@th{\edef\@tempa{\noexpand\UrlLeft
\Url@retain#1\Url@nosp\, }\@tempa\UrlRight\m@th}
\def\Url@retain#1 {#1\penalty\Url@sppen\ \Url@retain}
\def\Url@nosp\,#1\Url@retain{}
\fi
}
\endinput
%
% url.sty ver 1.2 19-Oct-1996 Donald Arseneau asnd@reg.triumf.ca
%
% This package defines "\url", a form of "\verb" that allows linebreaks,
% and can often be used in the argument to another command. It can be
% configured to print in different formats, and is particularly useful for
% hypertext links, email addresses, directories/paths, etc. The font may
% be selected using the "\urlstyle" command and pre-defined text can be
% stored with the "\urldef" command. New url-like commands can be defined,
% and a "\path" command is provided this way.
%
% Usage: Conditions:
% \url{ } If the argument contains any "%", "#", or "^^", or ends with
% "\", it can't be used in the argument to another command.
% The argument must not contain unbalanced braces.
% \url| | ...where "|" is any character not used in the argument and not
% "{". The same restrictions as above except that the argument
% may contain unbalanced braces.
% \xyz for "\xyz" a defined-url; this can be used anywhere, no matter
% what characters it contains.
%
% The "\url" command is fragile, and its argument is likely to be very
% fragile, but a defined-url is robust.
%
% Package Option: obeyspaces
% Ordinarily, all spaces are ignored in the url-text. The "[obeyspaces]"
% option allows spaces, but may introduce spurious spaces when a url
% containing "\" characters is given in the argument to another command.
% So if you need to obey spaces you can say "\usepackage[obeyspaces]{url}",
% and if you need both spaces and backslashes, use a `defined-url' for
% anything with "\".
%
% Package Option: hyphens
% Ordinarily, breaks are not allowed after "-" characters because this
% leads to confusion. (Is the "-" part of the address or just a hyphen?)
% The package option "[hyphens]" allows breaks after explicit hyphen
% characters. The "\url" command will *never ever* hyphenate words.
%
% Package Option: spaces
% Likewise, breaks are not usually allowed after spaces under the
% "[obeyspaces]" option, but giving the options "[obeyspaces,spaces]"
% will allow breaks at those spaces.
%
% Package Option: T1
% This signifies that you will be using T1-encoded fonts which contain
% some characters missing from most older (OT1) encoded TeX fonts. This
% changes the default definition for "\urlstyle{rm}".
%
% Defining a defined-url:
% Take for example the email address "myself%node@gateway.net" which could
% not be given (using "\url" or "\verb") in a caption or parbox due to the
% percent sign. This address can be predefined with
% \urldef{\myself}\url{myself%node@gateway.net} or
% \urldef{\myself}\url|myself%node@gateway.net|
% and then you may use "\myself" instead of "\url{myself%node@gateway.net}"
% in an argument, and even in a moving argument like a caption because a
% defined-url is robust.
%
% Style:
% You can switch the style of printing using "\urlstyle{tt}", where "tt"
% can be any defined style. The pre-defined styles are "tt", "rm", "sf",
% and "same" which all allow the same linebreaks but different fonts --
% the first three select a specific font and the "same" style uses the
% current text font. You can define your own styles with different fonts
% and/or line-breaking by following the explanations below. The "\url"
% command follows whatever the currently-set style dictates.
%
% Alternate commands:
% It may be desireable to have different things treated differently, each
% in a predefined style; e.g., if you want directory paths to always be
% in tt and email addresses to be rm, then you would define new url-like
% commands as follows:
%
% \newcommand\email{\begingroup \urlstyle{rm}\Url}
% \newcommand\directory{\begingroup \urlstyle{tt}\Url}
%
% You must follow this format closely, and NOTE that the final command is
% "\Url", not "\url". In fact, the "\directory" example is exactly the
% "\path" definition which is pre-defined in the package. If you look
% above, you will see that "\url" is defined with
% \newcommand\url{\begingroup \Url}
% I.e., using whatever url-style has been selected.
%
% You can make a defined-url for these other styles, using the usual
% "\urldef" command as in this example:
%
% \urldef{\myself}{\email}{myself%node.domain@gateway.net}
%
% which makes "\myself" act like "\email{myself%node.domain@gateway.net}",
% if the "\email" command is defined as above. The "\myself" command
% would then be robust.
%
% Defining styles:
% Before describing how to customize the printing style, it is best to
% mention something about the unusual implementation of "\url". Although
% the material is textual in nature, and the font specification required
% is a text-font command, the text is actually typeset in *math* mode.
% This allows the context-sensitive linebreaking, but also accounts for
% the default behavior of ignoring spaces. Now on to defining styles.
%
% To change the font or the list of characters that allow linebreaks, you
% could redefine the commands "\UrlFont", "\UrlBreaks", "\UrlSpecials" etc.
% directly in the document, but it is better to define a new `url-style'
% (following the example of "\url@ttstyle" and "\url@rmstyle") which defines
% all of "\UrlBigbreaks", "\UrlNoBreaks", "\UrlBreaks", "\UrlSpecials", and
% "\UrlFont".
%
% Changing font:
% The "\UrlFont" command selects the font. The definition of "\UrlFont"
% done by the pre-defined styles varies to cope with a variety of LaTeX
% font selection schemes, but it could be as simple as "\def\UrlFont{\tt}".
% Depending on the font selected, some characters may need to be defined
% in the "\UrlSpecials" list because many fonts don't contain all the
% standard input characters.
%
% Changing linebreaks:
% The list of characters that allow line-breaks is given by "\UrlBreaks"
% and "\UrlBigBreaks", which have the format "\do\c" for character "c".
% The differences are that `BigBreaks' have a lower penalty and have
% different breakpoints when in sequence (as in "http://"): `BigBreaks'
% are treated as mathrels while `Breaks' are mathbins (see The TeXbook,
% p.170). In particular, a series of `BigBreak' characters will break at
% the end and only at the end; a series of `Break' characters will break
% after the first and after every following *pair*; there will be no
% break after a `Break' character if a `BigBreak' follows. In the case
% of "http://" it doesn't matter whether ":" is a `Break' or `BigBreak' --
% the breaks are the same in either case; but for DECnet nodes with "::"
% it is important to prevent breaks *between* the colons, and that is why
% colons are `BigBreaks'.
%
% It is possible for characters to prevent breaks after the next following
% character (I use this for parentheses). Specify these in "\UrlNoBreaks".
%
% You can do arbitrarily complex things with characters by making them
% active in math mode (mathcode hex-8000) and specifying the definition(s)
% in "\UrlSpecials". This is used in the rm and sf styles for OT1 font
% encoding to handle several characters that are not present in those
% computer-modern style fonts. See the definition of "\Url@do", which
% is used by both "\url@rmstyle" and "\url@sfstyle"; it handles missing
% characters via "\UrlSpecials". The nominal format for setting each
% special character "c" is: "\do\c{}", but you can include
% other definitions too.
%
%
% If all this sounds confusing ... well, it is! But I hope you won't need
% to redefine breakpoints -- the default assignments seem to work well for
% a wide variety of applications. If you do need to make changes, you can
% test for breakpoints using regular math mode and the characters "+=(a".
%
% Yet more flexibility:
% You can also customize the verbatim text by defining "\UrlRight" and/or
% "\UrlLeft", e.g., for ISO formatting of urls surrounded by "< >", define
%
% \renewcommand\url{\begingroup \def\UrlLeft{}%
% \urlstyle{tt}\Url}
%
% The meanings of "\UrlLeft" and "\UrlRight" are *not* reproduced verbatim.
% This lets you use formatting commands there, but you must be careful not
% to use TeX's special characters ("\^_%~#$&{}" etc.) improperly.
% You can also define "\UrlLeft" to reprocess the verbatim text, but the
% format of the definition is special:
%
% \def\UrlLeft#1\UrlRight{ ... do things with #1 ... }
%
% Yes, that is "#1" followed by "\UrlRight" then the definition. For
% example, to put a hyperTeX hypertext link in the DVI file:
%
% \def\UrlLeft#1\UrlRight{\special{html:}#1\special{html: }}
%
% Revision History:
% ver 1.1 6-Feb-1996:
% Fix hyphens that wouldn't break and ligatures that weren't suppressed.
% ver 1.2 19-Oct-1996:
% Package option for T1 encoding; Hooks: "\UrlLeft" and "\UrlRight".
%
% The End
bird2-2.17.5/filter/ 0000775 0000000 0000000 00000000000 15211753245 0014102 5 ustar 00root root 0000000 0000000 bird2-2.17.5/filter/Doc 0000664 0000000 0000000 00000000046 15211753245 0014532 0 ustar 00root root 0000000 0000000 H Filters
S filter.c
S tree.c
S trie.c bird2-2.17.5/filter/Makefile 0000664 0000000 0000000 00000001544 15211753245 0015546 0 ustar 00root root 0000000 0000000 src := filter.c data.c f-util.c tree.c trie.c inst-gen.c
obj := $(src-o-files)
$(all-daemon)
$(cf-local)
#M4FLAGS_FILTERS=$(filter-out -s,$(M4FLAGS))
M4FLAGS_FILTERS=$(M4FLAGS)
$(o)inst-gen.h: $(s)decl.m4 $(s)f-inst.c $(objdir)/.dir-stamp
$(M4) $(M4FLAGS_FILTERS) -DTARGET=H -P $^ >$@
$(o)inst-gen.c: $(s)decl.m4 $(s)f-inst.c $(objdir)/.dir-stamp
$(M4) $(M4FLAGS_FILTERS) -DTARGET=C -P $^ >$@
$(o)inst-interpret.c: $(s)decl.m4 $(s)f-inst.c $(objdir)/.dir-stamp
$(M4) $(M4FLAGS_FILTERS) -DTARGET=I -P $^ >$@
prepare: $(o)inst-interpret.c $(o)inst-gen.h
tests_src := tree_test.c trie_test.c
ifeq ($(findstring bgp,$(protocols))-$(findstring static,$(protocols)),bgp-static)
tests_src += filter_test.c
endif
tests_targets := $(tests_targets) $(tests-target-files)
tests_objs := $(tests_objs) $(src-o-files)
$(call clean,inst-gen.h inst-gen.c inst-interpret.c)
bird2-2.17.5/filter/config.Y 0000664 0000000 0000000 00000076306 15211753245 0015515 0 ustar 00root root 0000000 0000000 /*
* BIRD - filters
*
* Copyright 1998--2000 Pavel Machek
*
* Can be freely distributed and used under the terms of the GNU GPL.
*
FIXME: priority of ! should be lower
*/
CF_HDR
#include "filter/f-inst.h"
#include "filter/data.h"
CF_DEFINES
static inline u32 pair(u32 a, u32 b) { return (a << 16) | b; }
static inline u32 pair_a(u32 p) { return p >> 16; }
static inline u32 pair_b(u32 p) { return p & 0xFFFF; }
static struct symbol *this_function;
static struct sym_scope *this_for_scope;
static struct f_method_scope {
struct f_inst *object;
struct sym_scope *main;
struct sym_scope scope;
} f_method_scope_stack[32];
static int f_method_scope_pos = -1;
#define FM (f_method_scope_stack[f_method_scope_pos])
static inline void f_method_call_start(struct f_inst *object)
{
if (object->type == T_VOID)
cf_error("Can't infer type to properly call a method, please assign the value to a variable");
if (++f_method_scope_pos >= (int) ARRAY_SIZE(f_method_scope_stack))
cf_error("Too many nested method calls");
struct sym_scope *scope = f_type_method_scope(object->type);
if (!scope)
cf_error("No methods defined for type %s", f_type_name(object->type));
FM = (struct f_method_scope) {
.object = object,
.main = new_config->current_scope,
.scope = {
.next = global_root_scope,
.hash = scope->hash,
.active = 1,
.block = 1,
.readonly = 1,
},
};
new_config->current_scope = &FM.scope;
}
static inline void f_method_call_args(void)
{
ASSERT_DIE(FM.scope.active);
FM.scope.active = 0;
new_config->current_scope = FM.main;
}
static inline void f_method_call_end(void)
{
ASSERT_DIE(f_method_scope_pos >= 0);
if (FM.scope.active) {
ASSERT_DIE(&FM.scope == new_config->current_scope);
new_config->current_scope = FM.main;
FM.scope.active = 0;
}
f_method_scope_pos--;
}
static int
f_new_var(struct sym_scope *s)
{
/*
* - A variable is an offset on vstack from vbase.
* - Vbase is set on filter start / function call.
* - Scopes contain (non-frame) block scopes inside filter/function scope
* - Each scope knows number of vars in that scope
* - Offset is therefore a sum of 'slots' up to filter/function scope
* - New variables are added on top of vstk, so intermediate values cannot
* be there during FI_VAR_INIT. I.e. no 'var' inside 'term'.
* - Also, each f_line must always have its scope, otherwise a variable may
* be defined but not initialized if relevant f_line is not executed.
*/
int offset = s->slots++;
while (s->block)
{
s = s->next;
ASSERT(s);
offset += s->slots;
}
if (offset >= 0xff)
cf_error("Too many variables, at most 255 allowed");
return offset;
}
/*
* Sets and their items are during parsing handled as lists, linked
* through left ptr. The first item in a list also contains a pointer
* to the last item in a list (right ptr). For convenience, even items
* are handled as one-item lists. Lists are merged by f_merge_items().
*/
static int
f_valid_set_type(int type)
{
switch (type)
{
case T_INT:
case T_PAIR:
case T_QUAD:
case T_ENUM:
case T_IP:
case T_EC:
case T_LC:
case T_RD:
return 1;
default:
return 0;
}
}
static inline struct f_tree *
f_new_item(struct f_val from, struct f_val to)
{
struct f_tree *t = f_new_tree();
t->right = t;
t->from = from;
t->to = to;
return t;
}
static inline struct f_tree *
f_merge_items(struct f_tree *a, struct f_tree *b)
{
if (!a) return b;
a->right->left = b;
a->right = b->right;
b->right = NULL;
return a;
}
static inline struct f_tree *
f_new_pair_item(int fa, int ta, int fb, int tb)
{
check_u16(fa);
check_u16(ta);
check_u16(fb);
check_u16(tb);
if ((ta < fa) || (tb < fb))
cf_error( "From value cannot be higher that To value in pair sets");
struct f_tree *t = f_new_tree();
t->right = t;
t->from.type = t->to.type = T_PAIR;
t->from.val.i = pair(fa, fb);
t->to.val.i = pair(ta, tb);
return t;
}
static inline struct f_tree *
f_new_pair_set(int fa, int ta, int fb, int tb)
{
check_u16(fa);
check_u16(ta);
check_u16(fb);
check_u16(tb);
if ((ta < fa) || (tb < fb))
cf_error( "From value cannot be higher that To value in pair sets");
struct f_tree *lst = NULL;
int i;
for (i = fa; i <= ta; i++)
lst = f_merge_items(lst, f_new_pair_item(i, i, fb, tb));
return lst;
}
#define CC_ALL 0xFFFF
#define EC_ALL 0xFFFFFFFF
#define LC_ALL 0xFFFFFFFF
static struct f_tree *
f_new_ec_item(u32 kind, u32 ipv4_used, u32 key, u32 vf, u32 vt)
{
u64 fm, to;
if ((kind != EC_GENERIC) && (ipv4_used || (key >= 0x10000))) {
check_u16(vf);
if (vt == EC_ALL)
vt = 0xFFFF;
else
check_u16(vt);
}
if (kind == EC_GENERIC) {
fm = ec_generic(key, vf);
to = ec_generic(key, vt);
}
else if (ipv4_used) {
fm = ec_ip4(kind, key, vf);
to = ec_ip4(kind, key, vt);
}
else if (key < 0x10000) {
fm = ec_as2(kind, key, vf);
to = ec_as2(kind, key, vt);
}
else {
fm = ec_as4(kind, key, vf);
to = ec_as4(kind, key, vt);
}
struct f_tree *t = f_new_tree();
t->right = t;
t->from.type = t->to.type = T_EC;
t->from.val.ec = fm;
t->to.val.ec = to;
return t;
}
static struct f_tree *
f_new_lc_item(u32 f1, u32 t1, u32 f2, u32 t2, u32 f3, u32 t3)
{
struct f_tree *t = f_new_tree();
t->right = t;
t->from.type = t->to.type = T_LC;
t->from.val.lc = (lcomm) {f1, f2, f3};
t->to.val.lc = (lcomm) {t1, t2, t3};
return t;
}
static inline struct f_inst *
f_const_empty(enum f_type t)
{
switch (t) {
case T_PATH:
case T_CLIST:
case T_ECLIST:
case T_LCLIST:
return f_new_inst(FI_CONSTANT, (struct f_val) {
.type = t,
.val.ad = &null_adata,
});
case T_ROUTE:
return f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_ROUTE });
default:
return f_new_inst(FI_CONSTANT, (struct f_val) {});
}
}
/*
* Remove all new lines and doubled whitespaces
* and convert all tabulators to spaces
* and return a copy of string
*/
char *
assert_copy_expr(const char *start, size_t len)
{
/* XXX: Allocates maybe a little more memory than we really finally need */
char *str = cfg_alloc(len + 1);
char *dst = str;
const char *src = start - 1;
const char *end = start + len;
while (++src < end)
{
if (*src == '\n')
continue;
/* Skip doubled whitespaces */
if (src != start)
{
const char *prev = src - 1;
if ((*src == ' ' || *src == '\t') && (*prev == ' ' || *prev == '\t'))
continue;
}
if (*src == '\t')
*dst = ' ';
else
*dst = *src;
dst++;
}
*dst = '\0';
return str;
}
/*
* assert_done - create f_instruction of bt_assert
* @expr: expression in bt_assert()
* @start: pointer to first char of test expression
* @end: pointer to the last char of test expression
*/
static struct f_inst *
assert_done(struct f_inst *expr, const char *start, const char *end)
{
return f_new_inst(FI_ASSERT, expr,
(end >= start) ?
assert_copy_expr(start, end - start + 1)
: "???");
}
static struct f_inst *
f_lval_getter(struct f_lval *lval)
{
switch (lval->type) {
case F_LVAL_VARIABLE: return f_new_inst(FI_VAR_GET, lval->sym);
case F_LVAL_SA: return f_new_inst(FI_RTA_GET, lval->rte, lval->sa);
case F_LVAL_EA: return f_new_inst(FI_EA_GET, lval->rte, lval->da);
default: bug("Unknown lval type");
}
}
static struct f_inst *
f_lval_setter(struct f_lval *lval, struct f_inst *expr)
{
switch (lval->type) {
case F_LVAL_VARIABLE: return f_new_inst(FI_VAR_SET, expr, lval->sym);
case F_LVAL_SA: return f_new_inst(FI_RTA_SET, expr, lval->sa);
case F_LVAL_EA: return f_new_inst(FI_EA_SET, expr, lval->da);
default: bug("Unknown lval type");
}
}
static struct f_inst *
assert_assign(struct f_lval *lval, struct f_inst *expr, const char *start, const char *end)
{
struct f_inst *setter = f_lval_setter(lval, expr),
*getter = f_lval_getter(lval);
struct f_inst *checker = f_new_inst(FI_EQ, expr, getter);
setter->next = checker;
return assert_done(setter, start, end);
}
CF_DECLS
CF_KEYWORDS_EXCLUSIVE(IN)
CF_KEYWORDS(FUNCTION, PRINT, PRINTN, UNSET, RETURN,
ACCEPT, REJECT, ERROR,
INT, BOOL, IP, PREFIX, RD, PAIR, QUAD, EC, LC, ENUM,
SET, STRING, BYTESTRING, BGPMASK, BGPPATH, CLIST, ECLIST, LCLIST,
IF, THEN, ELSE, CASE,
FOR, DO,
TRUE, FALSE, RT, RO, UNKNOWN, GENERIC,
FROM, GW, NET, PROTO, SOURCE, SCOPE, DEST, IFNAME, IFINDEX, WEIGHT, GW_MPLS, GW_MPLS_STACK, ONLINK,
PREFERENCE,
ROA_CHECK, ASPA_CHECK,
DEFINED,
ADD, DELETE, RESET,
PREPEND,
EMPTY,
FILTER, WHERE, EVAL, ATTRIBUTE,
FROM_HEX,
BT_ASSERT, BT_TEST_SUITE, BT_CHECK_ASSIGN, BT_TEST_SAME, FORMAT)
%nonassoc THEN
%nonassoc ELSE
%type cmds_int cmd_prep
%type term term_bs cmd cmd_var cmds cmds_scoped constant constructor var var_list var_list_r function_call symbol_value bgp_path_expr bgp_path bgp_path_tail term_dot_method method_name_cont
%type dynamic_attr
%type static_attr
%type filter where_filter
%type filter_body function_body
%type lvalue
%type type function_vars function_type
%type function_argsn function_args
%type ec_kind
%type break_command
%type cnum
%type pair_item ec_item lc_item set_item switch_item ec_items set_items switch_items switch_body
%type fprefix_set
%type set_atom0 set_atom switch_atom fipa
%type fprefix
%type get_cf_position
%type for_var
CF_GRAMMAR
conf: filter_def ;
filter_def:
FILTER symbol {
$2 = cf_define_symbol(new_config, $2, SYM_FILTER, filter, NULL);
cf_push_scope( new_config, $2 );
this_function = NULL;
} filter_body {
struct filter *f = cfg_alloc(sizeof(struct filter));
*f = (struct filter) { .sym = $2, .root = $4 };
$2->filter = f;
cf_pop_scope(new_config);
}
;
conf: filter_eval ;
filter_eval:
EVAL term { cf_eval_int($2); }
;
conf: custom_attr ;
custom_attr: ATTRIBUTE type symbol ';' {
cf_define_symbol(new_config, $3, SYM_ATTRIBUTE, attribute, ca_lookup(new_config->pool, $3->name, $2)->fda);
};
conf: bt_test_suite ;
bt_test_suite:
BT_TEST_SUITE '(' symbol_known ',' text ')' {
cf_assert_symbol($3, SYM_FUNCTION);
struct f_bt_test_suite *t = cfg_allocz(sizeof(struct f_bt_test_suite));
t->fn = $3->function;
t->fn_name = $3->name;
t->dsc = $5;
add_tail(&new_config->tests, &t->n);
}
;
conf: bt_test_same ;
bt_test_same:
BT_TEST_SAME '(' symbol_known ',' symbol_known ',' NUM ')' {
cf_assert_symbol($3, SYM_FUNCTION);
cf_assert_symbol($5, SYM_FUNCTION);
struct f_bt_test_suite *t = cfg_allocz(sizeof(struct f_bt_test_suite));
t->fn = $3->function;
t->cmp = $5->function;
t->result = $7;
t->fn_name = $3->name;
t->dsc = $5->name;
add_tail(&new_config->tests, &t->n);
}
;
type:
INT { $$ = T_INT; }
| BOOL { $$ = T_BOOL; }
| IP { $$ = T_IP; }
| RD { $$ = T_RD; }
| PREFIX { $$ = T_NET; }
| PAIR { $$ = T_PAIR; }
| QUAD { $$ = T_QUAD; }
| EC { $$ = T_EC; }
| LC { $$ = T_LC; }
| STRING { $$ = T_STRING; }
| BYTESTRING { $$ = T_BYTESTRING; }
| BGPMASK { $$ = T_PATH_MASK; }
| BGPPATH { $$ = T_PATH; }
| CLIST { $$ = T_CLIST; }
| ECLIST { $$ = T_ECLIST; }
| LCLIST { $$ = T_LCLIST; }
| ROUTE { $$ = T_ROUTE; }
| type SET {
switch ($1) {
case T_INT:
case T_PAIR:
case T_QUAD:
case T_ENUM:
case T_EC:
case T_LC:
case T_RD:
case T_IP:
$$ = T_SET;
break;
case T_NET:
$$ = T_PREFIX_SET;
break;
default:
cf_error( "You can't create sets of this type." );
}
}
| ENUM enum_type { $$ = $2; };
;
function_argsn:
/* EMPTY */ { $$ = NULL; }
| function_argsn type symbol ';' {
if ($3->scope->slots >= 0xfe) cf_error("Too many declarations, at most 255 allowed");
$$ = cfg_alloc(sizeof(struct f_arg));
$$->arg = cf_define_symbol(new_config, $3, SYM_VARIABLE | $2, offset, sym_->scope->slots++);
$$->next = $1;
}
;
function_args:
'(' ')' { $$ = NULL; }
| '(' function_argsn type symbol ')' {
$$ = cfg_alloc(sizeof(struct f_arg));
$$->arg = cf_define_symbol(new_config, $4, SYM_VARIABLE | $3, offset, sym_->scope->slots++);
$$->next = $2;
}
;
function_vars:
/* EMPTY */ { $$ = 0; }
| function_vars type symbol ';' {
cf_define_symbol(new_config, $3, SYM_VARIABLE | $2, offset, f_new_var(sym_->scope));
$$ = $1 + 1;
}
;
function_type:
/* EMPTY */ { $$ = T_VOID; }
| IMP type { $$ = $2; }
;
filter_body: function_body ;
filter:
symbol_known {
cf_assert_symbol($1, SYM_FILTER);
$$ = $1->filter;
}
| {
cf_push_scope(new_config, NULL);
this_function = NULL;
} filter_body {
struct filter *f = cfg_alloc(sizeof(struct filter));
*f = (struct filter) { .root = $2 };
$$ = f;
cf_pop_scope(new_config);
}
;
where_filter:
WHERE term {
/* Construct 'IF term THEN { ACCEPT; } ELSE { REJECT; }' */
$$ = f_new_where($2);
}
;
function_body:
function_vars '{' cmds '}' {
$$ = f_linearize($3, 0);
$$->vars = $1;
}
;
conf: function_def ;
function_def:
FUNCTION symbol {
DBG( "Beginning of function %s\n", $2->name );
this_function = cf_define_symbol(new_config, $2, SYM_FUNCTION, function, NULL);
cf_push_scope(new_config, this_function);
} function_args function_type {
/* Make dummy f_line for storing function prototype */
struct f_line *dummy = cfg_allocz(sizeof(struct f_line));
this_function->function = dummy;
dummy->return_type = $5;
/* Revert the args */
while ($4) {
struct f_arg *tmp = $4;
$4 = $4->next;
tmp->next = dummy->arg_list;
dummy->arg_list = tmp;
dummy->args++;
}
} function_body {
$7->args = this_function->function->args;
$7->arg_list = this_function->function->arg_list;
$7->return_type = this_function->function->return_type;
$2->function = $7;
cf_pop_scope(new_config);
}
;
/* Programs */
cmds: /* EMPTY */ { $$ = NULL; }
| cmds_int { $$ = $1.begin; }
;
cmds_scoped: { cf_push_soft_scope(new_config); } cmds { cf_pop_soft_scope(new_config); $$ = $2; } ;
cmd_var: var | cmd ;
cmd_prep: cmd_var {
$$.begin = $$.end = $1;
if ($1)
while ($$.end->next)
$$.end = $$.end->next;
}
;
cmds_int: cmd_prep
| cmds_int cmd_prep {
if (!$1.begin)
$$ = $2;
else if (!$2.begin)
$$ = $1;
else {
$$.begin = $1.begin;
$$.end = $2.end;
$1.end->next = $2.begin;
}
}
;
/*
* Complex types, their bison value is struct f_val
*/
fipa:
IP4 %prec PREFIX_DUMMY { $$.type = T_IP; $$.val.ip = ipa_from_ip4($1); }
| IP6 %prec PREFIX_DUMMY { $$.type = T_IP; $$.val.ip = ipa_from_ip6($1); }
;
/*
* Set constants. They are also used in switch cases. We use separate
* nonterminals for switch (set_atom/switch_atom, set_item/switch_item ...)
* to elude a collision between symbol (in expr) in set_atom and symbol
* as a function call in switch case cmds.
*/
set_atom0:
NUM { $$.type = T_INT; $$.val.i = $1; }
| fipa { $$ = $1; }
| VPN_RD { $$.type = T_RD; $$.val.rd = $1; }
| ENUM_TOKEN { $$.type = pair_a($1); $$.val.i = pair_b($1); }
| '(' term ')' {
$$ = cf_eval($2, T_VOID);
if (!f_valid_set_type($$.type))
cf_error("Set-incompatible type (%s)", f_type_name($$.type));
}
;
set_atom:
set_atom0
| symbol_known {
cf_assert_symbol($1, SYM_CONSTANT);
if (!f_valid_set_type(SYM_TYPE($1)))
cf_error("%s: Set-incompatible type (%s)", $1->name, f_type_name(SYM_TYPE($1)));
$$ = *$1->val;
}
;
switch_atom:
set_atom0
;
cnum:
term { $$ = cf_eval_int($1); }
pair_item:
'(' cnum ',' cnum ')' { $$ = f_new_pair_item($2, $2, $4, $4); }
| '(' cnum ',' cnum DDOT cnum ')' { $$ = f_new_pair_item($2, $2, $4, $6); }
| '(' cnum ',' '*' ')' { $$ = f_new_pair_item($2, $2, 0, CC_ALL); }
| '(' cnum DDOT cnum ',' cnum ')' { $$ = f_new_pair_set($2, $4, $6, $6); }
| '(' cnum DDOT cnum ',' cnum DDOT cnum ')' { $$ = f_new_pair_set($2, $4, $6, $8); }
| '(' cnum DDOT cnum ',' '*' ')' { $$ = f_new_pair_item($2, $4, 0, CC_ALL); }
| '(' '*' ',' cnum ')' { $$ = f_new_pair_set(0, CC_ALL, $4, $4); }
| '(' '*' ',' cnum DDOT cnum ')' { $$ = f_new_pair_set(0, CC_ALL, $4, $6); }
| '(' '*' ',' '*' ')' { $$ = f_new_pair_item(0, CC_ALL, 0, CC_ALL); }
| '(' cnum ',' cnum ')' DDOT '(' cnum ',' cnum ')'
{ $$ = f_new_pair_item($2, $8, $4, $10); }
;
ec_kind:
RT { $$ = EC_RT; }
| RO { $$ = EC_RO; }
| UNKNOWN NUM { $$ = $2; }
| GENERIC { $$ = EC_GENERIC; }
;
ec_item:
'(' ec_kind ',' cnum ',' cnum ')' { $$ = f_new_ec_item($2, 0, $4, $6, $6); }
| '(' ec_kind ',' cnum ',' cnum DDOT cnum ')' { $$ = f_new_ec_item($2, 0, $4, $6, $8); }
| '(' ec_kind ',' cnum ',' '*' ')' { $$ = f_new_ec_item($2, 0, $4, 0, EC_ALL); }
;
lc_item:
'(' cnum ',' cnum ',' cnum ')' { $$ = f_new_lc_item($2, $2, $4, $4, $6, $6); }
| '(' cnum ',' cnum ',' cnum DDOT cnum ')' { $$ = f_new_lc_item($2, $2, $4, $4, $6, $8); }
| '(' cnum ',' cnum ',' '*' ')' { $$ = f_new_lc_item($2, $2, $4, $4, 0, LC_ALL); }
| '(' cnum ',' cnum DDOT cnum ',' '*' ')' { $$ = f_new_lc_item($2, $2, $4, $6, 0, LC_ALL); }
| '(' cnum ',' '*' ',' '*' ')' { $$ = f_new_lc_item($2, $2, 0, LC_ALL, 0, LC_ALL); }
| '(' cnum DDOT cnum ',' '*' ',' '*' ')' { $$ = f_new_lc_item($2, $4, 0, LC_ALL, 0, LC_ALL); }
| '(' '*' ',' '*' ',' '*' ')' { $$ = f_new_lc_item(0, LC_ALL, 0, LC_ALL, 0, LC_ALL); }
| '(' cnum ',' cnum ',' cnum ')' DDOT '(' cnum ',' cnum ',' cnum ')'
{ $$ = f_new_lc_item($2, $10, $4, $12, $6, $14); }
;
set_item:
pair_item
| ec_item
| lc_item
| set_atom { $$ = f_new_item($1, $1); }
| set_atom DDOT set_atom { $$ = f_new_item($1, $3); }
;
switch_item:
pair_item
| ec_item
| lc_item
| switch_atom { $$ = f_new_item($1, $1); }
| switch_atom DDOT switch_atom { $$ = f_new_item($1, $3); }
;
ec_items:
ec_item
| ec_items ',' ec_item { $$ = f_merge_items($1, $3); }
;
set_items:
set_item
| set_items ',' set_item { $$ = f_merge_items($1, $3); }
;
switch_items:
switch_item
| switch_items ',' switch_item { $$ = f_merge_items($1, $3); }
;
fprefix:
net_ip_ { $$.net = $1; $$.lo = $1.pxlen; $$.hi = $1.pxlen; }
| net_ip_ '+' { $$.net = $1; $$.lo = $1.pxlen; $$.hi = net_max_prefix_length[$1.type]; }
| net_ip_ '-' { $$.net = $1; $$.lo = 0; $$.hi = $1.pxlen; }
| net_ip_ '{' NUM ',' NUM '}' {
$$.net = $1; $$.lo = $3; $$.hi = $5;
if (($3 > $5) || ($5 > net_max_prefix_length[$1.type]))
cf_error("Invalid prefix pattern range: {%u, %u}", $3, $5);
}
;
fprefix_set:
fprefix { $$ = f_new_trie(cfg_mem, 0); trie_add_prefix($$, &($1.net), $1.lo, $1.hi); }
| fprefix_set ',' fprefix { $$ = $1; if (!trie_add_prefix($$, &($3.net), $3.lo, $3.hi)) cf_error("Mixed IPv4/IPv6 prefixes in prefix set"); }
;
switch_body: /* EMPTY */ { $$ = NULL; }
| switch_body switch_items ':' cmds_scoped {
/* Fill data fields */
struct f_tree *t;
for (t = $2; t; t = t->left)
t->data = $4;
$$ = f_merge_items($1, $2);
}
| switch_body ELSECOL cmds_scoped {
struct f_tree *t = f_new_tree();
t->from.type = t->to.type = T_VOID;
t->right = t;
t->data = $3;
$$ = f_merge_items($1, t);
}
;
bgp_path_expr:
symbol_value { $$ = $1; }
| '(' term ')' { $$ = $2; }
;
bgp_path:
PO bgp_path_tail PC { $$ = $2; }
;
bgp_path_tail:
NUM bgp_path_tail { $$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_PATH_MASK_ITEM, .val.pmi = { .asn = $1, .kind = PM_ASN, }, }); $$->next = $2; }
| NUM DDOT NUM bgp_path_tail { $$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_PATH_MASK_ITEM, .val.pmi = { .from = $1, .to = $3, .kind = PM_ASN_RANGE }, }); $$->next = $4; }
| '[' ']' bgp_path_tail { $$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_PATH_MASK_ITEM, .val.pmi = { .set = NULL, .kind = PM_ASN_SET }, }); $$->next = $3; }
| '[' set_items ']' bgp_path_tail {
if ($2->from.type != T_INT) cf_error("Only integer sets allowed in path mask");
$$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_PATH_MASK_ITEM, .val.pmi = { .set = build_tree($2), .kind = PM_ASN_SET }, }); $$->next = $4;
}
| '*' bgp_path_tail { $$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_PATH_MASK_ITEM, .val.pmi = { .kind = PM_ASTERISK }, }); $$->next = $2; }
| '?' bgp_path_tail { $$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_PATH_MASK_ITEM, .val.pmi = { .kind = PM_QUESTION }, }); $$->next = $2; }
| '+' bgp_path_tail { $$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_PATH_MASK_ITEM, .val.pmi = { .kind = PM_LOOP }, }); $$->next = $2; }
| bgp_path_expr bgp_path_tail { $$ = $1; $$->next = $2; }
| { $$ = NULL; }
;
constant:
NUM { $$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_INT, .val.i = $1, }); }
| TRUE { $$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_BOOL, .val.i = 1, }); }
| FALSE { $$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_BOOL, .val.i = 0, }); }
| TEXT { $$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_STRING, .val.s = $1, }); }
| BYTETEXT { $$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_BYTESTRING, .val.bs = $1, }); }
| fipa { $$ = f_new_inst(FI_CONSTANT, $1); }
| VPN_RD { $$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_RD, .val.rd = $1, }); }
| net_ { $$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_NET, .val.net = $1, }); }
| '[' ']' { $$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_SET, .val.t = NULL, }); }
| '[' set_items ']' {
DBG( "We've got a set here..." );
$$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_SET, .val.t = build_tree($2), });
DBG( "ook\n" );
}
| '[' fprefix_set ']' { $$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_PREFIX_SET, .val.ti = $2, }); }
| ENUM_TOKEN { $$ = f_new_inst(FI_CONSTANT, (struct f_val) { .type = $1 >> 16, .val.i = $1 & 0xffff, }); }
;
constructor:
'(' term ',' term ')' { $$ = f_new_inst(FI_PAIR_CONSTRUCT, $2, $4); }
| '(' ec_kind ',' term ',' term ')' { $$ = f_new_inst(FI_EC_CONSTRUCT, $4, $6, $2); }
| '(' term ',' term ',' term ')' { $$ = f_new_inst(FI_LC_CONSTRUCT, $2, $4, $6); }
| bgp_path { $$ = f_new_inst(FI_PATHMASK_CONSTRUCT, $1); }
;
/* This generates the function_call variable list backwards */
var_list_r:
/* EMPTY */ { $$ = NULL; }
| term { $$ = $1; }
| var_list_r ',' term { $$ = $3; $$->next = $1; }
;
var_list: var_list_r
{
$$ = NULL;
/* Revert the var_list_r */
while ($1) {
struct f_inst *tmp = $1;
$1 = $1->next;
tmp->next = $$;
$$ = tmp;
}
}
;
function_call:
symbol_known '(' var_list ')'
{
if ($1->class != SYM_FUNCTION)
cf_error("You can't call something which is not a function. Really.");
$$ = f_new_inst(FI_CALL, $3, $1);
}
;
symbol_value: symbol_known
{
switch ($1->class) {
case SYM_CONSTANT_RANGE:
$$ = f_new_inst(FI_CONSTANT, *($1->val));
break;
case SYM_VARIABLE_RANGE:
$$ = f_new_inst(FI_VAR_GET, $1);
break;
case SYM_ATTRIBUTE:
$$ = f_new_inst(FI_EA_GET, f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_ROUTE, .val.rte = NULL }), *$1->attribute);
break;
default:
cf_error("Can't get value of symbol %s", $1->name);
}
}
;
static_attr:
FROM { $$ = f_new_static_attr(T_IP, SA_FROM, 0); }
| GW { $$ = f_new_static_attr(T_IP, SA_GW, 0); }
| NET { $$ = f_new_static_attr(T_NET, SA_NET, 1); }
| PROTO { $$ = f_new_static_attr(T_STRING, SA_PROTO, 1); }
| SOURCE { $$ = f_new_static_attr(T_ENUM_RTS, SA_SOURCE, 1); }
| SCOPE { $$ = f_new_static_attr(T_ENUM_SCOPE, SA_SCOPE, 0); }
| DEST { $$ = f_new_static_attr(T_ENUM_RTD, SA_DEST, 0); }
| IFNAME { $$ = f_new_static_attr(T_STRING, SA_IFNAME, 0); }
| IFINDEX { $$ = f_new_static_attr(T_INT, SA_IFINDEX, 1); }
| WEIGHT { $$ = f_new_static_attr(T_INT, SA_WEIGHT, 0); }
| PREFERENCE { $$ = f_new_static_attr(T_INT, SA_PREF, 0); }
| GW_MPLS { $$ = f_new_static_attr(T_INT, SA_GW_MPLS, 0); }
| GW_MPLS_STACK { $$ = f_new_static_attr(T_CLIST, SA_GW_MPLS_STACK, 0); }
| ONLINK { $$ = f_new_static_attr(T_BOOL, SA_ONLINK, 0); }
;
term_dot_method: term '.' { f_method_call_start($1); } method_name_cont { f_method_call_end(); $$ = $4; };
method_name_cont:
CF_SYM_METHOD_BARE {
$$ = f_dispatch_method($1, FM.object, NULL, 1);
}
| CF_SYM_METHOD_ARGS {
f_method_call_args();
} '(' var_list ')' {
$$ = f_dispatch_method($1, FM.object, $4, 1);
}
| static_attr {
if (FM.object->type != T_ROUTE)
cf_error("Getting a route attribute from %s, need a route", f_type_name(FM.object->type));
$$ = f_new_inst(FI_RTA_GET, FM.object, $1);
}
| dynamic_attr {
if (FM.object->type != T_ROUTE)
cf_error("Getting a route attribute from %s, need a route", f_type_name(FM.object->type));
$$ = f_new_inst(FI_EA_GET, FM.object, $1);
}
;
term:
'(' term ')' { $$ = $2; }
| term '+' term { $$ = f_new_inst(FI_ADD, $1, $3); }
| term '-' term { $$ = f_new_inst(FI_SUBTRACT, $1, $3); }
| term '*' term { $$ = f_new_inst(FI_MULTIPLY, $1, $3); }
| term '/' term { $$ = f_new_inst(FI_DIVIDE, $1, $3); }
| term AND term { $$ = f_new_inst(FI_AND, $1, $3); }
| term OR term { $$ = f_new_inst(FI_OR, $1, $3); }
| term '=' term { $$ = f_new_inst(FI_EQ, $1, $3); }
| term NEQ term { $$ = f_new_inst(FI_NEQ, $1, $3); }
| term '<' term { $$ = f_new_inst(FI_LT, $1, $3); }
| term LEQ term { $$ = f_new_inst(FI_LTE, $1, $3); }
| term '>' term { $$ = f_new_inst(FI_LT, $3, $1); }
| term GEQ term { $$ = f_new_inst(FI_LTE, $3, $1); }
| term '~' term { $$ = f_new_inst(FI_MATCH, $1, $3); }
| term NMA term { $$ = f_new_inst(FI_NOT_MATCH, $1, $3); }
| '!' term { $$ = f_new_inst(FI_NOT, $2); }
| DEFINED '(' term ')' { $$ = f_new_inst(FI_DEFINED, $3); }
| symbol_value { $$ = $1; }
| constant { $$ = $1; }
| constructor { $$ = $1; }
| static_attr { $$ = f_new_inst(FI_RTA_GET, f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_ROUTE, .val.rte = NULL }), $1); }
| dynamic_attr { $$ = f_new_inst(FI_EA_GET, f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_ROUTE, .val.rte = NULL }), $1); }
| term_dot_method
| '+' EMPTY '+' { $$ = f_new_inst(FI_CONSTANT, val_empty(T_PATH)); }
| '-' EMPTY '-' { $$ = f_new_inst(FI_CONSTANT, val_empty(T_CLIST)); }
| '-' '-' EMPTY '-' '-' { $$ = f_new_inst(FI_CONSTANT, val_empty(T_ECLIST)); }
| '-' '-' '-' EMPTY '-' '-' '-' { $$ = f_new_inst(FI_CONSTANT, val_empty(T_LCLIST)); }
| PREPEND '(' term ',' term ')' { $$ = f_dispatch_method_x("prepend", $3->type, $3, $5); }
| ADD '(' term ',' term ')' { $$ = f_dispatch_method_x("add", $3->type, $3, $5); }
| DELETE '(' term ',' term ')' { $$ = f_dispatch_method_x("delete", $3->type, $3, $5); }
| FILTER '(' term ',' term ')' { $$ = f_dispatch_method_x("filter", $3->type, $3, $5); }
| ROA_CHECK '(' rtable ')' { $$ = f_new_inst(FI_ROA_CHECK_IMPLICIT, $3); }
| ROA_CHECK '(' rtable ',' term ',' term ')' { $$ = f_new_inst(FI_ROA_CHECK_EXPLICIT, $5, $7, $3); }
| ASPA_CHECK '(' rtable ',' term ',' term ')' { $$ = f_new_inst(FI_ASPA_CHECK_EXPLICIT, $5, $7, $3); }
| FORMAT '(' term ')' { $$ = f_new_inst(FI_FORMAT, $3); }
| term_bs
| function_call
;
term_bs:
FROM_HEX '(' term ')' { $$ = f_new_inst(FI_FROM_HEX, $3); }
;
break_command:
ACCEPT { $$ = F_ACCEPT; }
| REJECT { $$ = F_REJECT; }
| ERROR { $$ = F_ERROR; }
;
var:
type symbol '=' term ';' {
struct symbol *sym = cf_define_symbol(new_config, $2, SYM_VARIABLE | $1, offset, f_new_var(sym_->scope));
$$ = f_new_inst(FI_VAR_INIT, $4, sym);
}
| type symbol ';' {
struct symbol *sym = cf_define_symbol(new_config, $2, SYM_VARIABLE | $1, offset, f_new_var(sym_->scope));
$$ = f_new_inst(FI_VAR_INIT0, sym);
}
;
for_var:
type symbol { $$ = cf_define_symbol(new_config, $2, SYM_VARIABLE | $1, offset, f_new_var(sym_->scope)); }
| CF_SYM_KNOWN { cf_error("Use of a pre-defined variable in for loop is not allowed"); }
;
cmd:
'{' cmds_scoped '}' {
$$ = $2;
}
| IF term THEN cmd {
$$ = f_new_inst(FI_CONDITION, $2, $4, NULL);
}
| IF term THEN cmd ELSE cmd {
$$ = f_new_inst(FI_CONDITION, $2, $4, $6);
}
| FOR {
/* Reserve space for walk data on stack */
cf_push_block_scope(new_config);
new_config->current_scope->slots += 2;
} for_var IN
/* Parse term in the parent scope */
{ this_for_scope = new_config->current_scope; new_config->current_scope = this_for_scope->next; }
term
{ new_config->current_scope = this_for_scope; this_for_scope = NULL; }
DO cmd {
cf_pop_block_scope(new_config);
$$ = f_for_cycle($3, $6, $9);
}
| symbol_known '=' term ';' {
switch ($1->class) {
case SYM_VARIABLE_RANGE:
$$ = f_new_inst(FI_VAR_SET, $3, $1);
break;
case SYM_ATTRIBUTE:
$$ = f_new_inst(FI_EA_SET, $3, *$1->attribute);
break;
default:
cf_error("Can't assign to symbol %s", $1->name);
}
}
| RETURN term ';' {
DBG( "Ook, we'll return the value\n" );
if (!this_function)
cf_error("Can't return from a non-function, use accept or reject instead.");
if (this_function->function->return_type == T_VOID)
{
if ($2->type != T_VOID)
cf_warn("Inferring function %s return type from its return value: %s", this_function->name, f_type_name($2->type));
((struct f_line *) this_function->function)->return_type = $2->type;
}
else if (this_function->function->return_type != $2->type)
cf_error("Can't return type %s from function %s, expected %s",
f_type_name($2->type), this_function->name, f_type_name(this_function->function->return_type));
$$ = f_new_inst(FI_RETURN, $2);
}
| dynamic_attr '=' term ';' {
$$ = f_new_inst(FI_EA_SET, $3, $1);
}
| static_attr '=' term ';' {
if ($1.readonly)
cf_error( "This static attribute is read-only.");
$$ = f_new_inst(FI_RTA_SET, $3, $1);
}
| UNSET '(' dynamic_attr ')' ';' {
$$ = f_new_inst(FI_EA_UNSET, $3);
}
| UNSET '(' symbol_known ')' ';' {
switch ($3->class) {
case SYM_ATTRIBUTE:
$$ = f_new_inst(FI_EA_UNSET, *$3->attribute);
break;
default:
cf_error("Can't unset symbol %s", $3->name);
}
}
| break_command var_list_r ';' {
$$ = f_print($2, !!$2, $1);
}
| PRINT var_list_r ';' {
$$ = f_print($2, 1, F_NOP);
}
| PRINTN var_list_r ';' {
$$ = f_print($2, 0, F_NOP);
}
| function_call ';' { $$ = f_new_inst(FI_DROP_RESULT, $1); }
| CASE term '{' switch_body '}' {
$$ = f_new_inst(FI_SWITCH, $2, $4);
}
| lvalue '.' {
f_method_call_start(f_lval_getter(&$1));
} method_name_cont ';' {
f_method_call_end();
$$ = f_lval_setter(&$1, $4);
}
| BT_ASSERT '(' get_cf_position term get_cf_position ')' ';' { $$ = assert_done($4, $3 + 1, $5 - 1); }
| BT_CHECK_ASSIGN '(' get_cf_position lvalue get_cf_position ',' term ')' ';' { $$ = assert_assign(&$4, $7, $3 + 1, $5 - 1); }
;
get_cf_position:
{
$$ = cf_text;
};
lvalue:
CF_SYM_KNOWN {
switch ($1->class)
{
case SYM_VARIABLE_RANGE:
$$ = (struct f_lval) { .type = F_LVAL_VARIABLE, .sym = $1, .rte = f_const_empty(T_ROUTE) };
break;
case SYM_ATTRIBUTE:
$$ = (struct f_lval) { .type = F_LVAL_EA, .da = *($1->attribute), .rte = f_const_empty(T_ROUTE) };
break;
default:
cf_error("Variable name or custom attribute name required");
}
}
| static_attr { $$ = (struct f_lval) { .type = F_LVAL_SA, .sa = $1, .rte = f_const_empty(T_ROUTE) }; }
| dynamic_attr { $$ = (struct f_lval) { .type = F_LVAL_EA, .da = $1, .rte = f_const_empty(T_ROUTE) }; }
;
CF_END
bird2-2.17.5/filter/data.c 0000664 0000000 0000000 00000037073 15211753245 0015171 0 ustar 00root root 0000000 0000000 /*
* Filters: utility functions
*
* (c) 1998 Pavel Machek
* (c) 2019 Maria Matejka
*
* Can be freely distributed and used under the terms of the GNU GPL.
*
*/
#include "nest/bird.h"
#include "lib/lists.h"
#include "lib/resource.h"
#include "lib/socket.h"
#include "lib/string.h"
#include "lib/unaligned.h"
#include "lib/net.h"
#include "lib/ip.h"
#include "nest/route.h"
#include "nest/protocol.h"
#include "nest/iface.h"
#include "nest/attrs.h"
#include "conf/conf.h"
#include "filter/filter.h"
#include "filter/f-inst.h"
#include "filter/data.h"
static const char * const f_type_str[] = {
[T_VOID] = "void",
[T_NONE] = "none",
[T_INT] = "int",
[T_BOOL] = "bool",
[T_PAIR] = "pair",
[T_QUAD] = "quad",
[T_ENUM_RTS] = "enum rts",
[T_ENUM_BGP_ORIGIN] = "enum bgp_origin",
[T_ENUM_SCOPE] = "enum scope",
[T_ENUM_RTD] = "enum rtd",
[T_ENUM_ROA] = "enum roa",
[T_ENUM_ASPA] = "enum aspa",
[T_ENUM_NET_TYPE] = "enum net_type",
[T_ENUM_RA_PREFERENCE] = "enum ra_preference",
[T_ENUM_AF] = "enum af",
[T_ENUM_MPLS_POLICY] = "enum mpls_policy",
[T_IP] = "ip",
[T_NET] = "prefix",
[T_STRING] = "string",
[T_BYTESTRING] = "bytestring",
[T_PATH_MASK] = "bgpmask",
[T_PATH] = "bgppath",
[T_CLIST] = "clist",
[T_EC] = "ec",
[T_ECLIST] = "eclist",
[T_LC] = "lc",
[T_LCLIST] = "lclist",
[T_RD] = "rd",
[T_ROUTE] = "route",
[T_ROUTES_BLOCK] = "block of routes",
};
const char *
f_type_name(enum f_type t)
{
if (t < ARRAY_SIZE(f_type_str))
return f_type_str[t] ?: "?";
if ((t == T_SET) || (t == T_PREFIX_SET))
return "set";
return "?";
}
enum f_type
f_type_element_type(enum f_type t)
{
switch(t) {
case T_PATH: return T_INT;
case T_CLIST: return T_PAIR;
case T_ECLIST: return T_EC;
case T_LCLIST: return T_LC;
case T_ROUTES_BLOCK: return T_ROUTE;
default: return T_VOID;
};
}
const struct f_trie f_const_empty_trie = { .ipv4 = -1, };
const struct f_val f_const_empty_prefix_set = {
.type = T_PREFIX_SET,
.val.ti = &f_const_empty_trie,
};
static struct adata *
adata_empty(struct linpool *pool, int l)
{
struct adata *res = lp_alloc(pool, sizeof(struct adata) + l);
res->length = l;
return res;
}
static void
pm_format(const struct f_path_mask *p, buffer *buf)
{
int loop = 0;
buffer_puts(buf, "[= ");
for (uint i=0; ilen; i++)
{
switch(p->item[i].kind)
{
case PM_ASN:
buffer_print(buf, "%u ", p->item[i].asn);
break;
case PM_QUESTION:
buffer_puts(buf, "? ");
break;
case PM_ASTERISK:
buffer_puts(buf, "* ");
break;
case PM_LOOP:
loop = 1;
break;
case PM_ASN_RANGE:
buffer_print(buf, "%u..%u ", p->item[i].from, p->item[i].to);
break;
case PM_ASN_SET:
tree_format(p->item[i].set, buf);
buffer_puts(buf, " ");
break;
case PM_ASN_EXPR:
ASSERT(0);
}
if (loop && (p->item[i].kind != PM_LOOP))
{
buffer_puts(buf, "+ ");
loop = 0;
}
}
buffer_puts(buf, "=]");
}
static inline int
lcomm_cmp(lcomm v1, lcomm v2)
{
if (v1.asn != v2.asn)
return (v1.asn > v2.asn) ? 1 : -1;
if (v1.ldp1 != v2.ldp1)
return (v1.ldp1 > v2.ldp1) ? 1 : -1;
if (v1.ldp2 != v2.ldp2)
return (v1.ldp2 > v2.ldp2) ? 1 : -1;
return 0;
}
/**
* val_compare - compare two values
* @v1: first value
* @v2: second value
*
* Compares two values and returns -1, 0, 1 on <, =, > or F_CMP_ERROR on
* error. Tree module relies on this giving consistent results so
* that it can be used for building balanced trees.
*/
int
val_compare(const struct f_val *v1, const struct f_val *v2)
{
if (v1->type != v2->type) {
if (v1->type == T_VOID) /* Hack for else */
return -1;
if (v2->type == T_VOID)
return 1;
/* IP->Quad implicit conversion */
if ((v1->type == T_QUAD) && val_is_ip4(v2))
return uint_cmp(v1->val.i, ipa_to_u32(v2->val.ip));
if (val_is_ip4(v1) && (v2->type == T_QUAD))
return uint_cmp(ipa_to_u32(v1->val.ip), v2->val.i);
DBG( "Types do not match in val_compare\n" );
return F_CMP_ERROR;
}
switch (v1->type) {
case T_VOID:
return 0;
case T_ENUM:
case T_INT:
case T_BOOL:
case T_PAIR:
case T_QUAD:
return uint_cmp(v1->val.i, v2->val.i);
case T_EC:
case T_RD:
return u64_cmp(v1->val.ec, v2->val.ec);
case T_LC:
return lcomm_cmp(v1->val.lc, v2->val.lc);
case T_IP:
return ipa_compare(v1->val.ip, v2->val.ip);
case T_NET:
return net_compare(v1->val.net, v2->val.net);
case T_STRING:;
int i = strcmp(v1->val.s, v2->val.s);
return (i > 0) - (i < 0);
case T_PATH:
return as_path_compare(v1->val.ad, v2->val.ad);
case T_ROUTE:
/* Fall through */
case T_ROUTES_BLOCK:
default:
return F_CMP_ERROR;
}
}
static inline int
bs_same(const struct adata *bs1, const struct adata *bs2)
{
return (bs1->length == bs2->length) && !memcmp(bs1->data, bs2->data, bs1->length);
}
static inline int
pmi_same(const struct f_path_mask_item *mi1, const struct f_path_mask_item *mi2)
{
if (mi1->kind != mi2->kind)
return 0;
switch (mi1->kind) {
case PM_ASN:
if (mi1->asn != mi2->asn)
return 0;
break;
case PM_ASN_EXPR:
if (!f_same(mi1->expr, mi2->expr))
return 0;
break;
case PM_ASN_RANGE:
if (mi1->from != mi2->from)
return 0;
if (mi1->to != mi2->to)
return 0;
break;
case PM_ASN_SET:
if (!same_tree(mi1->set, mi2->set))
return 0;
break;
}
return 1;
}
static int
pm_same(const struct f_path_mask *m1, const struct f_path_mask *m2)
{
if (m1->len != m2->len)
return 0;
for (uint i=0; ilen; i++)
if (!pmi_same(&(m1->item[i]), &(m2->item[i])))
return 0;
return 1;
}
/**
* val_same - compare two values
* @v1: first value
* @v2: second value
*
* Compares two values and returns 1 if they are same and 0 if not.
* Comparison of values of different types is valid and returns 0.
*/
int
val_same(const struct f_val *v1, const struct f_val *v2)
{
int rc;
rc = val_compare(v1, v2);
if (rc != F_CMP_ERROR)
return !rc;
if (v1->type != v2->type)
return 0;
switch (v1->type) {
case T_BYTESTRING:
return bs_same(v1->val.bs, v2->val.bs);
case T_PATH_MASK:
return pm_same(v1->val.path_mask, v2->val.path_mask);
case T_PATH_MASK_ITEM:
return pmi_same(&(v1->val.pmi), &(v2->val.pmi));
case T_PATH:
case T_CLIST:
case T_ECLIST:
case T_LCLIST:
return adata_same(v1->val.ad, v2->val.ad);
case T_SET:
return same_tree(v1->val.t, v2->val.t);
case T_PREFIX_SET:
return trie_same(v1->val.ti, v2->val.ti);
case T_ROUTE:
return v1->val.rte == v2->val.rte;
case T_ROUTES_BLOCK:
return v1->val.ad == v2->val.ad;
default:
bug("Invalid type in val_same(): %x", v1->type);
}
}
int
clist_set_type(const struct f_tree *set, struct f_val *v)
{
if (!set)
{
v->type = T_VOID;
return 1;
}
switch (set->from.type)
{
case T_PAIR:
v->type = T_PAIR;
return 1;
case T_QUAD:
v->type = T_QUAD;
return 1;
case T_IP:
if (val_is_ip4(&(set->from)) && val_is_ip4(&(set->to)))
{
v->type = T_QUAD;
return 1;
}
/* Fall through */
default:
v->type = T_VOID;
return 0;
}
}
int
clist_match_set(const struct adata *clist, const struct f_tree *set)
{
if (!clist)
return 0;
struct f_val v;
if (!clist_set_type(set, &v))
return F_CMP_ERROR;
u32 *l = (u32 *) clist->data;
u32 *end = l + clist->length/4;
while (l < end) {
v.val.i = *l++;
if (find_tree(set, &v))
return 1;
}
return 0;
}
int
eclist_match_set(const struct adata *list, const struct f_tree *set)
{
if (!list)
return 0;
if (!eclist_set_type(set))
return F_CMP_ERROR;
struct f_val v;
u32 *l = int_set_get_data(list);
int len = int_set_get_size(list);
int i;
v.type = T_EC;
for (i = 0; i < len; i += 2) {
v.val.ec = ec_get(l, i);
if (find_tree(set, &v))
return 1;
}
return 0;
}
int
lclist_match_set(const struct adata *list, const struct f_tree *set)
{
if (!list)
return 0;
if (!lclist_set_type(set))
return F_CMP_ERROR;
struct f_val v;
u32 *l = int_set_get_data(list);
int len = int_set_get_size(list);
int i;
v.type = T_LC;
for (i = 0; i < len; i += 3) {
v.val.lc = lc_get(l, i);
if (find_tree(set, &v))
return 1;
}
return 0;
}
const struct adata *
clist_filter(struct linpool *pool, const struct adata *list, const struct f_val *set, int pos)
{
if (!list)
return NULL;
int tree = (set->type == T_SET); /* 1 -> set is T_SET, 0 -> set is T_CLIST */
struct f_val v;
if (tree)
clist_set_type(set->val.t, &v);
else
v.type = T_PAIR;
int len = int_set_get_size(list);
u32 *l = int_set_get_data(list);
u32 tmp[len];
u32 *k = tmp;
u32 *end = l + len;
while (l < end) {
v.val.i = *l++;
/* pos && member(val, set) || !pos && !member(val, set), member() depends on tree */
if ((tree ? !!find_tree(set->val.t, &v) : int_set_contains(set->val.ad, v.val.i)) == pos)
*k++ = v.val.i;
}
uint nl = (k - tmp) * sizeof(u32);
if (nl == list->length)
return list;
struct adata *res = adata_empty(pool, nl);
memcpy(res->data, tmp, nl);
return res;
}
const struct adata *
eclist_filter(struct linpool *pool, const struct adata *list, const struct f_val *set, int pos)
{
if (!list)
return NULL;
int tree = (set->type == T_SET); /* 1 -> set is T_SET, 0 -> set is T_CLIST */
struct f_val v;
int len = int_set_get_size(list);
u32 *l = int_set_get_data(list);
u32 tmp[len];
u32 *k = tmp;
int i;
v.type = T_EC;
for (i = 0; i < len; i += 2) {
v.val.ec = ec_get(l, i);
/* pos && member(val, set) || !pos && !member(val, set), member() depends on tree */
if ((tree ? !!find_tree(set->val.t, &v) : ec_set_contains(set->val.ad, v.val.ec)) == pos) {
*k++ = l[i];
*k++ = l[i+1];
}
}
uint nl = (k - tmp) * sizeof(u32);
if (nl == list->length)
return list;
struct adata *res = adata_empty(pool, nl);
memcpy(res->data, tmp, nl);
return res;
}
const struct adata *
lclist_filter(struct linpool *pool, const struct adata *list, const struct f_val *set, int pos)
{
if (!list)
return NULL;
int tree = (set->type == T_SET); /* 1 -> set is T_SET, 0 -> set is T_CLIST */
struct f_val v;
int len = int_set_get_size(list);
u32 *l = int_set_get_data(list);
u32 tmp[len];
u32 *k = tmp;
int i;
v.type = T_LC;
for (i = 0; i < len; i += 3) {
v.val.lc = lc_get(l, i);
/* pos && member(val, set) || !pos && !member(val, set), member() depends on tree */
if ((tree ? !!find_tree(set->val.t, &v) : lc_set_contains(set->val.ad, v.val.lc)) == pos)
k = lc_copy(k, l+i);
}
uint nl = (k - tmp) * sizeof(u32);
if (nl == list->length)
return list;
struct adata *res = adata_empty(pool, nl);
memcpy(res->data, tmp, nl);
return res;
}
/**
* val_in_range - implement |~| operator
* @v1: element
* @v2: set
*
* Checks if @v1 is element (|~| operator) of @v2.
*/
int
val_in_range(const struct f_val *v1, const struct f_val *v2)
{
if ((v1->type == T_PATH) && (v2->type == T_PATH_MASK))
return as_path_match(v1->val.ad, v2->val.path_mask);
if ((v1->type == T_INT) && (v2->type == T_PATH))
return as_path_contains(v2->val.ad, v1->val.i, 1);
if (((v1->type == T_PAIR) || (v1->type == T_QUAD)) && (v2->type == T_CLIST))
return int_set_contains(v2->val.ad, v1->val.i);
/* IP->Quad implicit conversion */
if (val_is_ip4(v1) && (v2->type == T_CLIST))
return int_set_contains(v2->val.ad, ipa_to_u32(v1->val.ip));
if ((v1->type == T_EC) && (v2->type == T_ECLIST))
return ec_set_contains(v2->val.ad, v1->val.ec);
if ((v1->type == T_LC) && (v2->type == T_LCLIST))
return lc_set_contains(v2->val.ad, v1->val.lc);
if ((v1->type == T_STRING) && (v2->type == T_STRING))
return patmatch(v2->val.s, v1->val.s);
if ((v1->type == T_IP) && (v2->type == T_NET))
return ipa_in_netX(v1->val.ip, v2->val.net);
if ((v1->type == T_NET) && (v2->type == T_NET))
return net_in_netX(v1->val.net, v2->val.net);
if ((v1->type == T_NET) && (v2->type == T_PREFIX_SET))
return trie_match_net(v2->val.ti, v1->val.net);
if (v2->type != T_SET)
return F_CMP_ERROR;
if (!v2->val.t)
return 0;
/* With integrated Quad<->IP implicit conversion */
if ((v1->type == v2->val.t->from.type) ||
((v1->type == T_QUAD) && val_is_ip4(&(v2->val.t->from)) && val_is_ip4(&(v2->val.t->to))))
return !!find_tree(v2->val.t, v1);
if (v1->type == T_CLIST)
return clist_match_set(v1->val.ad, v2->val.t);
if (v1->type == T_ECLIST)
return eclist_match_set(v1->val.ad, v2->val.t);
if (v1->type == T_LCLIST)
return lclist_match_set(v1->val.ad, v2->val.t);
if (v1->type == T_PATH)
return as_path_match_set(v1->val.ad, v2->val.t);
return F_CMP_ERROR;
}
/*
* rte_format - format route information
*/
static void
rte_format(const struct rte *rte, buffer *buf)
{
if (rte)
buffer_print(buf, "Route [%d] to %N from %s.%s via %s",
rte->src->global_id, rte->net->n.addr,
rte->sender->proto->name, rte->sender->name,
rte->src->proto->name);
else
buffer_puts(buf, "[No route]");
}
static void
rte_block_format(const struct rte *rte, buffer *buf)
{
buffer_print(buf, "Block of routes:");
int i = 0;
while (rte)
{
buffer_print(buf, "%s%d: ", i ? "; " : " ", i);
rte_format(rte, buf);
rte = rte->next;
i++;
}
}
/*
* val_format - format filter value
*/
void
val_format(const struct f_val *v, buffer *buf)
{
char buf2[1024];
switch (v->type)
{
case T_VOID: buffer_puts(buf, "(void)"); return;
case T_BOOL: buffer_puts(buf, v->val.i ? "TRUE" : "FALSE"); return;
case T_INT: buffer_print(buf, "%u", v->val.i); return;
case T_STRING: buffer_print(buf, "%s", v->val.s); return;
case T_BYTESTRING: bstrbintohex(v->val.bs->data, v->val.bs->length, buf2, 1000, ':'); buffer_print(buf, "%s", buf2); return;
case T_IP: buffer_print(buf, "%I", v->val.ip); return;
case T_NET: buffer_print(buf, "%N", v->val.net); return;
case T_PAIR: buffer_print(buf, "(%u,%u)", v->val.i >> 16, v->val.i & 0xffff); return;
case T_QUAD: buffer_print(buf, "%R", v->val.i); return;
case T_EC: ec_format(buf2, v->val.ec); buffer_print(buf, "%s", buf2); return;
case T_LC: lc_format(buf2, v->val.lc); buffer_print(buf, "%s", buf2); return;
case T_RD: rd_format(v->val.rd, buf2, 1024); buffer_print(buf, "%s", buf2); return;
case T_PREFIX_SET: trie_format(v->val.ti, buf); return;
case T_SET: tree_format(v->val.t, buf); return;
case T_ENUM: buffer_print(buf, "(enum %x)%u", v->type, v->val.i); return;
case T_PATH: as_path_format(v->val.ad, buf2, 1000); buffer_print(buf, "(path %s)", buf2); return;
case T_CLIST: int_set_format(v->val.ad, 1, -1, buf2, 1000); buffer_print(buf, "(clist %s)", buf2); return;
case T_ECLIST: ec_set_format(v->val.ad, -1, buf2, 1000); buffer_print(buf, "(eclist %s)", buf2); return;
case T_LCLIST: lc_set_format(v->val.ad, -1, buf2, 1000); buffer_print(buf, "(lclist %s)", buf2); return;
case T_PATH_MASK: pm_format(v->val.path_mask, buf); return;
case T_ROUTE: rte_format(v->val.rte, buf); return;
case T_ROUTES_BLOCK: rte_block_format(v->val.rte, buf); return;
default: buffer_print(buf, "[unknown type %x]", v->type); return;
}
}
char *
val_format_str(struct linpool *lp, const struct f_val *v) {
buffer b;
LOG_BUFFER_INIT(b);
val_format(v, &b);
return lp_strdup(lp, b.start);
}
static char val_dump_buffer[1024];
const char *
val_dump(const struct f_val *v) {
static buffer b = {
.start = val_dump_buffer,
.end = val_dump_buffer + 1024,
};
b.pos = b.start;
val_format(v, &b);
return val_dump_buffer;
}
bird2-2.17.5/filter/data.h 0000664 0000000 0000000 00000022446 15211753245 0015174 0 ustar 00root root 0000000 0000000 /*
* BIRD Internet Routing Daemon -- Dynamic data structures
*
* (c) 1999 Pavel Machek
* (c) 2018--2019 Maria Matejka
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_FILTER_DATA_H_
#define _BIRD_FILTER_DATA_H_
#include "nest/bird.h"
#include "nest/route.h"
/* Type numbers must be in 0..0xff range */
#define T_MASK 0xff
/* Internal types */
enum f_type {
/* Nothing. Simply nothing. */
T_VOID = 0,
T_NONE = 1, /* Special hack to represent missing arguments */
/* User visible types, which fit in int */
T_INT = 0x10,
T_BOOL = 0x11,
T_PAIR = 0x12, /* Notice that pair is stored as integer: first << 16 | second */
T_QUAD = 0x13,
/* Put enumerational types in 0x30..0x3f range */
T_ENUM_LO = 0x30,
T_ENUM_HI = 0x3f,
T_ENUM_RTS = 0x30,
T_ENUM_BGP_ORIGIN = 0x31,
T_ENUM_SCOPE = 0x32,
T_ENUM_RTD = 0x33,
T_ENUM_ROA = 0x34,
T_ENUM_ASPA = 0x35,
T_ENUM_NET_TYPE = 0x36,
T_ENUM_RA_PREFERENCE = 0x37,
T_ENUM_AF = 0x38,
T_ENUM_MPLS_POLICY = 0x39,
/* new enums go here */
T_ENUM_EMPTY = 0x3f, /* Special hack for atomic_aggr */
#define T_ENUM T_ENUM_LO ... T_ENUM_HI
/* Bigger ones */
T_IP = 0x20,
T_NET = 0x21,
T_STRING = 0x22,
T_PATH_MASK = 0x23, /* mask for BGP path */
T_PATH = 0x24, /* BGP path */
T_CLIST = 0x25, /* Community list */
T_EC = 0x26, /* Extended community value, u64 */
T_ECLIST = 0x27, /* Extended community list */
T_LC = 0x28, /* Large community value, lcomm */
T_LCLIST = 0x29, /* Large community list */
T_RD = 0x2a, /* Route distinguisher for VPN addresses */
T_PATH_MASK_ITEM = 0x2b, /* Path mask item for path mask constructors */
T_BYTESTRING = 0x2c,
T_ROUTE = 0x78,
T_ROUTES_BLOCK = 0x79,
T_SET = 0x80,
T_PREFIX_SET = 0x81,
} PACKED;
struct f_method {
struct symbol *sym;
struct f_inst *(*new_inst)(struct f_inst *obj, struct f_inst *args);
const struct f_method *next;
uint arg_num;
enum f_type args_type[];
};
/* Filter value; size of this affects filter memory consumption */
struct f_val {
enum f_type type; /* T_* */
union {
uint i;
u64 ec;
lcomm lc;
vpn_rd rd;
ip_addr ip;
const net_addr *net;
const char *s;
const struct adata *bs;
const struct f_tree *t;
const struct f_trie *ti;
const struct adata *ad;
const struct f_path_mask *path_mask;
struct f_path_mask_item pmi;
struct rte *rte;
} val;
};
/* Dynamic attribute definition (eattrs) */
struct f_dynamic_attr {
u8 type; /* EA type (EAF_*) */
u8 bit; /* For bitfield accessors */
enum f_type f_type; /* Filter type */
uint ea_code; /* EA code */
uint flags;
};
enum f_sa_code {
SA_FROM = 1,
SA_GW,
SA_NET,
SA_PROTO,
SA_SOURCE,
SA_SCOPE,
SA_DEST,
SA_IFNAME,
SA_IFINDEX,
SA_WEIGHT,
SA_PREF,
SA_GW_MPLS,
SA_GW_MPLS_STACK,
SA_ONLINK,
} PACKED;
/* Static attribute definition (members of struct rta) */
struct f_static_attr {
enum f_type f_type; /* Filter type */
enum f_sa_code sa_code; /* Static attribute id */
int readonly:1; /* Don't allow writing */
};
/* Filter l-value type */
enum f_lval_type {
F_LVAL_VARIABLE,
F_LVAL_PREFERENCE,
F_LVAL_SA,
F_LVAL_EA,
};
/* Filter l-value */
struct f_lval {
enum f_lval_type type;
struct f_inst *rte;
union {
struct symbol *sym;
struct f_dynamic_attr da;
struct f_static_attr sa;
};
};
/* IP prefix range structure */
struct f_prefix {
net_addr net; /* The matching prefix must match this net */
u8 lo, hi; /* And its length must fit between lo and hi */
};
struct f_tree {
struct f_tree *left, *right;
struct f_val from, to;
void *data;
};
#ifdef ENABLE_COMPACT_TRIES
/* Compact 4-way tries */
#define TRIE_STEP 2
#define TRIE_STACK_LENGTH 65
#else
/* Faster 16-way tries */
#define TRIE_STEP 4
#define TRIE_STACK_LENGTH 33
#endif
struct f_trie_node4
{
ip4_addr addr, mask, accept;
u16 plen;
u16 local;
struct f_trie_node4 *c[1 << TRIE_STEP];
};
struct f_trie_node6
{
ip6_addr addr, mask, accept;
u16 plen;
u16 local;
struct f_trie_node6 *c[1 << TRIE_STEP];
};
struct f_trie_node
{
union {
struct f_trie_node4 v4;
struct f_trie_node6 v6;
};
};
struct f_trie
{
linpool *lp;
u8 zero;
s8 ipv4; /* -1 for undefined / empty */
u16 data_size; /* Additional data for each trie node */
u32 prefix_count; /* Works only for restricted tries (pxlen == l == h) */
struct f_trie_node root; /* Root trie node */
};
struct f_trie_walk_state
{
u8 ipv4;
u8 accept_length; /* Current inter-node prefix position */
u8 start_pos; /* Initial prefix position in stack[0] */
u8 local_pos; /* Current intra-node prefix position */
u8 stack_pos; /* Current node in stack below */
const struct f_trie_node *stack[TRIE_STACK_LENGTH];
};
struct f_tree *f_new_tree(void);
struct f_tree *build_tree(struct f_tree *);
const struct f_tree *find_tree(const struct f_tree *t, const struct f_val *val);
const struct f_tree *find_tree_linear(const struct f_tree *t, const struct f_val *val);
int same_tree(const struct f_tree *t0, const struct f_tree *t2);
int tree_node_count(const struct f_tree *t);
void tree_format(const struct f_tree *t, buffer *buf);
void tree_walk(const struct f_tree *t, void (*hook)(const struct f_tree *, void *), void *data);
struct f_trie *f_new_trie(linpool *lp, uint data_size);
void *trie_add_prefix(struct f_trie *t, const net_addr *n, uint l, uint h);
int trie_match_net(const struct f_trie *t, const net_addr *n);
int trie_match_longest_ip4(const struct f_trie *t, const net_addr_ip4 *net, net_addr_ip4 *dst, ip4_addr *found0);
int trie_match_longest_ip6(const struct f_trie *t, const net_addr_ip6 *net, net_addr_ip6 *dst, ip6_addr *found0);
void trie_walk_init(struct f_trie_walk_state *s, const struct f_trie *t, const net_addr *from);
int trie_walk_next(struct f_trie_walk_state *s, net_addr *net);
int trie_same(const struct f_trie *t1, const struct f_trie *t2);
void trie_format(const struct f_trie *t, buffer *buf);
static inline int
trie_match_next_longest_ip4(net_addr_ip4 *n, ip4_addr *found)
{
while (n->pxlen)
{
n->pxlen--;
ip4_clrbit(&n->prefix, n->pxlen);
if (ip4_getbit(*found, n->pxlen))
return 1;
}
return 0;
}
static inline int
trie_match_next_longest_ip6(net_addr_ip6 *n, ip6_addr *found)
{
while (n->pxlen)
{
n->pxlen--;
ip6_clrbit(&n->prefix, n->pxlen);
if (ip6_getbit(*found, n->pxlen))
return 1;
}
return 0;
}
#define TRIE_WALK_TO_ROOT_IP4(trie, net, dst) ({ \
net_addr_ip4 dst; \
ip4_addr _found; \
for (int _n = trie_match_longest_ip4(trie, net, &dst, &_found); \
_n; \
_n = trie_match_next_longest_ip4(&dst, &_found))
#define TRIE_WALK_TO_ROOT_IP6(trie, net, dst) ({ \
net_addr_ip6 dst; \
ip6_addr _found; \
for (int _n = trie_match_longest_ip6(trie, net, &dst, &_found); \
_n; \
_n = trie_match_next_longest_ip6(&dst, &_found))
#define TRIE_WALK_TO_ROOT_END })
#define TRIE_WALK(trie, net, from) ({ \
net_addr net; \
struct f_trie_walk_state tws_; \
trie_walk_init(&tws_, trie, from); \
while (trie_walk_next(&tws_, &net))
#define TRIE_WALK_END })
#define F_CMP_ERROR 999
const char *f_type_name(enum f_type t);
enum f_type f_type_element_type(enum f_type t);
struct sym_scope *f_type_method_scope(enum f_type t);
int val_same(const struct f_val *v1, const struct f_val *v2);
int val_compare(const struct f_val *v1, const struct f_val *v2);
void val_format(const struct f_val *v, buffer *buf);
char *val_format_str(struct linpool *lp, const struct f_val *v);
const char *val_dump(const struct f_val *v);
static inline int val_is_ip4(const struct f_val *v)
{ return (v->type == T_IP) && ipa_is_ip4(v->val.ip); }
int val_in_range(const struct f_val *v1, const struct f_val *v2);
int clist_set_type(const struct f_tree *set, struct f_val *v);
static inline int eclist_set_type(const struct f_tree *set)
{ return !set || set->from.type == T_EC; }
static inline int lclist_set_type(const struct f_tree *set)
{ return !set || set->from.type == T_LC; }
static inline int path_set_type(const struct f_tree *set)
{ return !set || set->from.type == T_INT; }
int clist_match_set(const struct adata *clist, const struct f_tree *set);
int eclist_match_set(const struct adata *list, const struct f_tree *set);
int lclist_match_set(const struct adata *list, const struct f_tree *set);
const struct adata *clist_filter(struct linpool *pool, const struct adata *list, const struct f_val *set, int pos);
const struct adata *eclist_filter(struct linpool *pool, const struct adata *list, const struct f_val *set, int pos);
const struct adata *lclist_filter(struct linpool *pool, const struct adata *list, const struct f_val *set, int pos);
/* Special undef value for paths and clists */
static inline int
val_is_undefined(struct f_val v)
{
return ((v.type == T_PATH) || (v.type == T_CLIST) ||
(v.type == T_ECLIST) || (v.type == T_LCLIST)) &&
(v.val.ad == &null_adata);
}
static inline struct f_val
val_empty(enum f_type t)
{
switch (t)
{
case T_PATH:
case T_CLIST:
case T_ECLIST:
case T_LCLIST:
return (struct f_val) { .type = t, .val.ad = &null_adata };
default:
return (struct f_val) { };
}
}
extern const struct f_val f_const_empty_prefix_set;
enum filter_return f_eval(const struct f_line *expr, struct linpool *tmp_pool, struct f_val *pres);
#endif
bird2-2.17.5/filter/decl.m4 0000664 0000000 0000000 00000062314 15211753245 0015261 0 ustar 00root root 0000000 0000000 m4_divert(-1)m4_dnl
#
# BIRD -- Construction of per-instruction structures
#
# (c) 2018 Maria Matejka
#
# Can be freely distributed and used under the terms of the GNU GPL.
#
# THIS IS A M4 MACRO FILE GENERATING 3 FILES ALTOGETHER.
# KEEP YOUR HANDS OFF UNLESS YOU KNOW WHAT YOU'RE DOING.
# EDITING AND DEBUGGING THIS FILE MAY DAMAGE YOUR BRAIN SERIOUSLY.
#
# But you're welcome to read and edit and debug if you aren't scared.
#
# Uncomment the following line to get exhaustive debug output.
# m4_debugmode(aceflqtx)
#
# How it works:
# 1) Instruction to code conversion (uses diversions 100..199)
# 2) Code wrapping (uses diversions 1..99)
# 3) Final preparation (uses diversions 200..299)
# 4) Shipout
#
# See below for detailed description.
#
#
# 1) Instruction to code conversion
# The code provided in f-inst.c between consecutive INST() calls
# is interleaved for many different places. It is here processed
# and split into separate instances where split-by-instruction
# happens. These parts are stored in temporary diversions listed:
#
# 101 content of per-inst struct
# 102 constructor arguments
# 110 constructor attributes
# 103 constructor body
# 111 method constructor body
# 112 instruction constructor call from method constructor
# 113 method constructor symbol registrator
# 104 dump line item content
# (there may be nothing in dump-line content and
# it must be handled specially in phase 2)
# 105 linearize body
# 106 comparator body
# 107 struct f_line_item content
# 108 interpreter body
# 109 iterator body
#
# Here are macros to allow you to _divert to the right directions.
m4_define(FID_STRUCT_IN, `m4_divert(101)')
m4_define(FID_NEW_ARGS, `m4_divert(102)')
m4_define(FID_NEW_ATTRIBUTES, `m4_divert(110)')
m4_define(FID_NEW_BODY, `m4_divert(103)')
m4_define(FID_NEW_METHOD, `m4_divert(111)')
m4_define(FID_METHOD_CALL, `m4_divert(112)')
m4_define(FID_TYPE_SIGNATURE, `m4_divert(113)')
m4_define(FID_DUMP_BODY, `m4_divert(104)m4_define([[FID_DUMP_BODY_EXISTS]])')
m4_define(FID_LINEARIZE_BODY, `m4_divert(105)')
m4_define(FID_SAME_BODY, `m4_divert(106)')
m4_define(FID_LINE_IN, `m4_divert(107)')
m4_define(FID_INTERPRET_BODY, `m4_divert(108)')
m4_define(FID_ITERATE_BODY, `m4_divert(109)')
# Sometimes you want slightly different code versions in different
# outputs.
# Use FID_HIC(code for inst-gen.h, code for inst-gen.c, code for inst-interpret.c)
# and put it into [[ ]] quotes if it shall contain commas.
m4_define(FID_HIC, `m4_ifelse(TARGET, [[H]], [[$1]], TARGET, [[I]], [[$2]], TARGET, [[C]], [[$3]])')
# In interpreter code, this is quite common.
m4_define(FID_INTERPRET_EXEC, `FID_HIC(,[[FID_INTERPRET_BODY()]],[[m4_divert(-1)]])')
m4_define(FID_INTERPRET_NEW, `FID_HIC(,[[m4_divert(-1)]],[[FID_INTERPRET_BODY()]])')
# If the instruction is never converted to constant, the interpret
# code is not produced at all for constructor
m4_define(NEVER_CONSTANT, `m4_define([[INST_NEVER_CONSTANT]])')
m4_define(FID_IFCONST, `m4_ifdef([[INST_NEVER_CONSTANT]],[[$2]],[[$1]])')
# If the instruction has some attributes (here called members),
# these are typically carried with the instruction from constructor
# to interpreter. This yields a line of code everywhere on the path.
# FID_MEMBER is a macro to help with this task.
m4_define(FID_MEMBER, `m4_dnl
FID_LINE_IN()m4_dnl
$1 $2;
FID_STRUCT_IN()m4_dnl
$1 $2;
FID_NEW_ARGS()m4_dnl
, $1 $2
FID_NEW_BODY()m4_dnl
whati->$2 = $2;
FID_LINEARIZE_BODY()m4_dnl
item->$2 = whati->$2;
m4_ifelse($3,,,[[
FID_SAME_BODY()m4_dnl
if ($3) return 0;
]])
m4_ifelse($4,,,[[
FID_DUMP_BODY()m4_dnl
RDUMP("%s" $4 "\n", INDENT, $5);
]])
FID_INTERPRET_EXEC()m4_dnl
const $1 $2 = whati->$2
FID_INTERPRET_BODY')
# Instruction arguments are needed only until linearization is done.
# This puts the arguments into the filter line to be executed before
# the instruction itself.
#
# To achieve this, ARG_ANY must be called before anything writes into
# the instruction line as it moves the instruction pointer forward.
m4_define(ARG_ANY, `
FID_STRUCT_IN()m4_dnl
struct f_inst * f$1;
FID_NEW_ARGS()m4_dnl
, struct f_inst * f$1
FID_NEW_ATTRIBUTES()m4_dnl
NONNULL(m4_eval($1+1))
FID_NEW_BODY()m4_dnl
whati->f$1 = f$1;
const struct f_inst *child$1 = f$1;
do {
what->size += child$1->size;
FID_IFCONST([[
if (child$1->fi_code != FI_CONSTANT)
constargs = 0;
]])
} while (child$1 = child$1->next);
m4_define([[INST_METHOD_NUM_ARGS]],$1)m4_dnl
m4_ifelse($1,1,,[[FID_NEW_METHOD()m4_dnl
struct f_inst *arg$1 = args;
if (args == NULL) cf_error("Not enough arguments"); /* INST_NAME */
args = args->next;
FID_METHOD_CALL() , arg$1]])
FID_LINEARIZE_BODY()m4_dnl
pos = linearize(dest, whati->f$1, pos);
FID_INTERPRET_BODY()')
# Some instructions accept variable number of arguments.
m4_define(VARARG, `
FID_NEW_ARGS()m4_dnl
, struct f_inst * fvar
FID_STRUCT_IN()m4_dnl
struct f_inst * fvar;
uint varcount;
FID_LINE_IN()m4_dnl
uint varcount;
FID_NEW_BODY()m4_dnl
whati->varcount = 0;
whati->fvar = fvar;
for (const struct f_inst *child = fvar; child; child = child->next, whati->varcount++) {
what->size += child->size;
FID_IFCONST([[
if (child->fi_code != FI_CONSTANT)
constargs = 0;
]])
}
FID_IFCONST([[
const struct f_inst **items = NULL;
if (constargs && whati->varcount) {
items = alloca(whati->varcount * sizeof(struct f_inst *));
const struct f_inst *child = fvar;
for (uint i=0; child; i++)
child = (items[i] = child)->next;
}
]])
FID_LINEARIZE_BODY()m4_dnl
pos = linearize(dest, whati->fvar, pos);
item->varcount = whati->varcount;
FID_DUMP_BODY()m4_dnl
RDUMP("%snumber of varargs %u\n", INDENT, item->varcount);
FID_SAME_BODY()m4_dnl
if (f1->varcount != f2->varcount) return 0;
FID_INTERPRET_BODY()
FID_HIC(,[[
if (fstk->vcnt < whati->varcount) runtime("Stack underflow");
fstk->vcnt -= whati->varcount;
]],)
')
# Some arguments need to check their type. After that, ARG_ANY is called.
m4_define(ARG, `ARG_ANY($1) ARG_TYPE($1,$2)')
m4_define(ARG_TYPE, `ARG_TYPE_STATIC($1,$2) ARG_TYPE_DYNAMIC($1,$2)')
m4_define(ARG_TYPE_STATIC, `m4_dnl
m4_ifelse($1,1,[[m4_define([[INST_METHOD_OBJECT_TYPE]],$2)]],)m4_dnl
FID_TYPE_SIGNATURE()m4_dnl
method->args_type[m4_eval($1-1)] = $2;
FID_NEW_BODY()m4_dnl
if (f$1->type && (f$1->type != ($2)) && !f_const_promotion(f$1, ($2)))
cf_error("Argument $1 of %s must be of type %s, got type %s",
f_instruction_name(what->fi_code), f_type_name($2), f_type_name(f$1->type));
FID_INTERPRET_BODY()')
m4_define(ARG_TYPE_DYNAMIC, `m4_dnl
FID_INTERPRET_EXEC()m4_dnl
if (v$1.type != ($2))
runtime("Argument $1 of %s must be of type %s, got type %s",
f_instruction_name(what->fi_code), f_type_name($2), f_type_name(v$1.type));
FID_INTERPRET_BODY()')
m4_define(ARG_SAME_TYPE, `m4_dnl
FID_NEW_BODY()m4_dnl
if (f$1->type && f$2->type && (f$1->type != f$2->type) &&
!f_const_promotion(f$2, f$1->type) && !f_const_promotion(f$1, f$2->type))
cf_error("Arguments $1 and $2 of %s must be of the same type", f_instruction_name(what->fi_code));
FID_INTERPRET_BODY()')
m4_define(ARG_PREFER_SAME_TYPE, `m4_dnl
FID_NEW_BODY()m4_dnl
if (f$1->type && f$2->type && (f$1->type != f$2->type))
(void) (f_const_promotion(f$2, f$1->type) || f_const_promotion(f$1, f$2->type));
FID_INTERPRET_BODY()')
# Executing another filter line. This replaces the recursion
# that was needed in the former implementation.
m4_define(LINEX, `FID_INTERPRET_EXEC()LINEX_($1)FID_INTERPRET_NEW()return $1 FID_INTERPRET_BODY()')
m4_define(LINEX_, `do if ($1) {
fstk->estk[fstk->ecnt].pos = 0;
fstk->estk[fstk->ecnt].line = $1;
fstk->estk[fstk->ecnt].ventry = fstk->vcnt;
fstk->estk[fstk->ecnt].vbase = fstk->estk[fstk->ecnt-1].vbase;
fstk->estk[fstk->ecnt].emask = 0;
fstk->ecnt++;
} while (0)')
m4_define(LINE, `
FID_LINE_IN()m4_dnl
const struct f_line * fl$1;
FID_STRUCT_IN()m4_dnl
struct f_inst * f$1;
FID_NEW_ARGS()m4_dnl
, struct f_inst * f$1
FID_NEW_BODY()m4_dnl
whati->f$1 = f$1;
m4_define([[INST_METHOD_NUM_ARGS]],$1)m4_dnl
FID_NEW_METHOD()m4_dnl
struct f_inst *arg$1 = args;
if (args == NULL) cf_error("Not enough arguments"); /* INST_NAME */
args = NULL; /* The rest is the line itself */
FID_METHOD_CALL() , arg$1
FID_DUMP_BODY()m4_dnl
f_dump_line(dreq, item->fl$1, indent + 1);
FID_LINEARIZE_BODY()m4_dnl
item->fl$1 = f_linearize(whati->f$1, $2);
FID_SAME_BODY()m4_dnl
if (!f_same(f1->fl$1, f2->fl$1)) return 0;
FID_ITERATE_BODY()m4_dnl
if (whati->fl$1) BUFFER_PUSH(fit->lines) = whati->fl$1;
FID_INTERPRET_EXEC()m4_dnl
LINEX_(whati->fl$1)
FID_INTERPRET_NEW()m4_dnl
return whati->f$1
FID_INTERPRET_BODY()')
# Some of the instructions have a result. These constructions
# state the result and put it to the right place.
m4_define(RESULT, `RESULT_TYPE([[$1]]) RESULT_([[$1]],[[$2]],[[$3]])')
m4_define(RESULT_, `RESULT_VAL([[ (struct f_val) { .type = $1, .val.$2 = $3 } ]])')
m4_define(RESULT_VAL, `FID_HIC(, [[do { res = $1; fstk->vcnt++; } while (0)]],
[[return fi_constant(what, $1)]])')
m4_define(RESULT_VOID, `RESULT_VAL([[ (struct f_val) { .type = T_VOID } ]])')
m4_define(ERROR,
`m4_errprint(m4___file__:m4___line__: $*
)m4_m4exit(1)')
# This macro specifies result type and makes there are no conflicting definitions
m4_define(RESULT_TYPE,
`m4_ifdef([[INST_RESULT_TYPE]],
[[m4_ifelse(INST_RESULT_TYPE,$1,,[[ERROR([[Multiple type definitions in]] INST_NAME)]])]],
[[m4_define(INST_RESULT_TYPE,$1) RESULT_TYPE_($1)]])')
m4_define(RESULT_TYPE_CHECK,
`m4_ifelse(INST_OUTVAL,0,,
[[m4_ifdef([[INST_RESULT_TYPE]],,[[ERROR([[Missing type definition in]] INST_NAME)]])]])')
m4_define(RESULT_TYPE_, `
FID_NEW_BODY()m4_dnl
what->type = $1;
FID_INTERPRET_BODY()')
# Some common filter instruction members
m4_define(SYMBOL, `FID_MEMBER(struct symbol *, sym, [[strcmp(f1->sym->name, f2->sym->name) || (f1->sym->class != f2->sym->class)]], "symbol %s", item->sym->name)')
m4_define(RTC, `FID_MEMBER(struct rtable_config *, rtc, [[strcmp(f1->rtc->name, f2->rtc->name)]], "route table %s", item->rtc->name)')
m4_define(STATIC_ATTR, `FID_MEMBER(struct f_static_attr, sa, f1->sa.sa_code != f2->sa.sa_code,,)')
m4_define(DYNAMIC_ATTR, `FID_MEMBER(struct f_dynamic_attr, da, f1->da.ea_code != f2->da.ea_code,,)')
m4_define(ACCESS_RTE, `FID_HIC(,[[do { if (!fs->rte) runtime("No route to access"); } while (0)]],NEVER_CONSTANT())')
# Method constructor block
m4_define(METHOD_CONSTRUCTOR, `m4_dnl
FID_NEW_METHOD()m4_dnl
if (args) cf_error("Too many arguments");
m4_define([[INST_IS_METHOD]])
m4_define([[INST_METHOD_NAME]],$1)
FID_INTERPRET_BODY()')
# Short method constructor
# $1 = type
# $2 = name
# $3 = method inputs
# method outputs are always 1
# $4 = code
m4_define(METHOD, `m4_dnl
INST([[FI_METHOD__]]$1[[__]]$2, m4_eval($3 + 1), 1) {
ARG(1, $1);
$4
METHOD_CONSTRUCTOR("$2");
}')
m4_define(METHOD_R, `METHOD($1, $2, 0, [[ RESULT($3, $4, $5) ]])')
# 2) Code wrapping
# The code produced in 1xx temporary diversions is a raw code without
# any auxiliary commands and syntactical structures around. When the
# instruction is done, INST_FLUSH is called. More precisely, it is called
# at the beginning of INST() call and at the end of file.
#
# INST_FLUSH picks all the temporary diversions, wraps their content
# into appropriate headers and structures and saves them into global
# diversions listed:
#
# 4 enum fi_code
# 5 enum fi_code to string
# 6 dump line item
# 7 dump line item callers
# 8 linearize
# 9 same (filter comparator)
# 10 iterate
# 1 union in struct f_inst
# 3 constructors + interpreter
# 11 method constructors
#
# These global diversions contain blocks of code that can be directly
# put into the final file, yet it still can't be written out now as
# every instruction writes to all of these diversions.
# Code wrapping diversion names. Here we want an explicit newline
# after the C comment.
m4_define(FID_ZONE, `m4_divert($1) /* $2 for INST_NAME() */
')
m4_define(FID_INST, `FID_ZONE(1, Instruction structure for config)')
m4_define(FID_LINE, `FID_ZONE(2, Instruction structure for interpreter)')
m4_define(FID_NEW, `FID_ZONE(3, Constructor)')
m4_define(FID_ENUM, `FID_ZONE(4, Code enum)')
m4_define(FID_ENUM_STR, `FID_ZONE(5, Code enum to string)')
m4_define(FID_DUMP, `FID_ZONE(6, Dump line)')
m4_define(FID_DUMP_CALLER, `FID_ZONE(7, Dump line caller)')
m4_define(FID_LINEARIZE, `FID_ZONE(8, Linearize)')
m4_define(FID_SAME, `FID_ZONE(9, Comparison)')
m4_define(FID_ITERATE, `FID_ZONE(10, Iteration)')
m4_define(FID_METHOD, `FID_ZONE(11, Method constructor)')
m4_define(FID_METHOD_SCOPE_INIT, `FID_ZONE(12, Method scope initializator)')
m4_define(FID_METHOD_REGISTER, `FID_ZONE(13, Method registrator)')
# This macro does all the code wrapping. See inline comments.
m4_define(INST_FLUSH, `m4_ifdef([[INST_NAME]], [[
RESULT_TYPE_CHECK()m4_dnl Check for defined RESULT_TYPE()
FID_ENUM()m4_dnl Contents of enum fi_code { ... }
INST_NAME(),
FID_ENUM_STR()m4_dnl Contents of const char * indexed by enum fi_code
[INST_NAME()] = "INST_NAME()",
FID_INST()m4_dnl Anonymous structure inside struct f_inst
struct {
m4_undivert(101)m4_dnl
} i_[[]]INST_NAME();
FID_LINE()m4_dnl Anonymous structure inside struct f_line_item
struct {
m4_undivert(107)m4_dnl
} i_[[]]INST_NAME();
FID_NEW()m4_dnl Constructor and interpreter code together
FID_HIC(
[[m4_dnl Public declaration of constructor in H file
struct f_inst *
m4_undivert(110)m4_dnl
f_new_inst_]]INST_NAME()[[(enum f_instruction_code fi_code
m4_undivert(102)m4_dnl
);]],
[[m4_dnl The one case in The Big Switch inside interpreter
case INST_NAME():
#define whati (&(what->i_]]INST_NAME()[[))
m4_ifelse(m4_eval(INST_INVAL() > 0), 1, [[if (fstk->vcnt < INST_INVAL()) runtime("Stack underflow");
fstk->vcnt -= INST_INVAL();]])
m4_undivert(108)m4_dnl
#undef whati
break;
]],
[[m4_dnl Constructor itself
struct f_inst *
m4_undivert(110)m4_dnl
f_new_inst_]]INST_NAME()[[(enum f_instruction_code fi_code
m4_undivert(102)m4_dnl
)
{
/* Allocate the structure */
struct f_inst *what = fi_new(fi_code);
FID_IFCONST([[uint constargs = 1;]])
/* Initialize all the members */
#define whati (&(what->i_]]INST_NAME()[[))
m4_undivert(103)m4_dnl
/* If not constant, return the instruction itself */
FID_IFCONST([[if (!constargs)]])
return what;
/* Try to pre-calculate the result */
FID_IFCONST([[m4_undivert(108)]])m4_dnl
#undef whati
}
]])
m4_ifdef([[INST_IS_METHOD]],m4_dnl
FID_METHOD()m4_dnl
[[struct f_inst * NONNULL(1)
f_new_method_]]INST_NAME()[[(struct f_inst *obj, struct f_inst *args)
{
/* Unwind the arguments (INST_METHOD_NUM_ARGS) */
m4_undivert(111)m4_dnl
return f_new_inst(INST_NAME, obj
m4_undivert(112)
);
}
FID_METHOD_SCOPE_INIT()m4_dnl
[INST_METHOD_OBJECT_TYPE] = {},
FID_METHOD_REGISTER()m4_dnl
method = lp_allocz(global_root_scope_linpool, sizeof(struct f_method) + INST_METHOD_NUM_ARGS * sizeof(enum f_type));
method->new_inst = f_new_method_]]INST_NAME()[[;
method->arg_num = INST_METHOD_NUM_ARGS;
m4_undivert(113)
f_register_method(INST_METHOD_OBJECT_TYPE, INST_METHOD_NAME, method);
]])m4_dnl
FID_DUMP_CALLER()m4_dnl Case in another big switch used in instruction dumping
case INST_NAME(): f_dump_line_item_]]INST_NAME()[[(dreq, item, indent + 1); break;
FID_DUMP()m4_dnl The dumper itself
m4_ifdef([[FID_DUMP_BODY_EXISTS]],
[[static inline void f_dump_line_item_]]INST_NAME()[[(struct dump_request *dreq, const struct f_line_item *item_, const int indent)]],
[[static inline void f_dump_line_item_]]INST_NAME()[[(struct dump_request *dreq UNUSED, const struct f_line_item *item UNUSED, const int indent UNUSED)]])
m4_undefine([[FID_DUMP_BODY_EXISTS]])
{
#define item (&(item_->i_]]INST_NAME()[[))
m4_undivert(104)m4_dnl
#undef item
}
FID_LINEARIZE()m4_dnl The linearizer
case INST_NAME(): {
#define whati (&(what->i_]]INST_NAME()[[))
#define item (&(dest->items[pos].i_]]INST_NAME()[[))
m4_undivert(105)m4_dnl
#undef whati
#undef item
dest->items[pos].fi_code = what->fi_code;
dest->items[pos].flags = what->flags;
dest->items[pos].lineno = what->lineno;
break;
}
FID_SAME()m4_dnl This code compares two f_line"s while reconfiguring
case INST_NAME():
#define f1 (&(f1_->i_]]INST_NAME()[[))
#define f2 (&(f2_->i_]]INST_NAME()[[))
m4_undivert(106)m4_dnl
#undef f1
#undef f2
break;
FID_ITERATE()m4_dnl The iterator
case INST_NAME():
#define whati (&(what->i_]]INST_NAME()[[))
m4_undivert(109)m4_dnl
#undef whati
break;
m4_divert(-1)FID_FLUSH(101,200)m4_dnl And finally this flushes all the unused diversions
]])')
m4_define(INST, `m4_dnl This macro is called on beginning of each instruction.
INST_FLUSH()m4_dnl First, old data is flushed
m4_define([[INST_NAME]], [[$1]])m4_dnl Then we store instruction name,
m4_define([[INST_INVAL]], [[$2]])m4_dnl instruction input value count,
m4_define([[INST_OUTVAL]], [[$3]])m4_dnl instruction output value count,
m4_undefine([[INST_NEVER_CONSTANT]])m4_dnl reset NEVER_CONSTANT trigger,
m4_undefine([[INST_RESULT_TYPE]])m4_dnl and reset RESULT_TYPE value.
m4_undefine([[INST_IS_METHOD]])m4_dnl and reset method constructor request.
m4_undefine([[INST_METHOD_OBJECT_TYPE]],)m4_dnl reset method object type,
FID_INTERPRET_BODY()m4_dnl By default, every code is interpreter code.
')
# 3) Final preparation
#
# Now we prepare all the code around the global diversions.
# It must be here, not in m4wrap, as we want M4 to mark the code
# by #line directives correctly, not to claim that every single line
# is at the beginning of the m4wrap directive.
#
# This part is split by the final file.
# H for inst-gen.h
# I for inst-interpret.c
# C for inst-gen.c
#
# So we in cycle:
# A. open a diversion
# B. send there some code
# C. close that diversion
# D. flush a global diversion
# E. open another diversion and goto B.
#
# Final diversions
# 200+ completed text before it is flushed to output
# This is a list of output diversions
m4_define(FID_WR_PUT_LIST)
# This macro does the steps C to E, see before.
m4_define(FID_WR_PUT_ALSO, `m4_define([[FID_WR_PUT_LIST]],FID_WR_PUT_LIST()[[FID_WR_DPUT(]]FID_WR_DIDX[[)FID_WR_DPUT(]]$1[[)]])m4_define([[FID_WR_DIDX]],m4_eval(FID_WR_DIDX+1))m4_divert(FID_WR_DIDX)')
# These macros do the splitting between H/I/C
m4_define(FID_WR_DIRECT, `m4_ifelse(TARGET,[[$1]],[[FID_WR_INIT()]],[[FID_WR_STOP()]])')
m4_define(FID_WR_INIT, `m4_define([[FID_WR_DIDX]],200)m4_define([[FID_WR_PUT]],[[FID_WR_PUT_ALSO($]][[@)]])m4_divert(200)')
m4_define(FID_WR_STOP, `m4_define([[FID_WR_PUT]])m4_divert(-1)')
# Here is the direct code to be put into the output files
# together with the undiversions, being hidden under FID_WR_PUT()
m4_changequote([[,]])
FID_WR_DIRECT(I)
FID_WR_PUT(3)
FID_WR_DIRECT(C)
#if defined(__GNUC__) && __GNUC__ >= 6
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmisleading-indentation"
#endif
#include "nest/bird.h"
#include "filter/filter.h"
#include "filter/f-inst.h"
/* Instruction codes to string */
static const char * const f_instruction_name_str[] = {
FID_WR_PUT(5)
};
const char *
f_instruction_name_(enum f_instruction_code fi)
{
if (fi < (sizeof(f_instruction_name_str) / sizeof(f_instruction_name_str[0])))
return f_instruction_name_str[fi];
else
bug("Got unknown instruction code: %d", fi);
}
static inline struct f_inst *
fi_new(enum f_instruction_code fi_code)
{
struct f_inst *what = tmp_allocz(sizeof(struct f_inst));
what->lineno = ifs->lino;
what->size = 1;
what->fi_code = fi_code;
return what;
}
static inline struct f_inst *
fi_constant(struct f_inst *what, struct f_val val)
{
what->fi_code = FI_CONSTANT;
what->i_FI_CONSTANT.val = val;
return what;
}
int
f_const_promotion_(struct f_inst *arg, enum f_type want, int update)
{
if (arg->fi_code != FI_CONSTANT)
return 0;
struct f_val *c = &arg->i_FI_CONSTANT.val;
if ((c->type == T_IP) && ipa_is_ip4(c->val.ip) && (want == T_QUAD)) {
if (update)
*c = (struct f_val) {
.type = T_QUAD,
.val.i = ipa_to_u32(c->val.ip),
};
return 1;
}
else if ((c->type == T_SET) && (!c->val.t) && (want == T_PREFIX_SET)) {
if (update)
*c = f_const_empty_prefix_set;
return 1;
}
return 0;
}
#define v1 whati->f1->i_FI_CONSTANT.val
#define v2 whati->f2->i_FI_CONSTANT.val
#define v3 whati->f3->i_FI_CONSTANT.val
#define vv(i) items[i]->i_FI_CONSTANT.val
#define runtime(fmt, ...) cf_error("filter preevaluation, line %d: " fmt, ifs->lino, ##__VA_ARGS__)
#define fpool cfg_mem
#define falloc(size) cfg_alloc(size)
/* Instruction constructors */
FID_WR_PUT(3)
#undef v1
#undef v2
#undef v3
#undef vv
/* Method constructor wrappers */
FID_WR_PUT(11)
#if defined(__GNUC__) && __GNUC__ >= 6
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Woverride-init"
#endif
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winitializer-overrides"
#endif
static struct sym_scope f_type_method_scopes[] = {
FID_WR_PUT(12)
};
#if defined(__clang__)
#pragma clang diagnostic pop
#endif
#if defined(__GNUC__) && __GNUC__ >= 6
#pragma GCC diagnostic pop
#endif
struct sym_scope *f_type_method_scope(enum f_type t)
{
return (t < ARRAY_SIZE(f_type_method_scopes)) ? &f_type_method_scopes[t] : NULL;
}
static void
f_register_method(enum f_type t, const byte *name, struct f_method *dsc)
{
struct sym_scope *scope = &f_type_method_scopes[t];
struct symbol *sym = cf_find_symbol_scope(scope, name);
if (!sym)
{
sym = cf_new_symbol(scope, global_root_scope_pool, global_root_scope_linpool, name);
sym->class = SYM_METHOD;
}
dsc->sym = sym;
dsc->next = sym->method;
sym->method = dsc;
}
void f_type_methods_register(void)
{
struct f_method *method;
FID_WR_PUT(13)
for (uint i = 0; i < ARRAY_SIZE(f_type_method_scopes); i++)
f_type_method_scopes[i].readonly = 1;
}
/* Line dumpers */
#define INDENT (((const char *) f_dump_line_indent_str) + sizeof(f_dump_line_indent_str) - (indent) - 1)
static const char f_dump_line_indent_str[] = " ";
FID_WR_PUT(6)
void f_dump_line(struct dump_request *dreq, const struct f_line *dest, uint indent)
{
if (!dest) {
RDUMP("%sNo filter line (NULL)\n", INDENT);
return;
}
RDUMP("%sFilter line %p (len=%u)\n", INDENT, dest, dest->len);
for (uint i=0; ilen; i++) {
const struct f_line_item *item = &dest->items[i];
RDUMP("%sInstruction %s at line %u\n", INDENT, f_instruction_name_(item->fi_code), item->lineno);
switch (item->fi_code) {
FID_WR_PUT(7)
default: bug("Unknown instruction %x in f_dump_line", item->fi_code);
}
}
RDUMP("%sFilter line %p dump done\n", INDENT, dest);
}
/* Linearize */
static uint
linearize(struct f_line *dest, const struct f_inst *what, uint pos)
{
for ( ; what; what = what->next) {
switch (what->fi_code) {
FID_WR_PUT(8)
}
pos++;
}
return pos;
}
struct f_line *
f_linearize_concat(const struct f_inst * const inst[], uint count, uint results)
{
uint len = 0;
for (uint i=0; inext)
len += what->size;
struct f_line *out = cfg_allocz(sizeof(struct f_line) + sizeof(struct f_line_item)*len);
for (uint i=0; ilen = linearize(out, inst[i], out->len);
out->results = results;
return out;
}
/* Filter line comparison */
int
f_same(const struct f_line *fl1, const struct f_line *fl2)
{
if ((!fl1) && (!fl2))
return 1;
if ((!fl1) || (!fl2))
return 0;
if (fl1->len != fl2->len)
return 0;
for (uint i=0; ilen; i++) {
#define f1_ (&(fl1->items[i]))
#define f2_ (&(fl2->items[i]))
if (f1_->fi_code != f2_->fi_code)
return 0;
if (f1_->flags != f2_->flags)
return 0;
switch(f1_->fi_code) {
FID_WR_PUT(9)
}
}
#undef f1_
#undef f2_
return 1;
}
/* Part of FI_SWITCH filter iterator */
static void
f_add_tree_lines(const struct f_tree *t, void *fit_)
{
struct filter_iterator * fit = fit_;
if (t->data)
BUFFER_PUSH(fit->lines) = t->data;
}
/* Filter line iterator */
void
f_add_lines(const struct f_line_item *what, struct filter_iterator *fit)
{
switch(what->fi_code) {
FID_WR_PUT(10)
}
}
#if defined(__GNUC__) && __GNUC__ >= 6
#pragma GCC diagnostic pop
#endif
FID_WR_DIRECT(H)
/* Filter instruction codes */
enum f_instruction_code {
FID_WR_PUT(4)m4_dnl
} PACKED;
/* Filter instruction structure for config */
struct f_inst {
struct f_inst *next; /* Next instruction */
enum f_instruction_code fi_code; /* Instruction code */
enum f_instruction_flags flags; /* Flags, instruction-specific */
enum f_type type; /* Type of returned value, if known */
int size; /* How many instructions are underneath */
int lineno; /* Line number */
union {
FID_WR_PUT(1)m4_dnl
};
};
/* Filter line item */
struct f_line_item {
enum f_instruction_code fi_code; /* What to do */
enum f_instruction_flags flags; /* Flags, instruction-specific */
uint lineno; /* Where */
union {
FID_WR_PUT(2)m4_dnl
};
};
/* Instruction constructors */
FID_WR_PUT(3)
m4_divert(-1)
# 4) Shipout
#
# Everything is prepared in FID_WR_PUT_LIST now. Let's go!
m4_changequote(`,')
# Flusher auxiliary macro
m4_define(FID_FLUSH, `m4_ifelse($1,$2,,[[m4_undivert($1)FID_FLUSH(m4_eval($1+1),$2)]])')
# Defining the macro used in FID_WR_PUT_LIST
m4_define(FID_WR_DPUT, `m4_undivert($1)')
# After the code is read and parsed, we:
m4_m4wrap(`INST_FLUSH()m4_divert(0)FID_WR_PUT_LIST()m4_divert(-1)FID_FLUSH(1,200)')
m4_changequote([[,]])
# And now M4 is going to parse f-inst.c, fill the diversions
# and after the file is done, the content of m4_m4wrap (see before)
# is executed.
bird2-2.17.5/filter/f-inst.c 0000664 0000000 0000000 00000137146 15211753245 0015462 0 ustar 00root root 0000000 0000000 /*
* Filters: Instructions themselves
*
* Copyright 1998 Pavel Machek
* Copyright 2018 Maria Matejka
* Copyright 2018 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*
* The filter code goes through several phases:
*
* 1 Parsing
* Flex- and Bison-generated parser decodes the human-readable data into
* a struct f_inst tree. This is an infix tree that was interpreted by
* depth-first search execution in previous versions of the interpreter.
* All instructions have their constructor: f_new_inst(FI_EXAMPLE, ...)
* translates into f_new_inst_FI_EXAMPLE(...) and the types are checked in
* compile time. If the result of the instruction is always the same,
* it's reduced to FI_CONSTANT directly in constructor. This phase also
* counts how many instructions are underlying in means of f_line_item
* fields to know how much we have to allocate in the next phase.
*
* 2 Linearize before interpreting
* The infix tree is always interpreted in the same order. Therefore we
* sort the instructions one after another into struct f_line. Results
* and arguments of these instructions are implicitly put on a value
* stack; e.g. the + operation just takes two arguments from the value
* stack and puts the result on there.
*
* 3 Interpret
* The given line is put on a custom execution stack. If needed (FI_CALL,
* FI_SWITCH, FI_AND, FI_OR, FI_CONDITION, ...), another line is put on top
* of the stack; when that line finishes, the execution continues on the
* older lines on the stack where it stopped before.
*
* 4 Same
* On config reload, the filters have to be compared whether channel
* reload is needed or not. The comparison is done by comparing the
* struct f_line's recursively.
*
* The main purpose of this rework was to improve filter performance
* by making the interpreter non-recursive.
*
* The other outcome is concentration of instruction definitions to
* one place -- right here. You shall define your instruction only here
* and nowhere else.
*
* Beware. This file is interpreted by M4 macros. These macros
* may be more stupid than you could imagine. If something strange
* happens after changing this file, compare the results before and
* after your change (see the Makefile to find out where the results are)
* and see what really happened.
*
* This file is not directly a C source code -> it is a generator input
* for several C sources; every instruction block gets expanded into many
* different places.
*
* All the arguments are processed literally; if you need an argument including comma,
* you have to quote it by [[ ... ]]
*
* What is the syntax here?
* m4_dnl INST(FI_NOP, in, out) { enum value, input args, output args
* m4_dnl ARG(num, type); argument, its id (in data fields) and type accessible by v1, v2, v3
* m4_dnl ARG_ANY(num); argument with no type check accessible by v1, v2, v3
* m4_dnl ARG_TYPE(num, type); just declare the type of argument
* m4_dnl VARARG; variable-length argument list; accessible by vv(i) and whati->varcount
* m4_dnl LINE(num, out); this argument has to be converted to its own f_line
* m4_dnl SYMBOL; symbol handed from config
* m4_dnl STATIC_ATTR; static attribute definition
* m4_dnl DYNAMIC_ATTR; dynamic attribute definition
* m4_dnl RTC; route table config
* m4_dnl ACCESS_RTE; this instruction needs route
* m4_dnl ACCESS_EATTRS; this instruction needs extended attributes
*
* m4_dnl METHOD_CONSTRUCTOR(name); this instruction is in fact a method of the first argument's type; register it with the given name for that type
*
* m4_dnl FID_MEMBER( custom instruction member
* m4_dnl C type, for storage in structs
* m4_dnl name, how the member is named
* m4_dnl comparator for same(), if different, this should be TRUE (CAVEAT)
* m4_dnl dump format string debug -> format string for bvsnprintf
* m4_dnl dump format args appropriate args
* m4_dnl )
*
* m4_dnl RESULT(type, union-field, value); putting this on value stack
* m4_dnl RESULT_(type, union-field, value); like RESULT(), but do not declare the type
* m4_dnl RESULT_VAL(value-struct); pass the struct f_val directly
* m4_dnl RESULT_TYPE(type); just declare the type of result value
* m4_dnl RESULT_VOID; return undef
* m4_dnl }
*
* Note that runtime arguments m4_dnl (ARG*, VARARG) must be defined before
* parse-time arguments m4_dnl (LINE, SYMBOL, ...). During linearization,
* first ones move position in f_line by linearizing arguments first, while
* second ones store data to the current position.
*
* Also note that the { ... } blocks are not respected by M4 at all.
* If you get weird unmatched-brace-pair errors, check what it generated and why.
* What is really considered as one instruction is not the { ... } block
* after m4_dnl INST() but all the code between them.
*
* Other code is just copied into the interpreter part.
*
* It's also possible to declare type methods in a short way:
*
* m4_dnl METHOD(type, method name, argument count, code)
* m4_dnl METHOD_R(type, method name, argument count, result type, union-field, value)
*
* The filter language uses a simple type system, where values have types
* (constants T_*) and also terms (instructions) are statically typed. Our
* static typing is partial (some terms do not declare types of arguments
* or results), therefore it can detect most but not all type errors and
* therefore we still have runtime type checks.
*
* m4_dnl Types of arguments are declared by macros ARG() and ARG_TYPE(),
* m4_dnl types of results are declared by RESULT() and RESULT_TYPE().
* m4_dnl Macros ARG_ANY(), RESULT_() and RESULT_VAL() do not declare types
* m4_dnl themselves, but can be combined with ARG_TYPE() / RESULT_TYPE().
*
* m4_dnl Note that types should be declared only once. If there are
* m4_dnl multiple RESULT() macros in an instruction definition, they must
* m4_dnl use the exact same expression for type, or they should be replaced
* m4_dnl by multiple RESULT_() macros and a common RESULT_TYPE() macro.
* m4_dnl See e.g. FI_EA_GET or FI_MIN instructions.
*
*
* If you are satisfied with this, you don't need to read the following
* detailed description of what is really done with the instruction definitions.
*
* m4_dnl Now let's look under the cover. The code between each INST()
* m4_dnl is copied to several places, namely these (numbered by the M4 diversions
* m4_dnl used in filter/decl.m4):
*
* m4_dnl (102) struct f_inst *f_new_inst(FI_EXAMPLE [[ put it here ]])
* m4_dnl {
* m4_dnl ... (common code)
* m4_dnl (103) [[ put it here ]]
* m4_dnl ...
* m4_dnl if (all arguments are constant)
* m4_dnl (108) [[ put it here ]]
* m4_dnl }
* m4_dnl For writing directly to constructor argument list, use FID_NEW_ARGS.
* m4_dnl For computing something in constructor (103), use FID_NEW_BODY.
* m4_dnl For constant pre-interpretation (108), see below at FID_INTERPRET_BODY.
*
* m4_dnl struct f_inst {
* m4_dnl ... (common fields)
* m4_dnl union {
* m4_dnl struct {
* m4_dnl (101) [[ put it here ]]
* m4_dnl } i_FI_EXAMPLE;
* m4_dnl ...
* m4_dnl };
* m4_dnl };
* m4_dnl This structure is returned from constructor.
* m4_dnl For writing directly to this structure, use FID_STRUCT_IN.
*
* m4_dnl linearize(struct f_line *dest, const struct f_inst *what, uint pos) {
* m4_dnl ...
* m4_dnl switch (what->fi_code) {
* m4_dnl case FI_EXAMPLE:
* m4_dnl (105) [[ put it here ]]
* m4_dnl break;
* m4_dnl }
* m4_dnl }
* m4_dnl This is called when translating from struct f_inst to struct f_line_item.
* m4_dnl For accessing your custom instruction data, use following macros:
* m4_dnl whati -> for accessing (struct f_inst).i_FI_EXAMPLE
* m4_dnl item -> for accessing (struct f_line)[pos].i_FI_EXAMPLE
* m4_dnl For writing directly here, use FID_LINEARIZE_BODY.
*
* m4_dnl (107) struct f_line_item {
* m4_dnl ... (common fields)
* m4_dnl union {
* m4_dnl struct {
* m4_dnl (101) [[ put it here ]]
* m4_dnl } i_FI_EXAMPLE;
* m4_dnl ...
* m4_dnl };
* m4_dnl };
* m4_dnl The same as FID_STRUCT_IN (101) but for the other structure.
* m4_dnl This structure is returned from the linearizer (105).
* m4_dnl For writing directly to this structure, use FID_LINE_IN.
*
* m4_dnl f_dump_line_item_FI_EXAMPLE(struct dump_request *dreq, const struct f_line_item *item, const int indent)
* m4_dnl {
* m4_dnl (104) [[ put it here ]]
* m4_dnl }
* m4_dnl This code dumps the instruction via RDUMP. Note that the argument
* m4_dnl is the linearized instruction; if the instruction has arguments,
* m4_dnl their code has already been linearized and their value is taken
* m4_dnl from the value stack.
* m4_dnl For writing directly here, use FID_DUMP_BODY.
*
* m4_dnl f_same(...)
* m4_dnl {
* m4_dnl switch (f1_->fi_code) {
* m4_dnl case FI_EXAMPLE:
* m4_dnl (106) [[ put it here ]]
* m4_dnl break;
* m4_dnl }
* m4_dnl }
* m4_dnl This code compares the two given instrucions (f1_ and f2_)
* m4_dnl on reconfigure. For accessing your custom instruction data,
* m4_dnl use macros f1 and f2.
* m4_dnl For writing directly here, use FID_SAME_BODY.
*
* m4_dnl f_add_lines(...)
* m4_dnl {
* m4_dnl switch (what_->fi_code) {
* m4_dnl case FI_EXAMPLE:
* m4_dnl (109) [[ put it here ]]
* m4_dnl break;
* m4_dnl }
* m4_dnl }
* m4_dnl This code adds new filter lines reachable from the instruction
* m4_dnl to the filter iterator line buffer. This is for instructions
* m4_dnl that changes conrol flow, like FI_CONDITION or FI_CALL, most
* m4_dnl instructions do not need to update it. It is used in generic
* m4_dnl filter iteration code (FILTER_ITERATE*). For accessing your
* m4_dnl custom instruction data, use macros f1 and f2. For writing
* m4_dnl directly here, use FID_ITERATE_BODY.
*
* m4_dnl interpret(...)
* m4_dnl {
* m4_dnl switch (what->fi_code) {
* m4_dnl case FI_EXAMPLE:
* m4_dnl (108) [[ put it here ]]
* m4_dnl break;
* m4_dnl }
* m4_dnl }
* m4_dnl This code executes the instruction. Every pre-defined macro
* m4_dnl resets the output here. For setting it explicitly,
* m4_dnl use FID_INTERPRET_BODY.
* m4_dnl This code is put on two places; one is the interpreter, the other
* m4_dnl is instruction constructor. If you need to distinguish between
* m4_dnl these two, use FID_INTERPRET_EXEC or FID_INTERPRET_NEW respectively.
* m4_dnl To address the difference between interpreter and constructor
* m4_dnl environments, there are several convenience macros defined:
* m4_dnl runtime() -> for spitting out runtime error like division by zero
* m4_dnl RESULT(...) -> declare result; may overwrite arguments
* m4_dnl v1, v2, v3 -> positional arguments, may be overwritten by RESULT()
* m4_dnl falloc(size) -> allocate memory from the appropriate linpool
* m4_dnl fpool -> the current linpool
* m4_dnl NEVER_CONSTANT-> don't generate pre-interpretation code at all
* m4_dnl ACCESS_RTE -> check that route is available, also NEVER_CONSTANT
* m4_dnl ACCESS_EATTRS -> pre-cache the eattrs; use only with ACCESS_RTE
* m4_dnl f_rta_cow(fs) -> function to call before any change to route should be done
*
* m4_dnl If you are stymied, see FI_CALL or FI_CONSTANT or just search for
* m4_dnl the mentioned macros in this file to see what is happening there in wild.
*
*
* A note about soundness of the type system:
*
* A type system is sound when types of expressions are consistent with
* types of values resulting from evaluation of such expressions. Untyped
* expressions are ok, but badly typed expressions are not sound. So is
* the type system of BIRD filtering code sound? There are some points:
*
* All cases of (one) m4_dnl RESULT() macro are obviously ok, as the macro
* both declares a type and returns a value. One have to check instructions
* that use m4_dnl RESULT_TYPE() macro. There are two issues:
*
* FI_AND, FI_OR - second argument is statically checked to be T_BOOL and
* passed as result without dynamic typecheck, declared to be T_BOOL. If
* an untyped non-bool expression is used as a second argument, then
* the mismatched type is returned.
*
* FI_VAR_GET - soundness depends on consistency of declared symbol types
* and stored values. This is maintained when values are stored by
* FI_VAR_SET, but when they are stored by FI_CALL, only static checking is
* used, so when an untyped expression returning mismatched value is used
* as a function argument, then inconsistent value is stored and subsequent
* FI_VAR_GET would be unsound.
*
* Both of these issues are inconsequential, as mismatched values from
* unsound expressions will be caught by dynamic typechecks like mismatched
* values from untyped expressions.
*
* Also note that FI_CALL is the only expression without properly declared
* result type.
*/
/* Binary operators */
INST(FI_ADD, 2, 1) {
ARG(1,T_INT);
ARG(2,T_INT);
RESULT(T_INT, i, v1.val.i + v2.val.i);
}
INST(FI_SUBTRACT, 2, 1) {
ARG(1,T_INT);
ARG(2,T_INT);
RESULT(T_INT, i, v1.val.i - v2.val.i);
}
INST(FI_MULTIPLY, 2, 1) {
ARG(1,T_INT);
ARG(2,T_INT);
RESULT(T_INT, i, v1.val.i * v2.val.i);
}
INST(FI_DIVIDE, 2, 1) {
ARG(1,T_INT);
ARG(2,T_INT);
if (v2.val.i == 0) runtime( "Mother told me not to divide by 0" );
RESULT(T_INT, i, v1.val.i / v2.val.i);
}
INST(FI_AND, 1, 1) {
ARG(1,T_BOOL);
ARG_TYPE_STATIC(2,T_BOOL);
RESULT_TYPE(T_BOOL);
if (v1.val.i)
LINE(2,1);
else
RESULT_VAL(v1);
}
INST(FI_OR, 1, 1) {
ARG(1,T_BOOL);
ARG_TYPE_STATIC(2,T_BOOL);
RESULT_TYPE(T_BOOL);
if (!v1.val.i)
LINE(2,1);
else
RESULT_VAL(v1);
}
INST(FI_PAIR_CONSTRUCT, 2, 1) {
ARG(1,T_INT);
ARG(2,T_INT);
uint u1 = v1.val.i;
uint u2 = v2.val.i;
if ((u1 > 0xFFFF) || (u2 > 0xFFFF))
runtime( "Can't operate with value out of bounds in pair constructor" );
RESULT(T_PAIR, i, (u1 << 16) | u2);
}
INST(FI_EC_CONSTRUCT, 2, 1) {
ARG_ANY(1);
ARG(2, T_INT);
FID_MEMBER(enum ec_subtype, ecs, f1->ecs != f2->ecs, "ec subtype %s", ec_subtype_str(item->ecs));
int ipv4_used;
u32 key, val;
if (v1.type == T_INT) {
ipv4_used = 0; key = v1.val.i;
}
else if (v1.type == T_QUAD) {
ipv4_used = 1; key = v1.val.i;
}
/* IP->Quad implicit conversion */
else if (val_is_ip4(&v1)) {
ipv4_used = 1; key = ipa_to_u32(v1.val.ip);
}
else
runtime("Argument 1 of EC constructor must be integer or IPv4 address, got 0x%02x", v1.type);
val = v2.val.i;
if (ecs == EC_GENERIC)
RESULT(T_EC, ec, ec_generic(key, val));
else if (ipv4_used)
if (val <= 0xFFFF)
RESULT(T_EC, ec, ec_ip4(ecs, key, val));
else
runtime("4-byte value %u can't be used with IP-address key in extended community", val);
else if (key < 0x10000)
RESULT(T_EC, ec, ec_as2(ecs, key, val));
else
if (val <= 0xFFFF)
RESULT(T_EC, ec, ec_as4(ecs, key, val));
else
runtime("4-byte value %u can't be used with 4-byte ASN in extended community", val);
}
INST(FI_LC_CONSTRUCT, 3, 1) {
ARG(1, T_INT);
ARG(2, T_INT);
ARG(3, T_INT);
RESULT(T_LC, lc, [[(lcomm) { v1.val.i, v2.val.i, v3.val.i }]]);
}
INST(FI_PATHMASK_CONSTRUCT, 0, 1) {
VARARG;
struct f_path_mask *pm = falloc(sizeof(struct f_path_mask) + whati->varcount * sizeof(struct f_path_mask_item));
pm->len = whati->varcount;
for (uint i=0; ivarcount; i++) {
switch (vv(i).type) {
case T_PATH_MASK_ITEM:
if (vv(i).val.pmi.kind == PM_LOOP)
{
if (i == 0)
runtime("Path mask iterator '+' cannot be first");
/* We want PM_LOOP as prefix operator */
pm->item[i] = pm->item[i - 1];
pm->item[i - 1] = vv(i).val.pmi;
break;
}
pm->item[i] = vv(i).val.pmi;
break;
case T_INT:
pm->item[i] = (struct f_path_mask_item) {
.asn = vv(i).val.i,
.kind = PM_ASN,
};
break;
case T_SET:
if (!path_set_type(vv(i).val.t))
runtime("Only integer sets allowed in path mask");
pm->item[i] = (struct f_path_mask_item) {
.set = vv(i).val.t,
.kind = PM_ASN_SET,
};
break;
default:
runtime( "Error resolving path mask template: value not an integer" );
}
}
RESULT(T_PATH_MASK, path_mask, pm);
}
/* Relational operators */
INST(FI_NEQ, 2, 1) {
ARG_ANY(1);
ARG_ANY(2);
ARG_PREFER_SAME_TYPE(1, 2);
RESULT(T_BOOL, i, !val_same(&v1, &v2));
}
INST(FI_EQ, 2, 1) {
ARG_ANY(1);
ARG_ANY(2);
ARG_PREFER_SAME_TYPE(1, 2);
RESULT(T_BOOL, i, val_same(&v1, &v2));
}
INST(FI_LT, 2, 1) {
ARG_ANY(1);
ARG_ANY(2);
ARG_SAME_TYPE(1, 2);
int i = val_compare(&v1, &v2);
if (i == F_CMP_ERROR)
runtime( "Can't compare values of incompatible types" );
RESULT(T_BOOL, i, (i == -1));
}
INST(FI_LTE, 2, 1) {
ARG_ANY(1);
ARG_ANY(2);
ARG_SAME_TYPE(1, 2);
int i = val_compare(&v1, &v2);
if (i == F_CMP_ERROR)
runtime( "Can't compare values of incompatible types" );
RESULT(T_BOOL, i, (i != 1));
}
INST(FI_NOT, 1, 1) {
ARG(1,T_BOOL);
RESULT(T_BOOL, i, !v1.val.i);
}
INST(FI_MATCH, 2, 1) {
ARG_ANY(1);
ARG_ANY(2);
int i = val_in_range(&v1, &v2);
if (i == F_CMP_ERROR)
runtime( "~ applied on unknown type pair" );
RESULT(T_BOOL, i, !!i);
}
INST(FI_NOT_MATCH, 2, 1) {
ARG_ANY(1);
ARG_ANY(2);
int i = val_in_range(&v1, &v2);
if (i == F_CMP_ERROR)
runtime( "!~ applied on unknown type pair" );
RESULT(T_BOOL, i, !i);
}
INST(FI_DEFINED, 1, 1) {
ARG_ANY(1);
RESULT(T_BOOL, i, (v1.type != T_VOID) && !val_is_undefined(v1));
}
METHOD_R(T_NET, type, T_ENUM_NET_TYPE, i, v1.val.net->type);
METHOD_R(T_IP, is_v4, T_BOOL, i, ipa_is_ip4(v1.val.ip));
/* Add initialized variable */
INST(FI_VAR_INIT, 1, 0) {
NEVER_CONSTANT;
ARG_ANY(1);
SYMBOL;
ARG_TYPE(1, sym->class & 0xff);
/* New variable is always the last on stack */
uint pos = curline.vbase + sym->offset;
fstk->vstk[pos] = v1;
fstk->vcnt = pos + 1;
}
/* Add uninitialized variable */
INST(FI_VAR_INIT0, 0, 0) {
NEVER_CONSTANT;
SYMBOL;
/* New variable is always the last on stack */
uint pos = curline.vbase + sym->offset;
fstk->vstk[pos] = val_empty(sym->class & 0xff);
fstk->vcnt = pos + 1;
}
/* Set to indirect value prepared in v1 */
INST(FI_VAR_SET, 1, 0) {
NEVER_CONSTANT;
ARG_ANY(1);
SYMBOL;
ARG_TYPE(1, sym->class & 0xff);
fstk->vstk[curline.vbase + sym->offset] = v1;
}
INST(FI_VAR_GET, 0, 1) {
SYMBOL;
NEVER_CONSTANT;
RESULT_TYPE(sym->class & 0xff);
RESULT_VAL(fstk->vstk[curline.vbase + sym->offset]);
}
INST(FI_CONSTANT, 0, 1) {
FID_MEMBER(
struct f_val,
val,
[[ !val_same(&(f1->val), &(f2->val)) ]],
"value %s",
val_dump(&(item->val))
);
RESULT_TYPE(val.type);
RESULT_VAL(val);
}
METHOD_R(T_PATH, empty, T_PATH, ad, &null_adata);
METHOD_R(T_CLIST, empty, T_CLIST, ad, &null_adata);
METHOD_R(T_ECLIST, empty, T_ECLIST, ad, &null_adata);
METHOD_R(T_LCLIST, empty, T_LCLIST, ad, &null_adata);
/* Common loop begin instruction, always created by f_for_cycle() */
INST(FI_FOR_LOOP_START, 0, 3) {
NEVER_CONSTANT;
SYMBOL;
/* Repeat the instruction which called us */
ASSERT_DIE(fstk->ecnt > 1);
prevline.pos--;
/* There should be exactly three items on the value stack to be taken care of */
fstk->vcnt += 3;
/* And these should also stay there after we finish for the caller instruction */
curline.ventry += 3;
/* Assert the iterator variable positioning */
ASSERT_DIE(curline.vbase + sym->offset == fstk->vcnt - 1);
/* The result type declaration makes no sense here but is needed */
RESULT_TYPE(T_VOID);
}
/* Type-specific for_next iterators */
INST(FI_PATH_FOR_NEXT, 3, 0) {
NEVER_CONSTANT;
ARG(1, T_PATH);
if (as_path_walk(v1.val.ad, &v2.val.i, &v3.val.i))
LINE(2,0);
METHOD_CONSTRUCTOR("!for_next");
}
INST(FI_CLIST_FOR_NEXT, 3, 0) {
NEVER_CONSTANT;
ARG(1, T_CLIST);
if (int_set_walk(v1.val.ad, &v2.val.i, &v3.val.i))
LINE(2,0);
METHOD_CONSTRUCTOR("!for_next");
}
INST(FI_ECLIST_FOR_NEXT, 3, 0) {
NEVER_CONSTANT;
ARG(1, T_ECLIST);
if (ec_set_walk(v1.val.ad, &v2.val.i, &v3.val.ec))
LINE(2,0);
METHOD_CONSTRUCTOR("!for_next");
}
INST(FI_LCLIST_FOR_NEXT, 3, 0) {
NEVER_CONSTANT;
ARG(1, T_LCLIST);
if (lc_set_walk(v1.val.ad, &v2.val.i, &v3.val.lc))
LINE(2,0);
METHOD_CONSTRUCTOR("!for_next");
}
INST(FI_ROUTES_BLOCK_FOR_NEXT, 3, 0) {
NEVER_CONSTANT;
ARG(1, T_ROUTES_BLOCK);
if (!v2.type)
v2 = v1;
if (v2.val.rte)
{
v3.val.rte = v2.val.rte;
v2.val.rte = v2.val.rte->next;
LINE(2,0);
}
METHOD_CONSTRUCTOR("!for_next");
}
INST(FI_CONDITION, 1, 0) {
ARG(1, T_BOOL);
if (v1.val.i)
LINE(2,0);
else
LINE(3,0);
}
INST(FI_PRINT, 1, 0) {
NEVER_CONSTANT;
ARG_ANY(1);
if (!(fs->flags & FF_SILENT))
val_format(&v1, &fs->buf);
}
INST(FI_FLUSH, 0, 0) {
NEVER_CONSTANT;
if (!(fs->flags & FF_SILENT))
/* After log_commit, the buffer is reset */
log_commit(*L_INFO, &fs->buf);
}
INST(FI_DIE, 0, 0) {
NEVER_CONSTANT;
FID_MEMBER(enum filter_return, fret, f1->fret != f2->fret, "%s", filter_return_str(item->fret));
switch (whati->fret) {
case F_ACCEPT: /* Should take care about turning ACCEPT into MODIFY */
case F_ERROR:
case F_REJECT: /* Maybe print complete route along with reason to reject route? */
return fret; /* We have to return now, no more processing. */
default:
bug( "unknown return type: Can't happen");
}
}
INST(FI_RTA_GET, 1, 1) {
{
ACCESS_RTE;
ARG(1, T_ROUTE);
STATIC_ATTR;
struct rta *rta = v1.val.rte ? v1.val.rte->attrs : (*fs->rte)->attrs;
switch (sa.sa_code)
{
case SA_FROM: RESULT(sa.f_type, ip, rta->from); break;
case SA_GW: RESULT(sa.f_type, ip, rta->nh.gw); break;
case SA_NET: RESULT(sa.f_type, net, (*fs->rte)->net->n.addr); break;
case SA_PROTO: RESULT(sa.f_type, s, (*fs->rte)->src->proto->name); break;
case SA_SOURCE: RESULT(sa.f_type, i, rta->source); break;
case SA_SCOPE: RESULT(sa.f_type, i, rta->scope); break;
case SA_DEST: RESULT(sa.f_type, i, rta->dest); break;
case SA_IFNAME: RESULT(sa.f_type, s, rta->nh.iface ? rta->nh.iface->name : ""); break;
case SA_IFINDEX: RESULT(sa.f_type, i, rta->nh.iface ? rta->nh.iface->index : 0); break;
case SA_WEIGHT: RESULT(sa.f_type, i, rta->nh.weight + 1); break;
case SA_PREF: RESULT(sa.f_type, i, rta->pref); break;
case SA_GW_MPLS: RESULT(sa.f_type, i, rta->nh.labels ? rta->nh.label[0] : MPLS_NULL); break;
case SA_GW_MPLS_STACK:
{
uint len = rta->nh.labels * sizeof(u32);
struct adata *list = falloc(sizeof(struct adata) + len);
list->length = len;
memcpy(list->data, rta->nh.label, len);
RESULT(sa.f_type, ad, list);
break;
}
case SA_ONLINK: RESULT(sa.f_type, i, rta->nh.flags & RNF_ONLINK ? 1 : 0); break;
default:
bug("Invalid static attribute access (%u/%u)", sa.f_type, sa.sa_code);
}
}
}
INST(FI_RTA_SET, 1, 0) {
ACCESS_RTE;
ARG_ANY(1);
STATIC_ATTR;
ARG_TYPE(1, sa.f_type);
f_rta_cow(fs);
{
struct rta *rta = (*fs->rte)->attrs;
switch (sa.sa_code)
{
case SA_FROM:
rta->from = v1.val.ip;
break;
case SA_GW:
{
ip_addr ip = v1.val.ip;
struct iface *ifa = ipa_is_link_local(ip) || (rta->nh.flags & RNF_ONLINK) ? rta->nh.iface : NULL;
neighbor *n = neigh_find((*fs->rte)->src->proto, ip, ifa, (rta->nh.flags & RNF_ONLINK) ? NEF_ONLINK : 0);
if (!n || (n->scope == SCOPE_HOST))
runtime( "Invalid gw address" );
rta->dest = RTD_UNICAST;
rta->nh.gw = ip;
rta->nh.iface = n->iface;
rta->nh.next = NULL;
rta->hostentry = NULL;
rta->nh.labels = 0;
}
break;
case SA_SCOPE:
rta->scope = v1.val.i;
break;
case SA_DEST:
{
int i = v1.val.i;
if ((i != RTD_BLACKHOLE) && (i != RTD_UNREACHABLE) && (i != RTD_PROHIBIT))
runtime( "Destination can be changed only to blackhole, unreachable or prohibit" );
rta->dest = i;
rta->nh.gw = IPA_NONE;
rta->nh.iface = NULL;
rta->nh.next = NULL;
rta->hostentry = NULL;
rta->nh.labels = 0;
}
break;
case SA_IFNAME:
{
struct iface *ifa = if_find_by_name(v1.val.s);
if (!ifa)
runtime( "Invalid iface name" );
rta->dest = RTD_UNICAST;
rta->nh.gw = IPA_NONE;
rta->nh.iface = ifa;
rta->nh.next = NULL;
rta->hostentry = NULL;
rta->nh.labels = 0;
}
break;
case SA_GW_MPLS:
{
if (v1.val.i >= 0x100000)
runtime( "Invalid MPLS label" );
if (v1.val.i != MPLS_NULL)
{
rta->nh.label[0] = v1.val.i;
rta->nh.labels = 1;
}
else
rta->nh.labels = 0;
rta->nh.labels_orig = rta->hostentry ? rta->nh.labels : 0;
}
break;
case SA_GW_MPLS_STACK:
{
int len = int_set_get_size(v1.val.ad);
u32 *l = int_set_get_data(v1.val.ad);
if (len > MPLS_MAX_LABEL_STACK)
runtime("Too many MPLS labels in stack (%d)", len);
int i;
for (i = 0; i < len; i++)
{
u32 label = l[i];
if (label >= 0x100000)
runtime("Invalid MPLS label (%u)", label);
/* Ignore rest of label stack if implicit-NULL label (3) is set */
if (label == MPLS_NULL)
break;
rta->nh.label[i] = label;
}
rta->nh.labels = i;
rta->nh.labels_orig = rta->hostentry ? i : 0;
}
break;
case SA_WEIGHT:
{
int i = v1.val.i;
if (i < 1 || i > 256)
runtime( "Setting weight value out of bounds" );
if (rta->dest != RTD_UNICAST)
runtime( "Setting weight needs regular nexthop " );
/* Set weight on all next hops */
for (struct nexthop *nh = &rta->nh; nh; nh = nh->next)
nh->weight = i - 1;
}
break;
case SA_PREF:
rta->pref = v1.val.i;
break;
case SA_ONLINK:
{
if (v1.val.i)
rta->nh.flags |= RNF_ONLINK;
else
rta->nh.flags &= ~RNF_ONLINK;
}
break;
default:
bug("Invalid static attribute access (%u/%u)", sa.f_type, sa.sa_code);
}
}
}
INST(FI_EA_GET, 1, 1) { /* Access to extended attributes */
ACCESS_RTE;
ACCESS_EATTRS;
ARG(1, T_ROUTE);
DYNAMIC_ATTR;
RESULT_TYPE(da.f_type);
{
struct ea_list *eal = v1.val.rte ? v1.val.rte->attrs->eattrs : *fs->eattrs;
eattr *e = ea_find(eal, da.ea_code);
if (!e) {
RESULT_VAL(val_empty(da.f_type));
break;
}
switch (e->type & EAF_TYPE_MASK) {
case EAF_TYPE_INT:
RESULT_(da.f_type, i, e->u.data);
break;
case EAF_TYPE_ROUTER_ID:
RESULT_(T_QUAD, i, e->u.data);
break;
case EAF_TYPE_OPAQUE:
if (da.f_type == T_ENUM_EMPTY)
RESULT_(T_ENUM_EMPTY, i, 0);
else
RESULT_(T_BYTESTRING, ad, e->u.ptr);
break;
case EAF_TYPE_IP_ADDRESS:
RESULT_(T_IP, ip, *((ip_addr *) e->u.ptr->data));
break;
case EAF_TYPE_AS_PATH:
RESULT_(T_PATH, ad, e->u.ptr);
break;
case EAF_TYPE_BITFIELD:
RESULT_(T_BOOL, i, !!(e->u.data & (1u << da.bit)));
break;
case EAF_TYPE_INT_SET:
RESULT_(T_CLIST, ad, e->u.ptr);
break;
case EAF_TYPE_EC_SET:
RESULT_(T_ECLIST, ad, e->u.ptr);
break;
case EAF_TYPE_LC_SET:
RESULT_(T_LCLIST, ad, e->u.ptr);
break;
case EAF_TYPE_STRING:
RESULT_(T_STRING, s, (const char *) e->u.ptr->data);
break;
default:
bug("Unknown dynamic attribute type");
}
}
}
INST(FI_EA_SET, 1, 0) {
ACCESS_RTE;
ACCESS_EATTRS;
ARG_ANY(1);
DYNAMIC_ATTR;
ARG_TYPE(1, da.f_type);
FID_NEW_BODY;
if (da.f_type == T_ENUM_EMPTY)
cf_error("Setting opaque attribute is not allowed");
FID_INTERPRET_BODY;
{
struct ea_list *l = lp_alloc(fs->pool, sizeof(struct ea_list) + sizeof(eattr));
l->next = NULL;
l->flags = EALF_SORTED;
l->count = 1;
l->attrs[0].id = da.ea_code;
l->attrs[0].flags = da.flags;
l->attrs[0].type = da.type;
l->attrs[0].originated = 1;
l->attrs[0].fresh = 1;
l->attrs[0].undef = 0;
switch (da.type) {
case EAF_TYPE_INT:
case EAF_TYPE_ROUTER_ID:
l->attrs[0].u.data = v1.val.i;
break;
case EAF_TYPE_IP_ADDRESS:;
int len = sizeof(ip_addr);
struct adata *ad = lp_alloc(fs->pool, sizeof(struct adata) + len);
ad->length = len;
(* (ip_addr *) ad->data) = v1.val.ip;
l->attrs[0].u.ptr = ad;
break;
case EAF_TYPE_OPAQUE:
case EAF_TYPE_AS_PATH:
case EAF_TYPE_INT_SET:
case EAF_TYPE_EC_SET:
case EAF_TYPE_LC_SET:
l->attrs[0].u.ptr = v1.val.ad;
break;
case EAF_TYPE_STRING:;
struct adata *d = lp_alloc_adata(fs->pool, strlen(v1.val.s) + 1);
memcpy(d->data, v1.val.s, d->length);
l->attrs[0].u.ptr = d;
break;
case EAF_TYPE_BITFIELD:
{
/* First, we have to find the old value */
eattr *e = ea_find(*fs->eattrs, da.ea_code);
u32 data = e ? e->u.data : 0;
if (v1.val.i)
l->attrs[0].u.data = data | (1u << da.bit);
else
l->attrs[0].u.data = data & ~(1u << da.bit);
}
break;
default:
bug("Unknown dynamic attribute type");
}
f_rta_cow(fs);
l->next = *fs->eattrs;
*fs->eattrs = l;
}
}
INST(FI_EA_UNSET, 0, 0) {
DYNAMIC_ATTR;
ACCESS_RTE;
ACCESS_EATTRS;
f_rta_cow(fs);
ea_unset_attr(fs->eattrs, fs->pool, 1, da.ea_code);
}
/* Get length of */
METHOD_R(T_NET, len, T_INT, i, net_pxlen(v1.val.net));
METHOD_R(T_PATH, len, T_INT, i, as_path_getlen(v1.val.ad));
METHOD_R(T_CLIST, len, T_INT, i, int_set_get_size(v1.val.ad));
METHOD_R(T_ECLIST, len, T_INT, i, ec_set_get_size(v1.val.ad));
METHOD_R(T_LCLIST, len, T_INT, i, lc_set_get_size(v1.val.ad));
INST(FI_NET_SRC, 1, 1) { /* Get src prefix */
ARG(1, T_NET);
METHOD_CONSTRUCTOR("src");
net_addr_union *net = (void *) v1.val.net;
net_addr *src = falloc(sizeof(net_addr_ip6));
const byte *part;
switch(v1.val.net->type) {
case NET_FLOW4:
part = flow4_get_part(&net->flow4, FLOW_TYPE_SRC_PREFIX);
if (part)
net_fill_ip4(src, flow_read_ip4_part(part), flow_read_pxlen(part));
else
net_fill_ip4(src, IP4_NONE, 0);
break;
case NET_FLOW6:
part = flow6_get_part(&net->flow6, FLOW_TYPE_SRC_PREFIX);
if (part)
net_fill_ip6(src, flow_read_ip6_part(part), flow_read_pxlen(part));
else
net_fill_ip6(src, IP6_NONE, 0);
break;
case NET_IP6_SADR:
net_fill_ip6(src, net->ip6_sadr.src_prefix, net->ip6_sadr.src_pxlen);
break;
default:
runtime( "Flow or SADR expected" );
}
RESULT(T_NET, net, src);
}
INST(FI_NET_DST, 1, 1) { /* Get dst prefix */
ARG(1, T_NET);
METHOD_CONSTRUCTOR("dst");
net_addr_union *net = (void *) v1.val.net;
net_addr *dst = falloc(sizeof(net_addr_ip6));
const byte *part;
switch(v1.val.net->type) {
case NET_FLOW4:
part = flow4_get_part(&net->flow4, FLOW_TYPE_DST_PREFIX);
if (part)
net_fill_ip4(dst, flow_read_ip4_part(part), flow_read_pxlen(part));
else
net_fill_ip4(dst, IP4_NONE, 0);
break;
case NET_FLOW6:
part = flow6_get_part(&net->flow6, FLOW_TYPE_DST_PREFIX);
if (part)
net_fill_ip6(dst, flow_read_ip6_part(part), flow_read_pxlen(part));
else
net_fill_ip6(dst, IP6_NONE, 0);
break;
case NET_IP6_SADR:
net_fill_ip6(dst, net->ip6_sadr.dst_prefix, net->ip6_sadr.dst_pxlen);
break;
default:
runtime( "Flow or SADR expected" );
}
RESULT(T_NET, net, dst);
}
/* Get ROA max prefix length */
METHOD(T_NET, maxlen, 0, [[
if (!net_is_roa(v1.val.net))
runtime( "ROA expected" );
RESULT(T_INT, i, (v1.val.net->type == NET_ROA4) ?
((net_addr_roa4 *) v1.val.net)->max_pxlen :
((net_addr_roa6 *) v1.val.net)->max_pxlen);
]]);
/* Get ROA ASN */
METHOD(T_NET, asn, 0, [[
if (!net_is_roa(v1.val.net))
runtime( "ROA expected" );
RESULT(T_INT, i, (v1.val.net->type == NET_ROA4) ?
((net_addr_roa4 *) v1.val.net)->asn :
((net_addr_roa6 *) v1.val.net)->asn);
]]);
/* Convert prefix to IP */
METHOD_R(T_NET, ip, T_IP, ip, net_prefix(v1.val.net));
INST(FI_ROUTE_DISTINGUISHER, 1, 1) {
ARG(1, T_NET);
METHOD_CONSTRUCTOR("rd");
if (!net_is_vpn(v1.val.net))
runtime( "VPN address expected" );
RESULT(T_RD, rd, net_rd(v1.val.net));
}
/* Get first ASN from AS PATH */
METHOD_R(T_PATH, first, T_INT, i, ({ u32 as = 0; as_path_get_first(v1.val.ad, &as); as; }));
/* Get last ASN from AS PATH */
METHOD_R(T_PATH, last, T_INT, i, ({ u32 as = 0; as_path_get_last(v1.val.ad, &as); as; }));
/* Get last ASN from non-aggregated part of AS PATH */
METHOD_R(T_PATH, last_nonaggregated, T_INT, i, as_path_get_last_nonaggregated(v1.val.ad));
/* Get ASN part from the standard community ASN */
METHOD_R(T_PAIR, asn, T_INT, i, v1.val.i >> 16);
/* Get data part from the standard community */
METHOD_R(T_PAIR, data, T_INT, i, v1.val.i & 0xFFFF);
/* Get ASN part from the large community */
METHOD_R(T_LC, asn, T_INT, i, v1.val.lc.asn);
/* Get data1 part from the large community */
METHOD_R(T_LC, data1, T_INT, i, v1.val.lc.ldp1);
/* Get data2 part from the large community */
METHOD_R(T_LC, data2, T_INT, i, v1.val.lc.ldp2);
/* Get minimum element from clist */
METHOD_R(T_CLIST, min, T_PAIR, i, ({ u32 val = 0; int_set_min(v1.val.ad, &val); val; }));
/* Get maximum element from clist */
METHOD_R(T_CLIST, max, T_PAIR, i, ({ u32 val = 0; int_set_max(v1.val.ad, &val); val; }));
/* Get minimum element from eclist */
METHOD_R(T_ECLIST, min, T_EC, ec, ({ u64 val = 0; ec_set_min(v1.val.ad, &val); val; }));
/* Get maximum element from eclist */
METHOD_R(T_ECLIST, max, T_EC, ec, ({ u64 val = 0; ec_set_max(v1.val.ad, &val); val; }));
/* Get minimum element from lclist */
METHOD_R(T_LCLIST, min, T_LC, lc, ({ lcomm val = {}; lc_set_min(v1.val.ad, &val); val; }));
/* Get maximum element from lclist */
METHOD_R(T_LCLIST, max, T_LC, lc, ({ lcomm val = {}; lc_set_max(v1.val.ad, &val); val; }));
INST(FI_RETURN, 1, 0) {
NEVER_CONSTANT;
/* Acquire the return value */
ARG_ANY(1);
uint retpos = fstk->vcnt;
/* Drop every sub-block including ourselves */
do fstk->ecnt--;
while ((fstk->ecnt > 0) && !(fstk->estk[fstk->ecnt].emask & FE_RETURN));
/* Now we are at the caller frame; if no such, try to convert to accept/reject. */
if (!fstk->ecnt)
{
if (fstk->vstk[retpos].type == T_BOOL)
return (fstk->vstk[retpos].val.i) ? F_ACCEPT : F_REJECT;
else
runtime("Can't return non-bool from non-function");
}
/* Set the value stack position, overwriting the former implicit void */
fstk->vcnt = fstk->estk[fstk->ecnt].ventry - 1;
/* Copy the return value */
RESULT_VAL(fstk->vstk[retpos]);
}
INST(FI_CALL, 0, 1) {
NEVER_CONSTANT;
VARARG;
SYMBOL;
RESULT_TYPE(sym->function->return_type);
FID_NEW_BODY()
ASSERT(sym->class == SYM_FUNCTION);
if (whati->varcount != sym->function->args)
cf_error("Function '%s' expects %u arguments, got %u arguments",
sym->name, sym->function->args, whati->varcount);
/* Typecheck individual arguments */
struct f_inst *a = fvar;
struct f_arg *b = sym->function->arg_list;
for (uint i = 1; a && b; a = a->next, b = b->next, i++)
{
enum f_type b_type = b->arg->class & 0xff;
if (a->type && (a->type != b_type) && !f_const_promotion(a, b_type))
cf_error("Argument %u of '%s' must be %s, got %s",
i, sym->name, f_type_name(b_type), f_type_name(a->type));
}
ASSERT(!a && !b);
/* Add implicit void slot for the return value */
struct f_inst *tmp = f_new_inst(FI_CONSTANT, (struct f_val) { .type = T_VOID });
tmp->next = whati->fvar;
whati->fvar = tmp;
what->size += tmp->size;
/* Mark recursive calls, they have dummy f_line */
if (!sym->function->len)
what->flags |= FIF_RECURSIVE;
FID_SAME_BODY()
if (!(f1->sym->flags & SYM_FLAG_SAME) && !(f1_->flags & FIF_RECURSIVE))
return 0;
FID_ITERATE_BODY()
if (!(what->flags & FIF_RECURSIVE))
BUFFER_PUSH(fit->lines) = whati->sym->function;
FID_INTERPRET_BODY()
/* Push the body on stack */
LINEX(sym->function);
curline.vbase = curline.ventry;
curline.emask |= FE_RETURN;
/* Arguments on stack */
fstk->vcnt += sym->function->args;
/* Storage for local variables */
memset(&(fstk->vstk[fstk->vcnt]), 0, sizeof(struct f_val) * sym->function->vars);
fstk->vcnt += sym->function->vars;
}
INST(FI_DROP_RESULT, 1, 0) {
NEVER_CONSTANT;
ARG_ANY(1);
}
INST(FI_SWITCH, 1, 0) {
ARG_ANY(1);
FID_MEMBER(struct f_tree *, tree, [[!same_tree(f1->tree, f2->tree)]], "tree %p", item->tree);
FID_LINEARIZE_BODY()
/* Linearize all branches in switch */
struct f_inst *last_inst = NULL;
struct f_line *last_line = NULL;
for (struct f_tree *t = whati->tree; t; t = t->left)
{
if (t->data != last_inst)
{
last_inst = t->data;
last_line = f_linearize(t->data, 0);
}
t->data = last_line;
}
/* Balance the tree */
item->tree = build_tree(whati->tree);
FID_ITERATE_BODY()
tree_walk(whati->tree, f_add_tree_lines, fit);
FID_INTERPRET_BODY()
/* In parse-time use find_tree_linear(), in runtime use find_tree() */
const struct f_tree *t = FID_HIC(,find_tree,find_tree_linear)(tree, &v1);
if (!t) {
v1.type = T_VOID;
t = FID_HIC(,find_tree,find_tree_linear)(tree, &v1);
if (!t) {
debug( "No else statement?\n");
FID_HIC(,break,return NULL);
}
}
LINEX(t->data);
}
INST(FI_IP_MASK, 2, 1) { /* IP.MASK(val) */
ARG(1, T_IP);
ARG(2, T_INT);
METHOD_CONSTRUCTOR("mask");
RESULT(T_IP, ip, [[ ipa_is_ip4(v1.val.ip) ?
ipa_from_ip4(ip4_and(ipa_to_ip4(v1.val.ip), ip4_mkmask(v2.val.i))) :
ipa_from_ip6(ip6_and(ipa_to_ip6(v1.val.ip), ip6_mkmask(v2.val.i))) ]]);
}
INST(FI_PATH_PREPEND, 2, 1) { /* Path prepend */
ARG(1, T_PATH);
ARG(2, T_INT);
METHOD_CONSTRUCTOR("prepend");
RESULT(T_PATH, ad, [[ as_path_prepend(fpool, v1.val.ad, v2.val.i) ]]);
}
/* Community list add */
INST(FI_CLIST_ADD_PAIR, 2, 1) {
ARG(1, T_CLIST);
ARG(2, T_PAIR);
METHOD_CONSTRUCTOR("add");
RESULT(T_CLIST, ad, [[ int_set_add(fpool, v1.val.ad, v2.val.i) ]]);
}
/* Hack for gw_mpls_list */
INST(FI_CLIST_ADD_INT, 2, 1) {
ARG(1, T_CLIST);
ARG(2, T_INT);
METHOD_CONSTRUCTOR("add");
RESULT(T_CLIST, ad, [[ int_set_add(fpool, v1.val.ad, v2.val.i) ]]);
}
INST(FI_CLIST_ADD_IP, 2, 1) {
ARG(1, T_CLIST);
ARG(2, T_IP);
METHOD_CONSTRUCTOR("add");
FID_NEW_BODY();
/* IP->Quad implicit conversion, must be before FI_CLIST_ADD_QUAD */
cf_warn("Method add(clist, ip) is deprecated, please use add(clist, quad)");
FID_INTERPRET_BODY();
if (!val_is_ip4(&v2)) runtime("Mismatched IP type");
RESULT(T_CLIST, ad, [[ int_set_add(fpool, v1.val.ad, ipa_to_u32(v2.val.ip)) ]]);
}
INST(FI_CLIST_ADD_QUAD, 2, 1) {
ARG(1, T_CLIST);
ARG(2, T_QUAD);
METHOD_CONSTRUCTOR("add");
RESULT(T_CLIST, ad, [[ int_set_add(fpool, v1.val.ad, v2.val.i) ]]);
}
INST(FI_CLIST_ADD_CLIST, 2, 1) {
ARG(1, T_CLIST);
ARG(2, T_CLIST);
METHOD_CONSTRUCTOR("add");
RESULT(T_CLIST, ad, [[ int_set_union(fpool, v1.val.ad, v2.val.ad) ]]);
}
INST(FI_ECLIST_ADD_EC, 2, 1) {
ARG(1, T_ECLIST);
ARG(2, T_EC);
METHOD_CONSTRUCTOR("add");
RESULT(T_ECLIST, ad, [[ ec_set_add(fpool, v1.val.ad, v2.val.ec) ]]);
}
INST(FI_ECLIST_ADD_ECLIST, 2, 1) {
ARG(1, T_ECLIST);
ARG(2, T_ECLIST);
METHOD_CONSTRUCTOR("add");
RESULT(T_ECLIST, ad, [[ ec_set_union(fpool, v1.val.ad, v2.val.ad) ]]);
}
INST(FI_LCLIST_ADD_LC, 2, 1) {
ARG(1, T_LCLIST);
ARG(2, T_LC);
METHOD_CONSTRUCTOR("add");
RESULT(T_LCLIST, ad, [[ lc_set_add(fpool, v1.val.ad, v2.val.lc) ]]);
}
INST(FI_LCLIST_ADD_LCLIST, 2, 1) {
ARG(1, T_LCLIST);
ARG(2, T_LCLIST);
METHOD_CONSTRUCTOR("add");
RESULT(T_LCLIST, ad, [[ lc_set_union(fpool, v1.val.ad, v2.val.ad) ]]);
}
INST(FI_PATH_DELETE_INT, 2, 1) {
ARG(1, T_PATH);
ARG(2, T_INT);
METHOD_CONSTRUCTOR("delete");
RESULT(T_PATH, ad, [[ as_path_filter(fpool, v1.val.ad, &v2, 0) ]]);
}
INST(FI_PATH_DELETE_SET, 2, 1) {
ARG(1, T_PATH);
ARG(2, T_SET);
METHOD_CONSTRUCTOR("delete");
if (!path_set_type(v2.val.t))
runtime("Mismatched set type");
RESULT(T_PATH, ad, [[ as_path_filter(fpool, v1.val.ad, &v2, 0) ]]);
}
/* Community list delete */
INST(FI_CLIST_DELETE_PAIR, 2, 1) {
ARG(1, T_CLIST);
ARG(2, T_PAIR);
METHOD_CONSTRUCTOR("delete");
RESULT(T_CLIST, ad, [[ int_set_del(fpool, v1.val.ad, v2.val.i) ]]);
}
/* Hack for gw_mpls_list */
INST(FI_CLIST_DELETE_INT, 2, 1) {
ARG(1, T_CLIST);
ARG(2, T_INT);
METHOD_CONSTRUCTOR("delete");
RESULT(T_CLIST, ad, [[ int_set_del(fpool, v1.val.ad, v2.val.i) ]]);
}
INST(FI_CLIST_DELETE_IP, 2, 1) {
ARG(1, T_CLIST);
ARG(2, T_IP);
METHOD_CONSTRUCTOR("delete");
FID_NEW_BODY();
/* IP->Quad implicit conversion, must be before FI_CLIST_DELETE_QUAD */
cf_warn("Method delete(clist, ip) is deprecated, please use delete(clist, quad)");
FID_INTERPRET_BODY();
if (!val_is_ip4(&v2)) runtime("Mismatched IP type");
RESULT(T_CLIST, ad, [[ int_set_del(fpool, v1.val.ad, ipa_to_u32(v2.val.ip)) ]]);
}
INST(FI_CLIST_DELETE_QUAD, 2, 1) {
ARG(1, T_CLIST);
ARG(2, T_QUAD);
METHOD_CONSTRUCTOR("delete");
RESULT(T_CLIST, ad, [[ int_set_del(fpool, v1.val.ad, v2.val.i) ]]);
}
INST(FI_CLIST_DELETE_CLIST, 2, 1) {
ARG(1, T_CLIST);
ARG(2, T_CLIST);
METHOD_CONSTRUCTOR("delete");
RESULT(T_CLIST, ad, [[ clist_filter(fpool, v1.val.ad, &v2, 0) ]]);
}
INST(FI_CLIST_DELETE_SET, 2, 1) {
ARG(1, T_CLIST);
ARG(2, T_SET);
METHOD_CONSTRUCTOR("delete");
if (!clist_set_type(v2.val.t, &(struct f_val){}))
runtime("Mismatched set type");
RESULT(T_CLIST, ad, [[ clist_filter(fpool, v1.val.ad, &v2, 0) ]]);
}
INST(FI_ECLIST_DELETE_EC, 2, 1) {
ARG(1, T_ECLIST);
ARG(2, T_EC);
METHOD_CONSTRUCTOR("delete");
RESULT(T_ECLIST, ad, [[ ec_set_del(fpool, v1.val.ad, v2.val.ec) ]]);
}
INST(FI_ECLIST_DELETE_ECLIST, 2, 1) {
ARG(1, T_ECLIST);
ARG(2, T_ECLIST);
METHOD_CONSTRUCTOR("delete");
RESULT(T_ECLIST, ad, [[ eclist_filter(fpool, v1.val.ad, &v2, 0) ]]);
}
INST(FI_ECLIST_DELETE_SET, 2, 1) {
ARG(1, T_ECLIST);
ARG(2, T_SET);
METHOD_CONSTRUCTOR("delete");
if (!eclist_set_type(v2.val.t))
runtime("Mismatched set type");
RESULT(T_ECLIST, ad, [[ eclist_filter(fpool, v1.val.ad, &v2, 0) ]]);
}
INST(FI_LCLIST_DELETE_LC, 2, 1) {
ARG(1, T_LCLIST);
ARG(2, T_LC);
METHOD_CONSTRUCTOR("delete");
RESULT(T_LCLIST, ad, [[ lc_set_del(fpool, v1.val.ad, v2.val.lc) ]]);
}
INST(FI_LCLIST_DELETE_LCLIST, 2, 1) {
ARG(1, T_LCLIST);
ARG(2, T_LCLIST);
METHOD_CONSTRUCTOR("delete");
RESULT(T_LCLIST, ad, [[ lclist_filter(fpool, v1.val.ad, &v2, 0) ]]);
}
INST(FI_LCLIST_DELETE_SET, 2, 1) {
ARG(1, T_LCLIST);
ARG(2, T_SET);
METHOD_CONSTRUCTOR("delete");
if (!lclist_set_type(v2.val.t))
runtime("Mismatched set type");
RESULT(T_LCLIST, ad, [[ lclist_filter(fpool, v1.val.ad, &v2, 0) ]]);
}
INST(FI_PATH_FILTER_SET, 2, 1) {
ARG(1, T_PATH);
ARG(2, T_SET);
METHOD_CONSTRUCTOR("filter");
if (!path_set_type(v2.val.t))
runtime("Mismatched set type");
RESULT(T_PATH, ad, [[ as_path_filter(fpool, v1.val.ad, &v2, 1) ]]);
}
INST(FI_CLIST_FILTER_CLIST, 2, 1) {
ARG(1, T_CLIST);
ARG(2, T_CLIST);
METHOD_CONSTRUCTOR("filter");
RESULT(T_CLIST, ad, [[ clist_filter(fpool, v1.val.ad, &v2, 1) ]]);
}
INST(FI_CLIST_FILTER_SET, 2, 1) {
ARG(1, T_CLIST);
ARG(2, T_SET);
METHOD_CONSTRUCTOR("filter");
if (!clist_set_type(v2.val.t, &(struct f_val){}))
runtime("Mismatched set type");
RESULT(T_CLIST, ad, [[ clist_filter(fpool, v1.val.ad, &v2, 1) ]]);
}
INST(FI_ECLIST_FILTER_ECLIST, 2, 1) {
ARG(1, T_ECLIST);
ARG(2, T_ECLIST);
METHOD_CONSTRUCTOR("filter");
RESULT(T_ECLIST, ad, [[ eclist_filter(fpool, v1.val.ad, &v2, 1) ]]);
}
INST(FI_ECLIST_FILTER_SET, 2, 1) {
ARG(1, T_ECLIST);
ARG(2, T_SET);
METHOD_CONSTRUCTOR("filter");
if (!eclist_set_type(v2.val.t))
runtime("Mismatched set type");
RESULT(T_ECLIST, ad, [[ eclist_filter(fpool, v1.val.ad, &v2, 1) ]]);
}
INST(FI_LCLIST_FILTER_LCLIST, 2, 1) {
ARG(1, T_LCLIST);
ARG(2, T_LCLIST);
METHOD_CONSTRUCTOR("filter");
RESULT(T_LCLIST, ad, [[ lclist_filter(fpool, v1.val.ad, &v2, 1) ]]);
}
INST(FI_LCLIST_FILTER_SET, 2, 1) {
ARG(1, T_LCLIST);
ARG(2, T_SET);
METHOD_CONSTRUCTOR("filter");
if (!lclist_set_type(v2.val.t))
runtime("Mismatched set type");
RESULT(T_LCLIST, ad, [[ lclist_filter(fpool, v1.val.ad, &v2, 1) ]]);
}
INST(FI_ROA_CHECK_IMPLICIT, 0, 1) { /* ROA Check */
NEVER_CONSTANT;
RTC(1);
struct rtable *table = rtc->table;
ACCESS_RTE;
ACCESS_EATTRS;
const net_addr *net = (*fs->rte)->net->n.addr;
/* We ignore temporary attributes, probably not a problem here */
/* 0x02 is a value of BA_AS_PATH, we don't want to include BGP headers */
eattr *e = ea_find(*fs->eattrs, EA_CODE(PROTOCOL_BGP, 0x02));
if (!e || ((e->type & EAF_TYPE_MASK) != EAF_TYPE_AS_PATH))
runtime("Missing AS_PATH attribute");
u32 as = 0;
as_path_get_last(e->u.ptr, &as);
if (!table)
runtime("Missing ROA table");
if (table->addr_type != NET_ROA4 && table->addr_type != NET_ROA6)
runtime("Table type must be either ROA4 or ROA6");
if (table->addr_type != (net->type == NET_IP4 ? NET_ROA4 : NET_ROA6))
RESULT(T_ENUM_ROA, i, ROA_UNKNOWN); /* Prefix and table type mismatch */
else
RESULT(T_ENUM_ROA, i, [[ net_roa_check(table, net, as) ]]);
}
INST(FI_ROA_CHECK_EXPLICIT, 2, 1) { /* ROA Check */
NEVER_CONSTANT;
ARG(1, T_NET);
ARG(2, T_INT);
RTC(3);
struct rtable *table = rtc->table;
u32 as = v2.val.i;
if (!table)
runtime("Missing ROA table");
if (table->addr_type != NET_ROA4 && table->addr_type != NET_ROA6)
runtime("Table type must be either ROA4 or ROA6");
if (table->addr_type != (v1.val.net->type == NET_IP4 ? NET_ROA4 : NET_ROA6))
RESULT(T_ENUM_ROA, i, ROA_UNKNOWN); /* Prefix and table type mismatch */
else
RESULT(T_ENUM_ROA, i, [[ net_roa_check(table, v1.val.net, as) ]]);
}
INST(FI_ASPA_CHECK_EXPLICIT, 2, 1) { /* ASPA Check */
NEVER_CONSTANT;
ARG(1, T_PATH);
ARG(2, T_BOOL);
RTC(3);
struct rtable *table = rtc->table;
if (!table)
runtime("Missing ASPA table");
if (table->addr_type != NET_ASPA)
runtime("Table type must be ASPA");
RESULT(T_ENUM_ASPA, i, [[ aspa_check(table, v1.val.ad, v2.val.i) ]]);
}
INST(FI_FROM_HEX, 1, 1) { /* Convert hex text to bytestring */
ARG(1, T_STRING);
int len = bstrhextobin(v1.val.s, NULL);
if (len < 0)
runtime("Invalid hex string");
struct adata *bs;
bs = falloc(sizeof(struct adata) + len);
bs->length = bstrhextobin(v1.val.s, bs->data);
ASSERT(bs->length == (size_t) len);
RESULT(T_BYTESTRING, bs, bs);
}
INST(FI_FORMAT, 1, 1) { /* Format */
ARG_ANY(1);
RESULT(T_STRING, s, val_format_str(fpool, &v1));
}
INST(FI_ASSERT, 1, 0) { /* Birdtest Assert */
NEVER_CONSTANT;
ARG(1, T_BOOL);
FID_MEMBER(char *, s, [[strcmp(f1->s, f2->s)]], "string %s", item->s);
ASSERT(s);
if (!bt_assert_hook)
runtime("No bt_assert hook registered, can't assert");
bt_assert_hook(v1.val.i, what);
}
bird2-2.17.5/filter/f-inst.h 0000664 0000000 0000000 00000012544 15211753245 0015461 0 ustar 00root root 0000000 0000000 /*
* BIRD Internet Routing Daemon -- Filter instructions
*
* (c) 1999 Pavel Machek
* (c) 2018--2019 Maria Matejka
*
* Can be freely distributed and used under the terms of the GNU GPL.
*
* Filter interpreter data structures and internal API.
* See filter/f-inst.c for documentation.
*/
#ifndef _BIRD_F_INST_H_
#define _BIRD_F_INST_H_
#include "nest/bird.h"
#include "conf/conf.h"
#include "filter/filter.h"
#include "filter/data.h"
#include "lib/buffer.h"
#include "lib/flowspec.h"
#include "lib/string.h"
/* Flags for instructions */
enum f_instruction_flags {
FIF_RECURSIVE = 1, /* FI_CALL: function is directly recursive */
} PACKED;
/* Include generated filter instruction declarations */
#include "filter/inst-gen.h"
#define f_new_inst(...) MACRO_CONCAT_AFTER(f_new_inst_, MACRO_FIRST(__VA_ARGS__))(__VA_ARGS__)
/* Convert the instruction back to the enum name */
const char *f_instruction_name_(enum f_instruction_code fi);
static inline const char *f_instruction_name(enum f_instruction_code fi)
{ return f_instruction_name_(fi) + 3; }
int f_const_promotion_(struct f_inst *arg, enum f_type want, int update);
static inline int f_const_promotion(struct f_inst *arg, enum f_type want)
{ return f_const_promotion_(arg, want, 1); }
static inline int f_try_const_promotion(struct f_inst *arg, enum f_type want)
{ return f_const_promotion_(arg, want, 0); }
struct f_arg {
struct symbol *arg;
struct f_arg *next;
};
/* Filter structures for execution */
/* Line of instructions to be unconditionally executed one after another */
struct f_line {
uint len; /* Line length */
u8 args; /* Function: Args required */
u8 vars;
u8 results; /* Results left on stack: cmd -> 0, term -> 1 */
u8 return_type; /* Type which the function returns */
struct f_arg *arg_list;
struct f_line_item items[0]; /* The items themselves */
};
/* Convert the f_inst infix tree to the f_line structures */
struct f_line *f_linearize_concat(const struct f_inst * const inst[], uint count, uint results);
static inline struct f_line *f_linearize(const struct f_inst *root, uint results)
{ return f_linearize_concat(&root, 1, results); }
void f_dump_line(struct dump_request *, const struct f_line *, uint indent);
/* Recursive iteration over filter instructions */
struct filter_iterator {
BUFFER_(const struct f_line *) lines;
};
void f_add_lines(const struct f_line_item *what, struct filter_iterator *fit);
#define FILTER_ITERATE_INIT(fit, filter, pool) \
({ \
BUFFER_INIT((fit)->lines, (pool), 32); \
BUFFER_PUSH((fit)->lines) = (filter)->root; \
})
#define FILTER_ITERATE(fit, fi) ({ \
const struct f_line *fl_; \
while (!BUFFER_EMPTY((fit)->lines)) \
{ \
BUFFER_POP((fit)->lines); \
fl_ = (fit)->lines.data[(fit)->lines.used]; \
for (uint i_ = 0; i_ < fl_->len; i_++) \
{ \
const struct f_line_item *fi = &fl_->items[i_]; \
f_add_lines(fi, (fit));
#define FILTER_ITERATE_END } } })
#define FILTER_ITERATE_CLEANUP(fit) \
({ \
mb_free((fit)->lines.data); \
memset((fit), 0, sizeof(struct filter_iterator)); \
})
struct filter *f_new_where(struct f_inst *);
struct f_inst *f_dispatch_method(struct symbol *sym, struct f_inst *obj, struct f_inst *args, int skip);
struct f_inst *f_dispatch_method_x(const char *name, enum f_type t, struct f_inst *obj, struct f_inst *args);
struct f_inst *f_for_cycle(struct symbol *var, struct f_inst *term, struct f_inst *block);
struct f_inst *f_print(struct f_inst *vars, int flush, enum filter_return fret);
static inline struct f_dynamic_attr f_new_dynamic_attr(u8 type, enum f_type f_type, uint code) /* Type as core knows it, type as filters know it, and code of dynamic attribute */
{ return (struct f_dynamic_attr) { .type = type, .f_type = f_type, .ea_code = code }; } /* f_type currently unused; will be handy for static type checking */
static inline struct f_dynamic_attr f_new_dynamic_attr_bit(u8 bit, enum f_type f_type, uint code) /* Type as core knows it, type as filters know it, and code of dynamic attribute */
{ return (struct f_dynamic_attr) { .type = EAF_TYPE_BITFIELD, .bit = bit, .f_type = f_type, .ea_code = code }; } /* f_type currently unused; will be handy for static type checking */
static inline struct f_static_attr f_new_static_attr(int f_type, int code, int readonly)
{ return (struct f_static_attr) { .f_type = f_type, .sa_code = code, .readonly = readonly }; }
static inline int f_type_attr(int f_type) {
switch (f_type) {
case T_INT: return EAF_TYPE_INT;
case T_IP: return EAF_TYPE_IP_ADDRESS;
case T_QUAD: return EAF_TYPE_ROUTER_ID;
case T_PATH: return EAF_TYPE_AS_PATH;
case T_CLIST: return EAF_TYPE_INT_SET;
case T_ECLIST: return EAF_TYPE_EC_SET;
case T_LCLIST: return EAF_TYPE_LC_SET;
case T_BYTESTRING: return EAF_TYPE_OPAQUE;
default:
cf_error("Custom route attribute of unsupported type");
}
}
/* Hook for call bt_assert() function in configuration */
extern void (*bt_assert_hook)(int result, const struct f_line_item *assert);
/* Bird Tests */
struct f_bt_test_suite {
node n; /* Node in config->tests */
const struct f_line *fn; /* Root of function */
const struct f_line *cmp; /* Compare to this function */
const char *fn_name; /* Name of test */
const char *dsc; /* Description */
int result; /* Desired result */
};
#endif
bird2-2.17.5/filter/f-util.c 0000664 0000000 0000000 00000022001 15211753245 0015441 0 ustar 00root root 0000000 0000000 /*
* Filters: utility functions
*
* Copyright 1998 Pavel Machek
* 2017 Jan Maria Matejka
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "nest/bird.h"
#include "conf/conf.h"
#include "filter/filter.h"
#include "filter/f-inst.h"
#include "lib/idm.h"
#include "nest/protocol.h"
#include "nest/route.h"
#define P(a,b) ((a<<8) | b)
const char *
filter_name(const struct filter *filter)
{
if (!filter)
return "ACCEPT";
else if (filter == FILTER_REJECT)
return "REJECT";
else if (!filter->sym)
return "(unnamed)";
else
return filter->sym->name;
}
struct filter *
f_new_where(struct f_inst *where)
{
struct f_inst *cond = f_new_inst(FI_CONDITION, where,
f_new_inst(FI_DIE, F_ACCEPT),
f_new_inst(FI_DIE, F_REJECT));
struct filter *f = cfg_allocz(sizeof(struct filter));
f->root = f_linearize(cond, 0);
return f;
}
static inline int
f_match_signature(const struct f_method *dsc, struct f_inst *args)
{
int i, arg_num = (int) dsc->arg_num;
for (i = 1; args && (i < arg_num); args = args->next, i++)
if (dsc->args_type[i] && (args->type != dsc->args_type[i]) &&
!f_try_const_promotion(args, dsc->args_type[i]))
return 0;
return !args && !(i < arg_num);
}
/* Variant of f_match_signature(), optimized for error reporting */
static inline void
f_match_signature_err(const struct f_method *dsc, struct f_inst *args, int *pos, int *want, int *got)
{
int i, arg_num = (int) dsc->arg_num;
for (i = 1; args && (i < arg_num); args = args->next, i++)
if (dsc->args_type[i] && (args->type != dsc->args_type[i]) &&
!f_try_const_promotion(args, dsc->args_type[i]))
break;
*pos = i;
*want = (i < arg_num) ? dsc->args_type[i] : T_NONE;
*got = args ? args->type : T_NONE;
}
struct f_inst *
f_dispatch_method(struct symbol *sym, struct f_inst *obj, struct f_inst *args, int skip)
{
/* Find match */
for (const struct f_method *dsc = sym->method; dsc; dsc = dsc->next)
if (f_match_signature(dsc, args))
return dsc->new_inst(obj, args);
/* No valid match - format error message */
int best_pos = -1; /* Longest argument position with partial match */
int best_got = 0; /* Received type at best partial match position */
int best_count = 0; /* Number of partial matches at best position */
const int best_max = 8; /* Max number of reported types */
int best_want[best_max]; /* Expected types at best position */
for (const struct f_method *dsc = sym->method; dsc; dsc = dsc->next)
{
int pos, want, got;
f_match_signature_err(dsc, args, &pos, &want, &got);
/* Ignore shorter match */
if (pos < best_pos)
continue;
/* Found longer match, reset existing results */
if (pos > best_pos)
{
best_pos = pos;
best_got = got;
best_count = 0;
}
/* Skip duplicates */
for (int i = 0; i < best_count; i++)
if (best_want[i] == want)
goto next;
/* Skip if we have enough types */
if (best_count >= best_max)
continue;
/* Add new expected type */
best_want[best_count] = want;
best_count++;
next:;
}
/* There is at least one method */
ASSERT(best_pos >= 0 && best_count > 0);
/* Update best_pos for printing */
best_pos = best_pos - skip + 1;
if (!best_got)
cf_error("Cannot infer type of argument %d of '%s', please assign it to a variable", best_pos, sym->name);
/* Format list of expected types */
buffer tbuf;
STACK_BUFFER_INIT(tbuf, 128);
for (int i = 0; i < best_count; i++)
buffer_print(&tbuf, " / %s", best_want[i] ? f_type_name(best_want[i]) : "any");
char *types = tbuf.start + 3;
char *dots = (best_count >= best_max) || (tbuf.pos == tbuf.end) ? " / ..." : "";
cf_error("Argument %d of '%s' expected %s%s, got %s",
best_pos, sym->name, types, dots, f_type_name(best_got));
}
struct f_inst *
f_dispatch_method_x(const char *name, enum f_type t, struct f_inst *obj, struct f_inst *args)
{
struct sym_scope *scope = f_type_method_scope(t);
struct symbol *sym = cf_find_symbol_scope(scope, name);
if (!sym)
cf_error("Cannot dispatch method '%s'", name);
return f_dispatch_method(sym, obj, args, 0);
}
struct f_inst *
f_for_cycle(struct symbol *var, struct f_inst *term, struct f_inst *block)
{
ASSERT((var->class & ~0xff) == SYM_VARIABLE);
ASSERT(term->next == NULL);
/* Static type check */
if (term->type == T_VOID)
cf_error("Cannot infer type of FOR expression, please assign it to a variable");
enum f_type el_type = f_type_element_type(term->type);
struct sym_scope *scope = el_type ? f_type_method_scope(term->type) : NULL;
struct symbol *ms = scope ? cf_find_symbol_scope(scope, "!for_next") : NULL;
if (!ms)
cf_error("Type %s is not iterable, can't be used in FOR", f_type_name(term->type));
if (var->class != (SYM_VARIABLE | el_type))
cf_error("Loop variable '%s' in FOR must be of type %s, got %s",
var->name, f_type_name(el_type), f_type_name(var->class & 0xff));
/* Push the iterator auxiliary value onto stack */
struct f_inst *iter = term->next = f_new_inst(FI_CONSTANT, (struct f_val) {});
/* Initialize the iterator variable */
iter->next = f_new_inst(FI_CONSTANT, (struct f_val) { .type = el_type });
/* Prepend the loop block with loop beginning instruction */
struct f_inst *loop_start = f_new_inst(FI_FOR_LOOP_START, var);
loop_start->next = block;
return ms->method->new_inst(term, loop_start);
}
struct f_inst *
f_print(struct f_inst *vars, int flush, enum filter_return fret)
{
#define AX(...) do { struct f_inst *_tmp = f_new_inst(__VA_ARGS__); _tmp->next = output; output = _tmp; } while (0)
struct f_inst *output = NULL;
if (fret != F_NOP)
AX(FI_DIE, fret);
if (flush)
AX(FI_FLUSH);
while (vars)
{
struct f_inst *tmp = vars;
vars = vars->next;
tmp->next = NULL;
AX(FI_PRINT, tmp);
}
return output;
#undef AX
}
#define CA_KEY(n) n->name, n->fda.type
#define CA_NEXT(n) n->next
#define CA_EQ(na,ta,nb,tb) (!strcmp(na,nb) && (ta == tb))
#define CA_FN(n,t) (mem_hash(n, strlen(n)) ^ (t*0xaae99453U))
#define CA_ORDER 8 /* Fixed */
struct ca_storage {
struct ca_storage *next;
struct f_dynamic_attr fda;
u32 uc;
char name[0];
};
HASH(struct ca_storage) ca_hash;
static struct idm ca_idm;
static struct ca_storage **ca_storage;
static uint ca_storage_max;
static void
ca_free(resource *r)
{
struct custom_attribute *ca = (void *) r;
struct ca_storage *cas = HASH_FIND(ca_hash, CA, ca->name, ca->fda->type);
ASSERT(cas);
ca->name = NULL;
ca->fda = NULL;
if (!--cas->uc) {
uint id = EA_CUSTOM_ID(cas->fda.ea_code);
idm_free(&ca_idm, id);
HASH_REMOVE(ca_hash, CA, cas);
ca_storage[id] = NULL;
mb_free(cas);
}
}
static void
ca_dump(struct dump_request *dreq, resource *r)
{
struct custom_attribute *ca = (void *) r;
RDUMP("name \"%s\" id 0x%04x ea_type 0x%02x f_type 0x%02x\n",
ca->name, ca->fda->ea_code, ca->fda->type, ca->fda->f_type);
}
static struct resclass ca_class = {
.name = "Custom attribute",
.size = sizeof(struct custom_attribute),
.free = ca_free,
.dump = ca_dump,
.lookup = NULL,
.memsize = NULL,
};
struct custom_attribute *
ca_lookup(pool *p, const char *name, int f_type)
{
int ea_type;
switch (f_type) {
case T_INT:
ea_type = EAF_TYPE_INT;
break;
case T_IP:
ea_type = EAF_TYPE_IP_ADDRESS;
break;
case T_QUAD:
ea_type = EAF_TYPE_ROUTER_ID;
break;
case T_PATH:
ea_type = EAF_TYPE_AS_PATH;
break;
case T_CLIST:
ea_type = EAF_TYPE_INT_SET;
break;
case T_ECLIST:
ea_type = EAF_TYPE_EC_SET;
break;
case T_LCLIST:
ea_type = EAF_TYPE_LC_SET;
break;
case T_STRING:
ea_type = EAF_TYPE_STRING;
break;
case T_BYTESTRING:
ea_type = EAF_TYPE_OPAQUE;
break;
default:
cf_error("Custom route attribute of unsupported type");
}
static int inited = 0;
if (!inited) {
idm_init(&ca_idm, config_pool, 8);
HASH_INIT(ca_hash, config_pool, CA_ORDER);
ca_storage_max = 256;
ca_storage = mb_allocz(config_pool, sizeof(struct ca_storage *) * ca_storage_max);
inited++;
}
struct ca_storage *cas = HASH_FIND(ca_hash, CA, name, ea_type);
if (cas) {
cas->uc++;
} else {
uint id = idm_alloc(&ca_idm);
if (id >= EA_CUSTOM_BIT)
cf_error("Too many custom attributes.");
if (id >= ca_storage_max) {
ca_storage_max *= 2;
ca_storage = mb_realloc(ca_storage, sizeof(struct ca_storage *) * ca_storage_max * 2);
}
cas = mb_allocz(config_pool, sizeof(struct ca_storage) + strlen(name) + 1);
cas->fda = f_new_dynamic_attr(ea_type, f_type, EA_CUSTOM(id));
cas->uc = 1;
strcpy(cas->name, name);
ca_storage[id] = cas;
HASH_INSERT(ca_hash, CA, cas);
}
struct custom_attribute *ca = ralloc(p, &ca_class);
ca->fda = &(cas->fda);
ca->name = cas->name;
return ca;
}
const char *
ea_custom_name(uint ea)
{
uint id = EA_CUSTOM_ID(ea);
if (id >= ca_storage_max)
return NULL;
if (!ca_storage[id])
return NULL;
return ca_storage[id]->name;
}
bird2-2.17.5/filter/filter.c 0000664 0000000 0000000 00000034255 15211753245 0015544 0 ustar 00root root 0000000 0000000 /*
* Filters: utility functions
*
* Copyright 1998 Pavel Machek
*
* Can be freely distributed and used under the terms of the GNU GPL.
*
*/
/**
* DOC: Filters
*
* You can find sources of the filter language in |filter/|
* directory. File |filter/config.Y| contains filter grammar and basically translates
* the source from user into a tree of &f_inst structures. These trees are
* later interpreted using code in |filter/filter.c|.
*
* A filter is represented by a tree of &f_inst structures, later translated
* into lists called &f_line. All the instructions are defined and documented
* in |filter/f-inst.c| definition file.
*
* Filters use a &f_val structure for their data. Each &f_val
* contains type and value (types are constants prefixed with %T_).
* Look into |filter/data.h| for more information and appropriate calls.
*/
#undef LOCAL_DEBUG
#include "nest/bird.h"
#include "lib/lists.h"
#include "lib/resource.h"
#include "lib/socket.h"
#include "lib/string.h"
#include "lib/unaligned.h"
#include "lib/ip.h"
#include "lib/net.h"
#include "lib/flowspec.h"
#include "nest/route.h"
#include "nest/protocol.h"
#include "nest/iface.h"
#include "nest/attrs.h"
#include "conf/conf.h"
#include "filter/filter.h"
#include "filter/f-inst.h"
#include "filter/data.h"
/* Exception bits */
enum f_exception {
FE_RETURN = 0x1,
};
struct filter_stack {
/* Value stack for execution */
#define F_VAL_STACK_MAX 4096
uint vcnt; /* Current value stack size; 0 for empty */
uint ecnt; /* Current execute stack size; 0 for empty */
struct f_val vstk[F_VAL_STACK_MAX]; /* The stack itself */
/* Instruction stack for execution */
#define F_EXEC_STACK_MAX 4096
struct {
const struct f_line *line; /* The line that is being executed */
uint pos; /* Instruction index in the line */
uint ventry; /* Value stack depth on entry */
uint vbase; /* Where to index variable positions from */
enum f_exception emask; /* Exception mask */
} estk[F_EXEC_STACK_MAX];
};
/* Internal filter state, to be allocated on stack when executing filters */
struct filter_state {
/* Stacks needed for execution */
struct filter_stack *stack;
/* The route we are processing. This may be NULL to indicate no route available. */
struct rte **rte;
/* The old rta to be freed after filters are done. */
struct rta *old_rta;
/* Cached pointer to ea_list */
struct ea_list **eattrs;
/* Linpool for adata allocation */
struct linpool *pool;
/* Buffer for log output */
struct buffer buf;
/* Pointers to routes we are aggregating */
const struct f_val *val;
/* Filter execution flags */
int flags;
};
_Thread_local static struct filter_state filter_state;
_Thread_local static struct filter_stack filter_stack;
void (*bt_assert_hook)(int result, const struct f_line_item *assert);
static inline void f_cache_eattrs(struct filter_state *fs)
{
fs->eattrs = &((*fs->rte)->attrs->eattrs);
}
static inline void f_rte_cow(struct filter_state *fs)
{
if (!((*fs->rte)->flags & REF_COW))
return;
*fs->rte = rte_cow(*fs->rte);
}
/*
* rta_cow - prepare rta for modification by filter
*/
static void
f_rta_cow(struct filter_state *fs)
{
if (!rta_is_cached((*fs->rte)->attrs))
return;
/* Prepare to modify rte */
f_rte_cow(fs);
/* Store old rta to free it later, it stores reference from rte_cow() */
fs->old_rta = (*fs->rte)->attrs;
/*
* Get shallow copy of rta. Fields eattrs and nexthops of rta are shared
* with fs->old_rta (they will be copied when the cached rta will be obtained
* at the end of f_run()), also the lock of hostentry is inherited (we
* suppose hostentry is not changed by filters).
*/
(*fs->rte)->attrs = rta_do_cow((*fs->rte)->attrs, fs->pool);
/* Re-cache the ea_list */
f_cache_eattrs(fs);
}
static struct tbf rl_runtime_err = TBF_DEFAULT_LOG_LIMITS;
/**
* interpret
* @fs: filter state
* @what: filter to interpret
*
* Interpret given tree of filter instructions. This is core function
* of filter system and does all the hard work.
*
* Each instruction has 4 fields: code (which is instruction code),
* aux (which is extension to instruction code, typically type),
* arg1 and arg2 - arguments. Depending on instruction, arguments
* are either integers, or pointers to instruction trees. Common
* instructions like +, that have two expressions as arguments use
* TWOARGS macro to get both of them evaluated.
*/
static enum filter_return
interpret(struct filter_state *fs, const struct f_line *line, uint argc, const struct f_val *argv, struct f_val *val)
{
/* No arguments allowed */
ASSERT_DIE(line->args == argc);
/* Initialize the filter stack */
struct filter_stack *fstk = fs->stack;
/* Set the arguments and top-level variables */
fstk->vcnt = line->vars + line->args;
memcpy(fstk->vstk, argv, sizeof(struct f_val) * line->args);
memset(fstk->vstk + line->args, 0, sizeof(struct f_val) * line->vars);
/* The same as with the value stack. Not resetting the stack completely for performance reasons. */
fstk->ecnt = 1;
fstk->estk[0].line = line;
fstk->estk[0].pos = 0;
#define curline fstk->estk[fstk->ecnt-1]
#define prevline fstk->estk[fstk->ecnt-2]
while (fstk->ecnt > 0) {
while (curline.pos < curline.line->len) {
const struct f_line_item *what = &(curline.line->items[curline.pos++]);
switch (what->fi_code) {
#define res fstk->vstk[fstk->vcnt]
#define vv(i) fstk->vstk[fstk->vcnt + (i)]
#define v1 vv(0)
#define v2 vv(1)
#define v3 vv(2)
#define runtime(fmt, ...) do { \
if (!(fs->flags & FF_SILENT)) \
log_rl(&rl_runtime_err, L_ERR "filters, line %d: " fmt, what->lineno, ##__VA_ARGS__); \
return F_ERROR; \
} while(0)
#define falloc(size) lp_alloc(fs->pool, size)
#define fpool fs->pool
#define ACCESS_EATTRS do { if (!fs->eattrs) f_cache_eattrs(fs); } while (0)
#include "filter/inst-interpret.c"
#undef res
#undef v1
#undef v2
#undef v3
#undef runtime
#undef falloc
#undef fpool
#undef ACCESS_EATTRS
}
}
/* End of current line. Drop local variables before exiting. */
fstk->vcnt = curline.ventry + curline.line->results;
fstk->ecnt--;
}
if (fstk->vcnt == 0) {
if (val) {
log_rl(&rl_runtime_err, L_ERR "filters: No value left on stack");
return F_ERROR;
}
return F_NOP;
}
if (val && (fstk->vcnt == 1)) {
*val = fstk->vstk[0];
return F_NOP;
}
log_rl(&rl_runtime_err, L_ERR "Too many items left on stack: %u", fstk->vcnt);
return F_ERROR;
}
/**
* f_run - run a filter for a route
* @filter: filter to run
* @rte: route being filtered, may be modified
* @tmp_pool: all filter allocations go from this pool
* @flags: flags
*
* If filter needs to modify the route, there are several
* posibilities. @rte might be read-only (with REF_COW flag), in that
* case rw copy is obtained by rte_cow() and @rte is replaced. If
* @rte is originally rw, it may be directly modified (and it is never
* copied).
*
* The returned rte may reuse the (possibly cached, cloned) rta, or
* (if rta was modified) contains a modified uncached rta, which
* uses parts allocated from @tmp_pool and parts shared from original
* rta. There is one exception - if @rte is rw but contains a cached
* rta and that is modified, rta in returned rte is also cached.
*
* Ownership of cached rtas is consistent with rte, i.e.
* if a new rte is returned, it has its own clone of cached rta
* (and cached rta of read-only source rte is intact), if rte is
* modified in place, old cached rta is possibly freed.
*/
enum filter_return
f_run(const struct filter *filter, struct rte **rte, struct linpool *tmp_pool, int flags)
{
if (filter == FILTER_ACCEPT)
return F_ACCEPT;
if (filter == FILTER_REJECT)
return F_REJECT;
return f_run_args(filter, rte, tmp_pool, 0, NULL, flags);
}
enum filter_return
f_run_args(const struct filter *filter, struct rte **rte, struct linpool *tmp_pool, uint argc, const struct f_val *argv, int flags)
{
int rte_cow = ((*rte)->flags & REF_COW);
DBG( "Running filter `%s'...", filter->name );
/* Initialize the filter state */
filter_state = (struct filter_state) {
.stack = &filter_stack,
.rte = rte,
.pool = tmp_pool,
.flags = flags,
};
LOG_BUFFER_INIT(filter_state.buf);
/* Run the interpreter itself */
enum filter_return fret = interpret(&filter_state, filter->root, argc, argv, NULL);
if (filter_state.old_rta) {
/*
* Cached rta was modified and filter_state->rte contains now an uncached one,
* sharing some part with the cached one. The cached rta should
* be freed (if rte was originally COW, filter_state->old_rta is a clone
* obtained during rte_cow()).
*
* This also implements the exception mentioned in f_run()
* description. The reason for this is that rta reuses parts of
* filter_state->old_rta, and these may be freed during rta_free(filter_state->old_rta).
* This is not the problem if rte was COW, because original rte
* also holds the same rta.
*/
if (!rte_cow) {
/* Cache the new attrs */
(*filter_state.rte)->attrs = rta_lookup((*filter_state.rte)->attrs);
/* Drop cached ea_list pointer */
filter_state.eattrs = NULL;
}
/* Uncache the old attrs and drop the pointer as it is invalid now. */
rta_free(filter_state.old_rta);
filter_state.old_rta = NULL;
}
/* Process the filter output, log it and return */
if (fret < F_ACCEPT) {
if (!(filter_state.flags & FF_SILENT))
log_rl(&rl_runtime_err, L_ERR "Filter %s did not return accept nor reject. Make up your mind", filter_name(filter));
return F_ERROR;
}
DBG( "done (%u)\n", res.val.i );
return fret;
}
/**
* f_eval_rte - run a filter line for an uncached route
* @expr: filter line to run
* @rte: route being filtered, may be modified
* @tmp_pool: all filter allocations go from this pool
*
* This specific filter entry point runs the given filter line
* (which must not have any arguments) on the given route.
*
* The route MUST NOT have REF_COW set and its attributes MUST NOT
* be cached by rta_lookup().
*/
enum filter_return
f_eval_rte(const struct f_line *expr, struct rte **rte, struct linpool *tmp_pool, uint argc, const struct f_val *argv, struct f_val *pres)
{
filter_state = (struct filter_state) {
.stack = &filter_stack,
.rte = rte,
.pool = tmp_pool,
};
LOG_BUFFER_INIT(filter_state.buf);
return interpret(&filter_state, expr, argc, argv, pres);
}
/*
* f_eval - get a value of a term
* @expr: filter line containing the term
* @tmp_pool: long data may get allocated from this pool
* @pres: here the output will be stored
*/
enum filter_return
f_eval(const struct f_line *expr, struct linpool *tmp_pool, struct f_val *pres)
{
filter_state = (struct filter_state) {
.stack = &filter_stack,
.pool = tmp_pool,
};
LOG_BUFFER_INIT(filter_state.buf);
enum filter_return fret = interpret(&filter_state, expr, 0, NULL, pres);
return fret;
}
/*
* cf_eval - evaluate a value of a term and check its type
* Called internally from the config parser, uses its internal memory pool
* for allocations. Do not call in other cases.
*/
struct f_val
cf_eval(const struct f_inst *inst, int type)
{
struct f_val val;
if (f_eval(f_linearize(inst, 1), cfg_mem, &val) > F_RETURN)
cf_error("Runtime error while evaluating expression; see log for details");
if (type != T_VOID && val.type != type)
cf_error("Expression of type %s expected", f_type_name(type));
return val;
}
/*
* f_eval_buf - get a value of a term and print it to the supplied buffer
*/
enum filter_return
f_eval_buf(const struct f_line *expr, struct linpool *tmp_pool, buffer *buf)
{
struct f_val val;
enum filter_return fret = f_eval(expr, tmp_pool, &val);
if (fret <= F_RETURN)
val_format(&val, buf);
return fret;
}
/**
* filter_same - compare two filters
* @new: first filter to be compared
* @old: second filter to be compared
*
* Returns 1 in case filters are same, otherwise 0. If there are
* underlying bugs, it will rather say 0 on same filters than say
* 1 on different.
*/
int
filter_same(const struct filter *new, const struct filter *old)
{
if (old == new) /* Handle FILTER_ACCEPT and FILTER_REJECT */
return 1;
if (old == FILTER_ACCEPT || old == FILTER_REJECT ||
new == FILTER_ACCEPT || new == FILTER_REJECT)
return 0;
if ((!old->sym) && (!new->sym))
return f_same(new->root, old->root);
if ((!old->sym) || (!new->sym))
return 0;
if (strcmp(old->sym->name, new->sym->name))
return 0;
return new->sym->flags & SYM_FLAG_SAME;
}
/**
* filter_commit - do filter comparisons on all the named functions and filters
*/
void
filter_commit(struct config *new, struct config *old)
{
if (!old)
return;
struct symbol *sym, *osym;
WALK_LIST(sym, new->symbols)
switch (sym->class) {
case SYM_FUNCTION:
if ((osym = cf_find_symbol(old, sym->name)) &&
(osym->class == SYM_FUNCTION) &&
f_same(sym->function, osym->function))
sym->flags |= SYM_FLAG_SAME;
else
sym->flags &= ~SYM_FLAG_SAME;
break;
case SYM_FILTER:
if ((osym = cf_find_symbol(old, sym->name)) &&
(osym->class == SYM_FILTER) &&
f_same(sym->filter->root, osym->filter->root))
sym->flags |= SYM_FLAG_SAME;
else
sym->flags &= ~SYM_FLAG_SAME;
break;
}
}
void filters_dump_all(struct dump_request *dreq)
{
struct symbol *sym;
WALK_LIST(sym, config->symbols) {
switch (sym->class) {
case SYM_FILTER:
RDUMP("Named filter %s:\n", sym->name);
f_dump_line(dreq, sym->filter->root, 1);
break;
case SYM_FUNCTION:
RDUMP("Function %s:\n", sym->name);
f_dump_line(dreq, sym->function, 1);
break;
case SYM_PROTO:
{
RDUMP("Protocol %s:\n", sym->name);
struct channel *c;
WALK_LIST(c, sym->proto->proto->channels) {
RDUMP(" Channel %s (%s) IMPORT", c->name, net_label[c->net_type]);
if (c->in_filter == FILTER_ACCEPT)
RDUMP(" ALL\n");
else if (c->in_filter == FILTER_REJECT)
RDUMP(" NONE\n");
else if (c->in_filter == FILTER_UNDEF)
RDUMP(" UNDEF\n");
else if (c->in_filter->sym) {
ASSERT(c->in_filter->sym->filter == c->in_filter);
RDUMP(" named filter %s\n", c->in_filter->sym->name);
} else {
RDUMP("\n");
f_dump_line(dreq, c->in_filter->root, 2);
}
}
}
}
}
}
bird2-2.17.5/filter/filter.h 0000664 0000000 0000000 00000004615 15211753245 0015546 0 ustar 00root root 0000000 0000000 /*
* BIRD Internet Routing Daemon -- Filters
*
* (c) 1999 Pavel Machek
* (c) 2018--2019 Maria Matejka
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_FILT_H_
#define _BIRD_FILT_H_
#include "lib/resource.h"
#include "lib/ip.h"
#include "lib/macro.h"
#include "nest/route.h"
#include "nest/attrs.h"
#include "filter/data.h"
/* Possible return values of filter execution */
enum filter_return {
F_NOP = 0,
F_NONL,
F_RETURN,
F_ACCEPT, /* Need to preserve ordering: accepts < rejects! */
F_REJECT,
F_ERROR,
};
static inline const char *filter_return_str(const enum filter_return fret) {
switch (fret) {
#define FRS(x) case x: return #x
FRS(F_NOP);
FRS(F_NONL);
FRS(F_RETURN);
FRS(F_ACCEPT);
FRS(F_REJECT);
FRS(F_ERROR);
#undef FRS
default: bug("This shall not happen");
}
}
/* The filter encapsulating structure to be pointed-to from outside */
struct f_inst;
struct f_line;
struct filter {
struct symbol *sym;
const struct f_line *root;
};
struct rte;
enum filter_return f_run(const struct filter *filter, struct rte **rte, struct linpool *tmp_pool, int flags);
enum filter_return f_run_args(const struct filter *filter, struct rte **rte, struct linpool *tmp_pool, uint argc, const struct f_val *argv, int flags);
enum filter_return f_eval_rte(const struct f_line *expr, struct rte **rte, struct linpool *tmp_pool, uint argc, const struct f_val *argv, struct f_val *pres);
enum filter_return f_eval_buf(const struct f_line *expr, struct linpool *tmp_pool, buffer *buf);
struct f_val cf_eval(const struct f_inst *inst, int type);
static inline uint cf_eval_int(const struct f_inst *inst) { return cf_eval(inst, T_INT).val.i; };
const char *filter_name(const struct filter *filter);
int filter_same(const struct filter *new, const struct filter *old);
int f_same(const struct f_line *f1, const struct f_line *f2);
void filter_commit(struct config *new, struct config *old);
void filters_dump_all(struct dump_request *);
#define FILTER_ACCEPT NULL
#define FILTER_REJECT ((struct filter *) 1)
#define FILTER_UNDEF ((struct filter *) 2) /* Used in BGP */
#define FF_SILENT 2 /* Silent filter execution */
/* Custom route attributes */
struct custom_attribute {
resource r;
struct f_dynamic_attr *fda;
const char *name;
};
struct custom_attribute *ca_lookup(pool *p, const char *name, int ea_type);
#endif
bird2-2.17.5/filter/filter_test.c 0000664 0000000 0000000 00000003715 15211753245 0016600 0 ustar 00root root 0000000 0000000 /*
* Filters: Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include
#include
#include "test/birdtest.h"
#include "test/bt-utils.h"
#include "filter/filter.h"
#include "filter/data.h"
#include "filter/f-inst.h"
#include "conf/conf.h"
#define BT_CONFIG_FILE "filter/test.conf"
static int
t_reconfig(const void *arg)
{
if (!bt_config_file_parse(arg))
return 0;
struct symbol *s;
WALK_LIST(s, config->symbols)
if ((s->class == SYM_FUNCTION) || (s->class == SYM_FILTER))
bt_assert_msg((s->flags & SYM_FLAG_SAME), "Symbol %s same check", s->name);
return 1;
}
static int
run_function(const void *arg)
{
const struct f_bt_test_suite *t = arg;
if (t->cmp)
return t->result == f_same(t->fn, t->cmp);
enum filter_return fret = f_eval(t->fn, tmp_linpool, NULL);
return (fret < F_REJECT);
}
static void
bt_assert_filter(int result, const struct f_line_item *assert)
{
int bt_suit_case_result = 1;
if (!result)
{
bt_result = 0;
bt_suite_result = 0;
bt_suit_case_result = 0;
}
bt_log_suite_case_result(bt_suit_case_result, "Assertion at line %d (%s)",
assert->lineno, assert->i_FI_ASSERT.s);
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_bird_init();
bt_assert_hook = bt_assert_filter;
/* Initial test.conf parsing, must be done here */
if (!bt_config_file_parse(BT_CONFIG_FILE))
abort();
bt_test_suite_arg(t_reconfig, BT_CONFIG_FILE ".overlay", "Testing reconfiguration to overlay");
bt_test_suite_arg(t_reconfig, BT_CONFIG_FILE, "Testing reconfiguration back");
bt_test_suite_arg(t_reconfig, BT_CONFIG_FILE, "Testing reconfiguration to the same file");
struct f_bt_test_suite *t;
WALK_LIST(t, config->tests)
bt_test_suite_base(run_function, t->fn_name, t, BT_FORKING, BT_TIMEOUT, "%s", t->dsc);
bt_bird_cleanup();
return bt_exit_value();
}
bird2-2.17.5/filter/test-reconf-begin.conf 0000664 0000000 0000000 00000000413 15211753245 0020262 0 ustar 00root root 0000000 0000000 router id 1.1.1.1;
protocol device {}
function a() {
return true;
}
function b() {
return a();
}
function c() {
return b();
}
filter d {
if c() then accept; else reject;
}
protocol static {
ipv4 { import filter d; };
route 10.0.0.0/24 unreachable;
}
bird2-2.17.5/filter/test-reconf-end.conf 0000664 0000000 0000000 00000000414 15211753245 0017745 0 ustar 00root root 0000000 0000000 router id 1.1.1.1;
protocol device {}
function a() {
return false;
}
function b() {
return a();
}
function c() {
return b();
}
filter d {
if c() then accept; else reject;
}
protocol static {
ipv4 { import filter d; };
route 10.0.0.0/24 unreachable;
}
bird2-2.17.5/filter/test.conf 0000664 0000000 0000000 00000204340 15211753245 0015733 0 ustar 00root root 0000000 0000000 /*
* This is unit testing configuration file for testing filters
*
* FIXME: add all examples from docs here.
*/
router id 62.168.0.1;
/* We have to setup any protocol */
protocol device { }
attribute bgppath mypath;
attribute lclist mylclist;
/*
* Common definitions and functions
* --------------------------------
*/
define one = 1;
define ten = 10;
function onef(int a) -> int
{
return 1;
}
function twof(int a) -> int
{
return 2;
}
function oneg(int a) -> int
{
return 1;
}
bt_test_same(onef, onef, 1);
bt_test_same(onef, oneg, 1);
bt_test_same(onef, twof, 0);
/*
* Testing filter corner cases
* ---------------------------
*/
function t_nothing() {}
bt_test_suite(t_nothing, "Testing nothing");
function t_metanothing() { t_nothing(); }
bt_test_suite(t_metanothing, "Testing meta nothing");
/*
* Testing boolean expressions
* ---------------------------
*/
function t_bool()
{
bool b = true;
bt_assert(b);
bt_assert(!!b);
bt_assert(format(true) = "TRUE");
bt_assert(format(false) = "FALSE");
if ( b = true ) then
bt_assert(b);
else
bt_assert(false);
bt_assert(true && true);
bt_assert(true || false);
bt_assert(! false && ! false && true);
bt_assert(1 < 2 && 1 != 3);
bt_assert(true && true && ! false);
# bt_assert(true || 1+"a");
# bt_assert(!(false && 1+"a"));
bt_assert(!(true && false));
}
bt_test_suite(t_bool, "Testing boolean expressions");
/*
* Testing integers
* ----------------
*/
function aux_t_int(int t; int u)
{
case t {
1: {}
else: {}
}
}
define four = 4;
define xyzzy = (120+10);
define '1a-a1' = (xyzzy-100);
function t_int()
{
bt_assert(xyzzy = 130);
bt_assert('1a-a1' = 30);
int i = four;
i = 12*100 + 60/2 + i;
i = (i + 0);
bt_assert(i = 1234);
bt_assert(format(i) = "1234");
i = 4200000000;
bt_assert(i = 4200000000);
bt_assert(i > 4100000000);
bt_assert(!(i > 4250000000));
bt_assert(1 = 1);
bt_assert(!(1 != 1));
bt_assert(1 != 2);
bt_assert(1 <= 2);
bt_assert(1 != "a");
bt_assert(1 != (0,1));
bt_assert(!(i = 4));
bt_assert(1 <= 1);
bt_assert(!(1234 < 1234));
case i {
4200000000: bt_assert(true);
(2+2): bt_assert(false);
else: bt_assert(false);
}
case four {
4200000000: bt_assert(false);
(2+2): bt_assert(true);
else: bt_assert(false);
}
case 5 {
4200000000: bt_assert(false);
(2+2): bt_assert(false);
else: bt_assert(true);
}
aux_t_int(1, 2);
aux_t_int(1, 3);
aux_t_int(2, 3);
aux_t_int(2, 2);
}
bt_test_suite(t_int, "Testing integers");
/*
* Testing sets of integers
* ------------------------
*/
define is1 = [ one, (2+1), (6-one), 8, 11, 15, 17, 19];
define is2 = [(17+2), 17, 15, 11, 8, 5, 3, 2];
define is3 = [5, 17, 2, 11, 8, 15, 3, 19];
function t_int_set()
{
int set is = [];
bt_assert(is = []);
bt_assert(0 !~ is);
bt_assert(1 ~ [1,2,3]);
bt_assert(5 ~ [1..20]);
bt_assert(2 ~ [ 1, 2, 3 ]);
bt_assert(5 ~ [ 4 .. 7 ]);
bt_assert(1 !~ [ 2, 3, 4 ]);
bt_assert(999 !~ [ 666, 333 ]);
bt_assert(1 !~ []);
bt_assert(1 !~ is);
is = [ 2, 3, 4, 7..11 ];
bt_assert(10 ~ is);
bt_assert(5 !~ is);
bt_assert(1 ~ is1);
bt_assert(3 ~ is1);
bt_assert(5 ~ is1);
bt_assert((one+2) ~ is1);
bt_assert(2 ~ is2);
bt_assert(2 ~ is3);
bt_assert(4 !~ is1);
bt_assert(4 !~ is2);
bt_assert(4 !~ is3);
bt_assert(10 !~ is1);
bt_assert(10 !~ is2);
bt_assert(10 !~ is3);
bt_assert(15 ~ is1);
bt_assert(15 ~ is2);
bt_assert(15 ~ is3);
bt_assert(18 !~ is1);
bt_assert(18 !~ is2);
bt_assert(18 !~ is3);
bt_assert(19 ~ is1);
bt_assert(19 ~ is2);
bt_assert(19 ~ is3);
bt_assert(20 !~ is1);
bt_assert(20 !~ is2);
bt_assert(20 !~ is3);
bt_assert([1,2] != [1,3]);
bt_assert([1,4..10,20] = [1,4..10,20]);
bt_assert(format([ 1, 2, 1, 1, 1, 3, 4, 1, 1, 1, 5 ]) = "[1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 5]");
bt_assert(format([]) = "[]");
case 3 {
(one), (2+1), (6-one), (17+2), 8, 11, 15, 17: bt_assert(true);
1, 4..10, 20: bt_assert(false);
else: bt_assert(false);
}
case 7 {
(one), (2+1), (6-one), (17+2), 8, 11, 15, 17: bt_assert(false);
1, 4..10, 20: bt_assert(true);
else: bt_assert(false);
}
case 12 {
(one), (2+1), (6-one), (17+2), 8, 11, 15, 17: bt_assert(false);
1, 4..10, 20: bt_assert(false);
else: bt_assert(true);
}
}
bt_test_suite(t_int_set, "Testing sets of integers");
/*
* Testing string matching
* -----------------------
*/
function t_string()
{
string st = "Hello";
bt_assert(format(st) = "Hello");
bt_assert(st ~ "Hell*");
bt_assert(st ~ "?ello");
bt_assert(st ~ "Hello");
bt_assert(st ~ "Hell?");
bt_assert(st !~ "ell*");
}
bt_test_suite(t_string, "Testing string matching");
/*
* Testing bytestings
* ------------------
*/
function t_bytestring()
{
bytestring bs1 = hex:;
bytestring bs2 = hex:0112233445566778899aabbccddeeff0;
bt_assert(format(bs1) = "");
bt_assert(format(bs2) = "01:12:23:34:45:56:67:78:89:9a:ab:bc:cd:de:ef:f0");
bt_assert(hex:01:12:23:34:45:56:67:78:89:9a:ab:bc:cd:de:ef:f0 = bs2);
bt_assert(01:12:23:34:45:56:67:78:89:9a:ab:bc:cd:de:ef:f0 = bs2);
bt_assert(0112233445566778899aabbccddeeff0 = bs2);
bt_assert(hex:01234567 = hex:01:23:45:67);
bt_assert(hex:0123456789abcdef != bs2);
bt_assert(hex:0123456789abcdef != hex:0123);
bt_assert(format(hex:0123456789abcdef) = "01:23:45:67:89:ab:cd:ef");
bt_assert(from_hex(" ") = bs1);
bt_assert(from_hex("01:12:23:34:45:56:67:78:89:9a:ab:bc:cd:de:ef:f0") = bs2);
bt_assert(from_hex(format(bs2)) = bs2);
bt_assert(from_hex(" 0112:23-34455667 78-89 - 9a-ab bc:cd : de:eff0 ") = bs2);
}
bt_test_suite(t_bytestring, "Testing bytestrings");
/*
* Testing pairs
* -------------
*/
function 'mkpair-a'(int a) -> pair
{
return (1, a);
}
function t_pair()
{
pair pp = (1, 2);
bt_assert(format(pp) = "(1,2)");
bt_assert((1,2) = pp);
bt_assert((1,1+1) = pp);
bt_assert('mkpair-a'(2) = pp);
bt_assert((1,2) = (1,1+1));
bt_assert(((1,2) < (2,2)));
bt_assert(!((1,1) > (1,1)));
}
bt_test_suite(t_pair, "Testing pairs");
/*
* Testing sets of pairs
* ---------------------
*/
function t_pair_set()
{
pair pp = (1, 2);
pair set ps = [];
bt_assert(pp !~ ps);
ps = [(1,(one+one)), (3,4)..(4,8), (5,*), (6,3..6)];
bt_assert(format(ps) = "[(1,2), (3,4)..(4,8), (5,0)..(5,65535), (6,3)..(6,6)]");
bt_assert(pp ~ ps);
bt_assert((3,5) ~ ps);
bt_assert((4,1) ~ ps);
bt_assert((5,4) ~ ps);
bt_assert((5,65535) ~ ps);
bt_assert((6,4) ~ ps);
bt_assert((3, 10000) ~ ps);
bt_assert((3,3) !~ ps);
bt_assert((4,9) !~ ps);
bt_assert((4,65535) !~ ps);
bt_assert((6,2) !~ ps);
bt_assert((6,6+one) !~ ps);
bt_assert(((one+6),2) !~ ps);
bt_assert((1,1) !~ ps);
bt_assert(pp !~ []);
ps = [(20..150, 200..300), (50100..50200, 1000..50000), (*, 5+5)];
bt_assert((100,200) ~ ps);
bt_assert((150,300) ~ ps);
bt_assert((50180,1200) ~ ps);
bt_assert((50110,49000) ~ ps);
bt_assert((0,10) ~ ps);
bt_assert((64000,10) ~ ps);
bt_assert((20,199) !~ ps);
bt_assert((151,250) !~ ps);
bt_assert((50050,2000) !~ ps);
bt_assert((50150,50050) !~ ps);
bt_assert((10,9) !~ ps);
bt_assert((65535,11) !~ ps);
case (6,4) {
(1,(one+one)), (3,4)..(4,8), (5,*), (6,3..6): bt_assert(true);
(20..150, 200..300), (50100..50200, 1000..50000), (*, 5+5): bt_assert(false);
else: bt_assert(false);
}
case (4,10) {
(1,(one+one)), (3,4)..(4,8), (5,*), (6,3..6): bt_assert(false);
(20..150, 200..300), (50100..50200, 1000..50000), (*, 5+5): bt_assert(true);
else: bt_assert(false);
}
case (1,5) {
(1,(one+one)), (3,4)..(4,8), (5,*), (6,3..6): bt_assert(false);
(20..150, 200..300), (50100..50200, 1000..50000), (*, 5+5): bt_assert(false);
else: bt_assert(true);
}
}
bt_test_suite(t_pair_set, "Testing sets of pairs");
/*
* Testing quads
* -------------
*/
function t_quad()
quad qq;
{
qq = 1.2.3.4;
bt_assert(format(qq) = "1.2.3.4");
bt_assert(qq = 1.2.3.4);
bt_assert(qq != 4.3.2.1);
}
bt_test_suite(t_quad, "Testing quads");
/*
* Testing sets of quads
* ---------------------
*/
function t_quad_set()
quad qq;
{
qq = 1.2.3.4;
bt_assert(qq ~ [1.2.3.4, 5.6.7.8]);
bt_assert(qq !~ [1.2.1.1, 1.2.3.5]);
bt_assert(qq !~ []);
case qq {
1.2.3.4, 5.6.7.8: bt_assert(true);
1.2.1.1, 1.2.3.5: bt_assert(false);
else: bt_assert(false);
}
case 1.2.1.1 {
1.2.3.4, 5.6.7.8: bt_assert(false);
1.2.1.1, 1.2.3.5: bt_assert(true);
else: bt_assert(false);
}
case 1.1.2.1 {
1.2.3.4, 5.6.7.8: bt_assert(false);
1.2.1.1, 1.2.3.5: bt_assert(false);
else: bt_assert(true);
}
}
bt_test_suite(t_quad_set, "Testing sets of quads");
/*
* Testing ip address
* ------------------
*/
define onetwo = 1.2.3.4;
function t_ip()
ip p;
{
p = 127.1.2.3;
bt_assert(p.is_v4);
bt_assert(p.mask(8) = 127.0.0.0);
bt_assert(1.2.3.4 = 1.2.3.4);
bt_assert(1.2.3.4 = onetwo);
bt_assert(format(p) = "127.1.2.3");
p = ::fffe:6:c0c:936d:88c7:35d3;
bt_assert(!p.is_v4);
bt_assert(format(p) = "::fffe:6:c0c:936d:88c7:35d3");
p = 1234:5678::;
bt_assert(!p.is_v4);
bt_assert(p.mask(24) = 1234:5600::);
p = 1:2:3:4:5:6:7:8;
bt_assert(!p.is_v4);
bt_assert(format(p) = "1:2:3:4:5:6:7:8");
bt_assert(p.mask(64) = 1:2:3:4::);
p = 10:20:30:40:50:60:70:80;
bt_assert(!p.is_v4);
bt_assert(format(p) = "10:20:30:40:50:60:70:80");
bt_assert(p.mask(64) = 10:20:30:40::);
p = 1090:20a0:30b0:40c0:50d0:60e0:70f0:8000;
bt_assert(!p.is_v4);
bt_assert(format(p) = "1090:20a0:30b0:40c0:50d0:60e0:70f0:8000");
bt_assert(p.mask(64) = 1090:20a0:30b0:40c0::);
p = ::fffe:6:c0c:936d:88c7:35d3;
bt_assert(!p.is_v4);
bt_assert(format(p) = "::fffe:6:c0c:936d:88c7:35d3");
bt_assert(p.mask(64) = 0:0:fffe:6::);
}
bt_test_suite(t_ip, "Testing ip address");
/*
* Testing sets of ip address
* --------------------------
*/
define ip1222 = 1.2.2.2;
function t_ip_set()
ip set ips;
{
ips = [ 1.1.1.0 .. 1.1.1.255, ip1222];
bt_assert(format(ips) = "[1.1.1.0..1.1.1.255, 1.2.2.2]");
bt_assert(1.1.1.0 ~ ips);
bt_assert(1.1.1.100 ~ ips);
bt_assert(1.2.2.2 ~ ips);
bt_assert(1.1.0.255 !~ ips);
bt_assert(1.1.2.0 !~ ips);
bt_assert(1.2.2.3 !~ ips);
bt_assert(192.168.1.1 !~ ips);
bt_assert(1.2.3.4 !~ [ 1.2.3.3, 1.2.3.5 ]);
bt_assert(1.2.3.4 ~ [ 1.2.3.3..1.2.3.5 ]);
bt_assert(1.2.3.4 !~ []);
case 1.1.1.64 {
1.1.1.0 .. 1.1.1.255 : bt_assert(true);
(ip1222): bt_assert(false);
else: bt_assert(false);
}
case 1.2.2.2 {
1.1.1.0 .. 1.1.1.255 : bt_assert(false);
(ip1222): bt_assert(true);
else: bt_assert(false);
}
case onetwo {
1.1.1.0 .. 1.1.1.255 : bt_assert(false);
(ip1222): bt_assert(false);
else: bt_assert(true);
}
case 1234:5678:: {
::fffe:6:c0c:936d:88c7:35d3, 1234:5678:: : bt_assert(true);
1:2:3:4:5:6:7:8, 10:20:30:40:50:60:70:80, 1090:20a0:30b0:40c0:50d0:60e0:70f0:8000 : bt_assert(false);
else: bt_assert(false);
}
case 10:20:30:40:50:60:70:80 {
::fffe:6:c0c:936d:88c7:35d3, 1234:5678:: : bt_assert(false);
1:2:3:4:5:6:7:8, 10:20:30:40:50:60:70:80, 1090:20a0:30b0:40c0:50d0:60e0:70f0:8000 : bt_assert(true);
else: bt_assert(false);
}
case 1:2:3:4:5:6:7:9 {
::fffe:6:c0c:936d:88c7:35d3, 1234:5678:: : bt_assert(false);
1:2:3:4:5:6:7:8, 10:20:30:40:50:60:70:80, 1090:20a0:30b0:40c0:50d0:60e0:70f0:8000 : bt_assert(false);
else: bt_assert(true);
}
}
bt_test_suite(t_ip_set, "Testing sets of ip address");
/*
* Testing enums
* -------------
*/
function t_enum()
{
enum rts ev0 = RTS_STATIC;
enum rtd ev1 = RTD_UNICAST;
enum scope ev2 = SCOPE_UNIVERSE;
enum roa ev3 = ROA_VALID;
enum aspa ev4 = ASPA_VALID;
enum af ev5 = AF_IPV6;
enum net_type ev6 = NET_IP6;
enum bgp_origin ev7 = ORIGIN_IGP;
enum ra_preference ev8 = RA_PREF_LOW;
enum mpls_policy ev9 = MPLS_POLICY_STATIC;
enum net_type set es = [NET_IP6, NET_VPN6];
bt_assert(format(RTS_STATIC) = "(enum 30)1");
bt_assert(format(NET_IP4) = "(enum 36)1");
bt_assert(format(NET_VPN6) = "(enum 36)4");
bt_assert(format(ev6) = "(enum 36)2");
bt_assert(ev0 = RTS_STATIC);
bt_assert(ev6 = NET_IP6);
bt_assert(RTS_STATIC ~ [RTS_STATIC, RTS_DEVICE]);
bt_assert(RTS_BGP !~ [RTS_STATIC, RTS_DEVICE]);
bt_assert(NET_IP6 ~ es);
bt_assert(NET_IP4 !~ es);
case NET_IP6 {
NET_IP6: bt_assert(true);
NET_VPN6: bt_assert(false);
else: bt_assert(false);
}
case RTS_DEVICE {
RTS_STATIC: bt_assert(false);
RTS_DEVICE: bt_assert(true);
else: bt_assert(false);
}
case NET_IP4 {
NET_IP6: bt_assert(false);
NET_VPN6: bt_assert(false);
else: bt_assert(true);
}
}
bt_test_suite(t_enum, "Testing enums");
/*
* Testing prefixes
* ----------------
*/
define netdoc = 2001:db8::/32;
function t_prefix()
prefix px;
{
px = 1.2.0.0/18;
bt_assert(format(px) = "1.2.0.0/18");
bt_assert(px.ip = 1.2.0.0);
bt_assert(px.len = 18);
bt_assert(192.168.0.0/16 ~ 192.168.0.0/16);
bt_assert(192.168.0.0/17 ~ 192.168.0.0/16);
bt_assert(192.168.254.0/24 ~ 192.168.0.0/16);
bt_assert(netdoc ~ 2001::/16);
bt_assert(192.168.0.0/15 !~ 192.168.0.0/16);
bt_assert(192.160.0.0/17 !~ 192.168.0.0/16);
bt_assert(px !~ netdoc);
bt_assert(1.2.3.4 ~ 1.0.0.0/8);
bt_assert(1.0.0.0/8 ~ 1.0.0.0/8);
}
bt_test_suite(t_prefix, "Testing prefixes");
/*
* Testing prefix sets
* -------------------
*/
define net10 = 10.0.0.0/8;
define pxs2 = [ 10.0.0.0/16{8,12}, 20.0.0.0/16{24,28} ];
function test_pxset(prefix set pxs)
{
bt_assert(net10 ~ pxs);
bt_assert(10.0.0.0/10 ~ pxs);
bt_assert(10.0.0.0/12 ~ pxs);
bt_assert(20.0.0.0/24 ~ pxs);
bt_assert(20.0.40.0/24 ~ pxs);
bt_assert(20.0.0.0/26 ~ pxs);
bt_assert(20.0.100.0/26 ~ pxs);
bt_assert(20.0.0.0/28 ~ pxs);
bt_assert(20.0.255.0/28 ~ pxs);
bt_assert(10.0.0.0/7 !~ pxs);
bt_assert(10.0.0.0/13 !~ pxs);
bt_assert(10.0.0.0/16 !~ pxs);
bt_assert(20.0.0.0/16 !~ pxs);
bt_assert(20.0.0.0/23 !~ pxs);
bt_assert(20.0.0.0/29 !~ pxs);
bt_assert(11.0.0.0/10 !~ pxs);
bt_assert(20.1.0.0/26 !~ pxs);
bt_assert(1.0.0.0/8 ~ [ 1.0.0.0/8+ ]);
bt_assert(1.0.0.0/9 !~ [ 1.0.0.0/8- ]);
bt_assert(1.2.0.0/17 !~ [ 1.0.0.0/8{ 15 , 16 } ]);
bt_assert(net10 !~ []);
bt_assert([ 10.0.0.0/8{ 15 , 17 } ] = [ 10.0.0.0/8{ 15 , 17 } ]);
}
function test_empty_pxset(prefix set pxs)
int set s0;
prefix set s1;
{
s0 = [];
s1 = [];
bt_assert(pxs != s0);
bt_assert(pxs = s1);
bt_assert(pxs = []);
}
function t_prefix_set()
prefix set pxs;
{
pxs = [];
bt_assert(format(pxs) = "[]");
bt_assert(pxs = []);
bt_assert(1.2.0.0/16 !~ []);
bt_assert(1.2.0.0/16 !~ pxs);
test_empty_pxset([]);
test_empty_pxset(pxs);
pxs = [ 1.2.0.0/16, 1.4.0.0/16+, 44.66.88.64/30{24,28}, 12.34.56.0/24{8,16} ];
bt_assert(format(pxs) = "[1.2.0.0/16{0.1.0.0}, 1.4.0.0/16{0.1.255.255}, 12.34.0.0/16{1.255.0.0}, 44.66.88.64/28{0.0.1.240}]");
bt_assert(1.2.0.0/16 ~ pxs);
bt_assert(1.4.0.0/16 ~ pxs);
bt_assert(1.4.0.0/18 ~ pxs);
bt_assert(1.4.0.0/32 ~ pxs);
bt_assert(1.1.0.0/16 !~ pxs);
bt_assert(1.3.0.0/16 !~ pxs);
bt_assert(1.2.0.0/15 !~ pxs);
bt_assert(1.2.0.0/17 !~ pxs);
bt_assert(1.2.0.0/32 !~ pxs);
bt_assert(1.4.0.0/15 !~ pxs);
test_pxset(pxs2);
test_pxset([ 10.0.0.0/16{8,12}, 20.0.0.0/16{24,28} ]);
bt_assert(1.2.0.0/16 ~ [ 1.0.0.0/8{ 15 , 17 } ]);
bt_assert([ 10.0.0.0/8{ 15 , 17 } ] != [ 11.0.0.0/8{ 15 , 17 } ]);
/* Formatting of prefix sets, some cases are a bit strange */
bt_assert(format([ 0.0.0.0/0 ]) = "[0.0.0.0/0]");
bt_assert(format([ 10.10.0.0/32 ]) = "[10.10.0.0/32{0.0.0.1}]");
bt_assert(format([ 10.10.0.0/17 ]) = "[10.10.0.0/17{0.0.128.0}]");
# bt_assert(format([ 10.10.0.0/17{17,19} ]) = "[10.10.0.0/17{0.0.224.0}]"); # 224 = 128+64+32
bt_assert(format([ 10.10.128.0/17{18,19} ]) = "[10.10.128.0/18{0.0.96.0}, 10.10.192.0/18{0.0.96.0}]"); # 96 = 64+32
# bt_assert(format([ 10.10.64.0/18- ]) = "[0.0.0.0/0, 0.0.0.0/1{128.0.0.0}, 0.0.0.0/2{64.0.0.0}, 0.0.0.0/3{32.0.0.0}, 10.10.0.0/16{255.255.0.0}, 10.10.0.0/17{0.0.128.0}, 10.10.64.0/18{0.0.64.0}]");
# bt_assert(format([ 10.10.64.0/18+ ]) = "[10.10.64.0/18{0.0.96.0}, 10.10.64.0/20{0.0.31.255}, 10.10.80.0/20{0.0.31.255}, 10.10.96.0/20{0.0.31.255}, 10.10.112.0/20{0.0.31.255}]");
bt_assert(format([ 10.10.160.0/19 ]) = "[10.10.160.0/19{0.0.32.0}]");
bt_assert(format([ 10.10.160.0/19{19,22} ]) = "[10.10.160.0/19{0.0.32.0}, 10.10.160.0/20{0.0.28.0}, 10.10.176.0/20{0.0.28.0}]"); # 28 = 16+8+4
bt_assert(format([ 10.10.160.0/19+ ]) = "[10.10.160.0/19{0.0.32.0}, 10.10.160.0/20{0.0.31.255}, 10.10.176.0/20{0.0.31.255}]");
bt_assert(format([ ::/0 ]) = "[::/0]");
bt_assert(format([ 11:22:33:44:55:66:77:88/128 ]) = "[11:22:33:44:55:66:77:88/128{::1}]");
bt_assert(format([ 11:22:33:44::/64 ]) = "[11:22:33:44::/64{0:0:0:1::}]");
bt_assert(format([ 11:22:33:44::/64+ ]) = "[11:22:33:44::/64{::1:ffff:ffff:ffff:ffff}]");
bt_assert(format([ 11:22:33:44::/65 ]) = "[11:22:33:44::/65{::8000:0:0:0}]");
# bt_assert(format([ 11:22:33:44::/65{65,67} ]) = "[11:22:33:44::/65{::e000:0:0:0}]"); # e = 8+4+2
bt_assert(format([ 11:22:33:44:8000::/65{66,67} ]) = "[11:22:33:44:8000::/66{::6000:0:0:0}, 11:22:33:44:c000::/66{::6000:0:0:0}]"); # 6 = 4+2
# bt_assert(format([ 11:22:33:44:4000::/66- ]) = "[::/0, ::/1{8000::}, ::/2{4000::}, ::/3{2000::}, 11:22:33:44::/64{ffff:ffff:ffff:ffff::}, 11:22:33:44::/65{::8000:0:0:0}, 11:22:33:44:4000::/66{::4000:0:0:0}]");
# bt_assert(format([ 11:22:33:44:4000::/66+ ]) = "[11:22:33:44:4000::/66{::6000:0:0:0}, 11:22:33:44:4000::/68{::1fff:ffff:ffff:ffff}, 11:22:33:44:5000::/68{::1fff:ffff:ffff:ffff}, 11:22:33:44:6000::/68{::1fff:ffff:ffff:ffff}, 11:22:33:44:7000::/68{::1fff:ffff:ffff:ffff}]");
bt_assert(format([ 11:22:33:44:c000::/67 ]) = "[11:22:33:44:c000::/67{::2000:0:0:0}]");
bt_assert(format([ 11:22:33:44:c000::/67{67,71} ]) = "[11:22:33:44:c000::/67{::2000:0:0:0}, 11:22:33:44:c000::/68{::1e00:0:0:0}, 11:22:33:44:d000::/68{::1e00:0:0:0}]");
bt_assert(format([ 11:22:33:44:c000::/67+ ]) = "[11:22:33:44:c000::/67{::2000:0:0:0}, 11:22:33:44:c000::/68{::1fff:ffff:ffff:ffff}, 11:22:33:44:d000::/68{::1fff:ffff:ffff:ffff}]");
}
bt_test_suite(t_prefix_set, "Testing prefix sets");
/*
* Testing Prefix IPv6
* -------------------
*/
function t_prefix6()
{
prefix px = 1020::/18;
bt_assert(format(px) = "1020::/18");
bt_assert(px.ip = 1020::);
bt_assert(px.len = 18);
bt_assert(1020:3040:5060:: ~ 1020:3040:5000::/40);
bt_assert(1020:3040::/32 ~ 1020:3040::/32);
bt_assert(1020:3040::/33 ~ 1020:3040::/32);
bt_assert(1020:3040:5060::/48 ~ 1020:3040::/32);
bt_assert(1020:3040::/31 !~ 1020:3040::/32);
bt_assert(1020:3041::/33 !~ 1020:3040::/32);
}
bt_test_suite(t_prefix6, "Testing prefix IPv6");
/*
* Testing prefix IPv6 sets
* ------------------------
*/
function t_prefix6_set()
prefix set pxs;
{
pxs = [];
bt_assert(format(pxs) = "[]");
bt_assert(pxs = []);
bt_assert(12::34/128 !~ []);
bt_assert(12::34/128 !~ pxs);
bt_assert(1180::/16 ~ [ 1100::/8{15, 17} ]);
bt_assert(12::34 = 12::34);
bt_assert(12::34 ~ [ 12::33..12::35 ]);
bt_assert(1020::34 ~ 1000::/8);
bt_assert(1000::/8 ~ 1000::/8);
bt_assert(1000::/8 ~ [ 1000::/8+ ]);
bt_assert(12::34 !~ [ 12::33, 12::35 ]);
bt_assert(1000::/9 !~ [ 1000::/8- ]);
bt_assert(1000::/17 !~ [ 1000::/8{15, 16} ]);
pxs = [ 1102::/16, 1104::/16+];
bt_assert(1102::/16 ~ pxs);
bt_assert(1104::/16 ~ pxs);
bt_assert(1104::/18 ~ pxs);
bt_assert(1104::/32 ~ pxs);
bt_assert(1101::/16 !~ pxs);
bt_assert(1103::/16 !~ pxs);
bt_assert(1102::/15 !~ pxs);
bt_assert(1102::/17 !~ pxs);
bt_assert(1102::/32 !~ pxs);
bt_assert(1104::/15 !~ pxs);
pxs = ([ 1000::/16{8,12}, 2000::/16{24,28} ]);
bt_assert(format(pxs) = "[1000::/12{1f0::}, 2000::/16{0:1f0::}]");
bt_assert(1000::/8 ~ pxs);
bt_assert(1000::/10 ~ pxs);
bt_assert(1000::/12 ~ pxs);
bt_assert(2000::/24 ~ pxs);
bt_assert(2000:4000::/24 ~ pxs);
bt_assert(2000::/26 ~ pxs);
bt_assert(2000:8000::/26 ~ pxs);
bt_assert(2000::/28 ~ pxs);
bt_assert(2000:FFF0::/28 ~ pxs);
bt_assert(1000::/7 !~ pxs);
bt_assert(1000::/13 !~ pxs);
bt_assert(1000::/16 !~ pxs);
bt_assert(2000::/16 !~ pxs);
bt_assert(2000::/23 !~ pxs);
bt_assert(2000::/29 !~ pxs);
bt_assert(1100::/10 !~ pxs);
bt_assert(2010::/26 !~ pxs);
pxs = [ 52E0::/13{13,128} ];
bt_assert(52E7:BE81:379B:E6FD:541F:B0D0::/93 ~ pxs);
pxs = [ 41D8:8718::/30{0,30}, 413A:99A8:6C00::/38{38,128} ];
bt_assert(4180::/9 ~ pxs);
}
bt_test_suite(t_prefix6_set, "Testing prefix IPv6 sets");
/*
* Testing Paths
* -------------
*/
function mkpath(int a; int b) -> bgpmask
{
return [= a b 3 2 1 =];
}
define set35 = [3 .. 5];
function t_path_old()
bgpmask pm1;
bgppath p2;
int set set12;
{
pm1 = [= 4 3 2 1 =];
set12 = [1, 2];
bt_assert(format(pm1) = "[= 4 3 2 1 =]");
bt_assert(+empty+ = +empty+);
bt_assert(10 !~ +empty+);
p2 = prepend( + empty +, 1 );
p2 = prepend( p2, 2 );
p2 = prepend( p2, 3 );
p2 = prepend( p2, 4 );
bt_assert(format(p2) = "(path 4 3 2 1)");
bt_assert(p2.len = 4);
bt_assert(p2 ~ pm1);
bt_assert(3 ~ p2);
bt_assert(p2 ~ [2, 10..20]);
bt_assert(p2 ~ [4, 10..20]);
bt_assert(p2 !~ []);
p2 = prepend(p2, 5);
bt_assert(p2 !~ pm1);
bt_assert(10 !~ p2);
bt_assert(p2 !~ [8, ten..(2*ten)]);
bt_assert(p2 ~ [= * 4 3 * 1 =]);
bt_assert(p2 ~ [= (3+2) (2*2) 3 2 1 =]);
bt_assert(p2 ~ [= 5 [2, 4, 6] 3 [1..2] 1 =]);
bt_assert(p2 ~ [= 5 set35 3 set12 set12 =]);
bt_assert(p2 ~ mkpath(5, 4));
bt_assert(p2 ~ [= * [3] * =]);
bt_assert(p2 !~ [= * [] * =]);
bt_assert(p2.len = 5);
bt_assert(p2.first = 5);
bt_assert(p2.last = 1);
bt_assert(p2.len = 5);
bt_assert(delete(p2, 3) = prepend(prepend(prepend(prepend(+empty+, 1), 2), 4), 5));
bt_assert(filter(p2, [1..3]) = prepend(prepend(prepend(+empty+, 1), 2), 3));
bt_assert(delete(p2, []) = p2);
bt_assert(filter(p2, []) = +empty+);
bt_assert(delete(prepend(prepend(+empty+, 0), 1), []) = prepend(prepend(+empty+, 0), 1));
bt_assert(filter(prepend(prepend(+empty+, 0), 1), []) = +empty+);
p2 = prepend( + empty +, 5 );
p2 = prepend( p2, 4 );
p2 = prepend( p2, 3 );
p2 = prepend( p2, 3 );
p2 = prepend( p2, 2 );
p2 = prepend( p2, 1 );
bt_assert(p2 !~ [= 1 2 3 4 5 =]);
bt_assert(p2 ~ [= 1 2 * 4 5 =]);
bt_assert(p2 ~ [= 1 2 * 3 4 5 =]);
bt_assert(p2 ~ [= 1 2 3+ 4 5 =]);
bt_assert(p2 ~ [= 1 2 3+ 4+ 5 =]);
bt_assert(p2 !~ [= 1 2 3+ 5+ 4 5 =]);
bt_assert(p2 !~ [= 1 2 3 3 5+ 4 5 =]);
bt_assert(delete(p2, 3) = prepend(prepend(prepend(prepend(+empty+, 5), 4), 2), 1));
bt_assert(delete(p2, [4..5]) = prepend(prepend(prepend(prepend(+empty+, 3), 3), 2), 1));
bt_assert(format([= 1 2+ 3 =]) = "[= 1 2 + 3 =]");
# iteration over path
int x = 0;
int y = 0;
for int i in p2 do {
x = x + i;
y = y + x;
}
bt_assert(x = 18 && y = 50);
# gigantic path
bgppath mega = +empty+.prepend(1).prepend(2).prepend(3).prepend(4).prepend(5).prepend(6).prepend(7).prepend(8).prepend(9);
bgppath game;
for int m in mega do {
for int g in mega do {
game.prepend((m-1) * 9 + g);
}
}
for int m in game do {
for int g in game do {
mega.prepend((m-1) * 81 + g);
}
}
bt_assert(mega ~ [= * 1000 * 67 * 42 * =]);
}
bt_test_suite(t_path_old, "Testing paths (old syntax)");
function t_path_new()
{
bgpmask pm1 = [= 4 3 2 1 =];
int set set12 = [1, 2];
bt_assert(format(pm1) = "[= 4 3 2 1 =]");
bt_assert(+empty+ = +empty+);
bt_assert(10 !~ +empty+);
bgppath p2;
bt_assert(p2 = +empty+);
p2.prepend(1);
p2.prepend(2);
p2.prepend(3);
p2.prepend(4);
bt_assert(p2.empty = +empty+);
bt_assert(format(p2) = "(path 4 3 2 1)");
bt_assert(p2.len = 4);
bt_assert(p2 ~ pm1);
bt_assert(3 ~ p2);
bt_assert(p2 ~ [2, 10..20]);
bt_assert(p2 ~ [4, 10..20]);
bt_assert(p2 !~ []);
p2.prepend(5);
bt_assert(p2 !~ pm1);
bt_assert(10 !~ p2);
bt_assert(p2 !~ [8, ten..(2*ten)]);
bt_assert(p2 ~ [= * 4 3 * 1 =]);
bt_assert(p2 ~ [= (3+2) (2*2) 3 2 1 =]);
bt_assert(p2 ~ [= 5 [2, 4, 6] 3 [1..2] 1 =]);
bt_assert(p2 ~ [= 5 set35 3 set12 set12 =]);
bt_assert(p2 ~ mkpath(5, 4));
bt_assert(p2 ~ [= * [3] * =]);
bt_assert(p2 !~ [= * [] * =]);
bt_assert(p2.len = 5);
bt_assert(p2.first = 5);
bt_assert(p2.last = 1);
bt_assert(p2.len = 5);
bt_assert(p2.delete(3) = +empty+.prepend(1).prepend(2).prepend(4).prepend(5));
bt_assert(p2.filter([1..3]) = +empty+.prepend(1).prepend(2).prepend(3));
bt_assert(p2.delete([]) = p2);
bt_assert(p2.filter([]) = +empty+);
bt_assert(+empty+.prepend(0).prepend(1).delete([]) = +empty+.prepend(0).prepend(1));
bt_assert(+empty+.prepend(0).prepend(1).filter([]) = +empty+);
p2 = +empty+;
p2.prepend(5);
p2.prepend(4);
p2.prepend(3);
p2.prepend(3);
p2.prepend(2);
p2.prepend(1);
bt_assert(p2 !~ [= 1 2 3 4 5 =]);
bt_assert(p2 ~ [= 1 2 * 4 5 =]);
bt_assert(p2 ~ [= 1 2 * 3 4 5 =]);
bt_assert(p2 ~ [= 1 2 3+ 4 5 =]);
bt_assert(p2 ~ [= 1 2 3+ 4+ 5 =]);
bt_assert(p2 !~ [= 1 2 3+ 5+ 4 5 =]);
bt_assert(p2 !~ [= 1 2 3 3 5+ 4 5 =]);
bt_assert(p2.delete(3) = +empty+.prepend(5).prepend(4).prepend(2).prepend(1));
bt_assert(p2.delete([4..5]) = +empty+.prepend(3).prepend(3).prepend(2).prepend(1));
bt_assert(format([= 1 2+ 3 =]) = "[= 1 2 + 3 =]");
# iteration over path
int x = 0;
int y = 0;
for int i in p2 do {
x = x + i;
y = y + x;
}
bt_assert(x = 18 && y = 50);
# gigantic path
bgppath mega = +empty+.prepend(1).prepend(2).prepend(3).prepend(4).prepend(5).prepend(6).prepend(7).prepend(8).prepend(9);
bgppath game;
for int m in mega do {
for int g in mega do {
game.prepend((m-1) * 9 + g);
}
}
for int m in game do {
for int g in game do {
mega.prepend((m-1) * 81 + g);
}
}
bt_assert(mega ~ [= * 1000 * 67 * 42 * =]);
}
bt_test_suite(t_path_new, "Testing paths (new syntax)");
/*
* Testing Community List
* ----------------------
*/
define p23 = (2, 3);
function t_clist_old()
clist l;
clist l2;
clist r;
{
bt_assert((10, 20).asn = 10);
bt_assert((10, 20).data = 20);
bt_assert(p23.asn = 2);
bt_assert(p23.data = 3);
l = - empty -;
bt_assert(l !~ [(*,*)]);
bt_assert((l ~ [(*,*)]) != (l !~ [(*,*)]));
bt_assert(-empty- = -empty-);
l = add( l, (one,2) );
bt_assert(l ~ [(*,*)]);
l = add( l, (2,one+2) );
bt_assert(format(l) = "(clist (1,2) (2,3))");
bt_assert((2,3) ~ l);
bt_assert(l ~ [(1,*)]);
bt_assert(l ~ [p23]);
bt_assert(l ~ [(2,2..3)]);
bt_assert(l ~ [(1,1..2)]);
bt_assert(l ~ [(1,1)..(1,2)]);
bt_assert(l !~ []);
l = add(l, (2,5));
l = add(l, (5,one));
l = add(l, (6,one));
l = add(l, (one,one));
l = delete(l, [(5,1),(6,one),(one,1)]);
l = delete(l, [(5,one),(6,one)]);
l = filter(l, [(1,*)]);
bt_assert(l = add(-empty-, (1,2)));
bt_assert((2,3) !~ l);
bt_assert(l !~ [(2,*)]);
bt_assert(l !~ [(one,3..6)]);
bt_assert(l ~ [(*,*)]);
l = add(l, (3,one));
l = add(l, (one+one+one,one+one));
l = add(l, (3,3));
l = add(l, (3,4));
l = add(l, (3,5));
l2 = filter(l, [(3,*)]);
l = delete(l, [(3,2..4)]);
bt_assert(l = add(add(add(-empty-, (1,2)), (3,1)), (3,5)));
bt_assert(l.len = 3);
l = add(l, (3,2));
l = add(l, (4,5));
bt_assert(l = add(add(add(add(add(-empty-, (1,2)), (3,1)), (3,5)), (3,2)), (4,5)));
bt_assert(l.len = 5);
bt_assert(l ~ [(*,2)]);
bt_assert(l ~ [(*,5)]);
bt_assert(l ~ [(*, one)]);
bt_assert(l !~ [(*,3)]);
bt_assert(l !~ [(*,(one+6))]);
bt_assert(l !~ [(*, (one+one+one))]);
bt_assert(delete(l, []) = l);
bt_assert(filter(l, []) = -empty-);
l = delete(l, [(*,(one+onef(3)))]);
l = delete(l, [(*,(4+one))]);
bt_assert(l = add(-empty-, (3,1)));
l = delete(l, [(*,(onef(5)))]);
bt_assert(l = -empty-);
l2 = add(l2, (3,6));
l = filter(l2, [(3,1..4)]);
l2 = filter(l2, [(3,3..6)]);
quad q = 2.0.1.0;
clist ql = add(add(add(-empty-, 1.0.0.1), q), 3.1.0.0);
bt_assert(delete(ql, 1.0.0.1) = add(add(-empty-, 2.0.1.0), 3.1.0.0));
bt_assert(delete(ql, [2.0.0.0 .. 4.0.0.0]) = add(-empty-, 1.0.0.1));
bt_assert(filter(ql, [3.0.0.0 .. 4.0.0.0]) = add(-empty-, 3.1.0.0));
# clist A (10,20,30)
bt_assert(l = add(add(add(add(-empty-, (3,1)), (3,2)), (3,3)), (3,4)));
bt_assert(format(l) = "(clist (3,1) (3,2) (3,3) (3,4))");
# clist B (30,40,50)
bt_assert(l2 = add(add(add(add(-empty-, (3,3)), (3,4)), (3,5)), (3,6)));
bt_assert(format(l2) = "(clist (3,3) (3,4) (3,5) (3,6))");
# clist A union B
r = add(l, l2);
bt_assert(r = add(add(add(add(add(add(-empty-, (3,1)), (3,2)), (3,3)), (3,4)), (3,5)), (3,6)));
bt_assert(format(r) = "(clist (3,1) (3,2) (3,3) (3,4) (3,5) (3,6))");
# clist A isect B
r = filter(l, l2);
bt_assert(r = add(add(-empty-, (3,3)), (3,4)));
bt_assert(format(r) = "(clist (3,3) (3,4))");
# clist A \ B
r = delete(l, l2);
bt_assert(r = add(add(-empty-, (3,1)), (3,2)));
bt_assert(format(r) = "(clist (3,1) (3,2))");
# clist in c set
r = filter(l, [(3,1), (*,2)]);
bt_assert(r = add(add(-empty-, (3,1)), (3,2)));
bt_assert(format(r) = "(clist (3,1) (3,2))");
# minimim & maximum element
r = add(add(add(add(add(-empty-, (2,1)), (1,3)), (2,2)), (3,1)), (2,3));
bt_assert(format(r) = "(clist (2,1) (1,3) (2,2) (3,1) (2,3))");
bt_assert(r.min = (1,3));
bt_assert(r.max = (3,1));
# iteration over clist
int x = 0;
for pair c in r do
x = x + c.asn * c.asn * c.data;
bt_assert(x = 36);
}
bt_test_suite(t_clist_old, "Testing lists of communities (old syntax)");
function t_clist_new()
{
bt_assert((10, 20).asn = 10);
bt_assert((10, 20).data = 20);
bt_assert(p23.asn = 2);
bt_assert(p23.data = 3);
clist l;
bt_assert(l = -empty-);
bt_assert(l !~ [(*,*)]);
bt_assert((l ~ [(*,*)]) != (l !~ [(*,*)]));
bt_assert(-empty- = -empty-);
l.add( (one,2) );
bt_assert(l ~ [(*,*)]);
l.add( (2,one+2) );
bt_assert(format(l) = "(clist (1,2) (2,3))");
bt_assert(l.empty = -empty-);
bt_assert((2,3) ~ l);
bt_assert(l ~ [(1,*)]);
bt_assert(l ~ [p23]);
bt_assert(l ~ [(2,2..3)]);
bt_assert(l ~ [(1,1..2)]);
bt_assert(l ~ [(1,1)..(1,2)]);
bt_assert(l !~ []);
l.add((2,5));
l.add((5,one));
l.add((6,one));
l.add((one,one));
l.delete([(5,1),(6,one),(one,1)]);
l.delete([(5,one),(6,one)]);
l.filter([(1,*)]);
bt_assert(l = -empty-.add((1,2)));
bt_assert((2,3) !~ l);
bt_assert(l !~ [(2,*)]);
bt_assert(l !~ [(one,3..6)]);
bt_assert(l ~ [(*,*)]);
l.add((3,one));
l.add((one+one+one,one+one));
l.add((3,3));
l.add((3,4));
l.add((3,5));
clist l2 = l.filter([(3,*)]);
l.delete([(3,2..4)]);
bt_assert(l = -empty-.add((1,2)).add((3,1)).add((3,5)));
bt_assert(l.len = 3);
l.add((3,2));
l.add((4,5));
bt_assert(l = -empty-.add((1,2)).add((3,1)).add((3,5)).add((3,2)).add((4,5)));
bt_assert(l.len = 5);
bt_assert(l ~ [(*,2)]);
bt_assert(l ~ [(*,5)]);
bt_assert(l ~ [(*, one)]);
bt_assert(l !~ [(*,3)]);
bt_assert(l !~ [(*,(one+6))]);
bt_assert(l !~ [(*, (one+one+one))]);
bt_assert(l.delete([]) = l);
bt_assert(l.filter([]) = -empty-);
l.delete([(*,(one+onef(3)))]);
l.delete([(*,(4+one))]);
bt_assert(l = -empty-.add((3,1)));
l.delete([(*,(onef(5)))]);
bt_assert(l = -empty-);
l2.add((3,6));
l = l2.filter([(3,1..4)]);
l2.filter([(3,3..6)]);
quad q = 2.0.1.0;
clist ql = -empty-.add(1.0.0.1).add(q).add(3.1.0.0);
bt_assert(delete(ql, 1.0.0.1) = -empty-.add(2.0.1.0).add(3.1.0.0));
bt_assert(delete(ql, [2.0.0.0 .. 4.0.0.0]) = -empty-.add(1.0.0.1));
bt_assert(filter(ql, [3.0.0.0 .. 4.0.0.0]) = -empty-.add(3.1.0.0));
# clist A (10,20,30)
bt_assert(l = -empty-.add((3,1)).add((3,2)).add((3,3)).add((3,4)));
bt_assert(format(l) = "(clist (3,1) (3,2) (3,3) (3,4))");
# clist B (30,40,50)
bt_assert(l2 = -empty-.add((3,3)).add((3,4)).add((3,5)).add((3,6)));
bt_assert(format(l2) = "(clist (3,3) (3,4) (3,5) (3,6))");
# clist A union B
clist r = l.add(l2);
bt_assert(r = -empty-.add((3,1)).add((3,2)).add((3,3)).add((3,4)).add((3,5)).add((3,6)));
bt_assert(format(r) = "(clist (3,1) (3,2) (3,3) (3,4) (3,5) (3,6))");
# clist A isect B
r = l.filter(l2);
bt_assert(r = -empty-.add((3,3)).add((3,4)));
bt_assert(format(r) = "(clist (3,3) (3,4))");
# clist A \ B
r = l.delete(l2);
bt_assert(r = -empty-.add((3,1)).add((3,2)));
bt_assert(format(r) = "(clist (3,1) (3,2))");
# clist in c set
r = l.filter([(3,1), (*,2)]);
bt_assert(r = -empty-.add((3,1)).add((3,2)));
bt_assert(format(r) = "(clist (3,1) (3,2))");
# minimim & maximum element
r = -empty-.add((2,1)).add((1,3)).add((2,2)).add((3,1)).add((2,3));
bt_assert(format(r) = "(clist (2,1) (1,3) (2,2) (3,1) (2,3))");
bt_assert(r.min = (1,3));
bt_assert(r.max = (3,1));
# iteration over clist
int x = 0;
for pair c in r do
x = x + c.asn * c.asn * c.data;
bt_assert(x = 36);
}
bt_test_suite(t_clist_new, "Testing lists of communities (new syntax)");
/*
* Testing Extended Communities
* ----------------------------
*/
function t_ec()
{
ec cc;
cc = (rt, 12345, 200000);
bt_assert(format(cc) = "(rt, 12345, 200000)");
bt_assert(cc = (rt, 12345, 200000));
bt_assert(cc < (rt, 12345, 200010));
bt_assert(cc != (rt, 12346, 200000));
bt_assert(cc != (ro, 12345, 200000));
bt_assert(!(cc > (rt, 12345, 200010)));
bt_assert(format((ro, 100000, 20000)) = "(ro, 100000, 20000)");
}
bt_test_suite(t_ec, "Testing extended communities");
/*
* Testing Extended Community List
* -------------------------------
*/
function t_eclist_old()
eclist el;
eclist el2;
eclist r;
{
# Deprecated syntax
el = -- empty --;
el = add(el, (rt, 10, 20));
el = add(el, (ro, 10.20.30.40, 100));
el = add(el, (ro, 11.21.31.41.mask(16), 200));
bt_assert(--empty-- = --empty--);
bt_assert(((rt, 10, 20)) !~ --empty--);
bt_assert(format(el) = "(eclist (rt, 10, 20) (ro, 10.20.30.40, 100) (ro, 11.21.0.0, 200))");
bt_assert(el.len = 3);
el = delete(el, (rt, 10, 20));
el = delete(el, (rt, 10, 30));
bt_assert(el = add(add(--empty--, (ro, 10.20.30.40, 100)), (ro, 11.21.0.0, 200)));
el = add(el, (unknown 2, ten, 1));
el = add(el, (unknown 5, ten, 1));
el = add(el, (rt, ten, one+one));
el = add(el, (rt, 10, 3));
el = add(el, (rt, 10, 4));
el = add(el, (rt, 10, 5));
el = add(el, (generic, 0x2000a, 3*ten));
el = delete(el, [(rt, 10, 2..ten)]);
bt_assert(el = add(add(add(add(add(--empty--, (ro, 10.20.30.40, 100)), (ro, 11.21.0.0, 200)), (rt, 10, 1)), (unknown 5, 10, 1)), (rt, 10, 30)));
el = filter(el, [(rt, 10, *)]);
bt_assert(el = add(add(--empty--, (rt, 10, 1)), (rt, 10, 30)));
bt_assert((rt, 10, 1) ~ el);
bt_assert(el ~ [(rt, 10, ten..40)]);
bt_assert((rt, 10, 20) !~ el);
bt_assert((ro, 10.20.30.40, 100) !~ el);
bt_assert(el !~ [(rt, 10, 35..40)]);
bt_assert(el !~ [(ro, 10, *)]);
bt_assert(el !~ []);
el = add(el, (rt, 10, 40));
el2 = filter(el, [(rt, 10, 20..40)] );
el2 = add(el2, (rt, 10, 50));
bt_assert(delete(el, []) = el);
bt_assert(filter(el, []) = --empty--);
# eclist A (1,30,40)
bt_assert(el = add(add(add(--empty--, (rt, 10, 1)), (rt, 10, 30)), (rt, 10, 40)));
bt_assert(format(el) = "(eclist (rt, 10, 1) (rt, 10, 30) (rt, 10, 40))");
# eclist B (30,40,50)
bt_assert(el2 = add(add(add(--empty--, (rt, 10, 30)), (rt, 10, 40)), (rt, 10, 50)));
bt_assert(format(el2) = "(eclist (rt, 10, 30) (rt, 10, 40) (rt, 10, 50))");
# eclist A union B
r = add(el2, el);
bt_assert(r = add(add(add(add(--empty--, (rt, 10, 30)), (rt, 10, 40)), (rt, 10, 50)), (rt, 10, 1)));
bt_assert(format(r) = "(eclist (rt, 10, 30) (rt, 10, 40) (rt, 10, 50) (rt, 10, 1))");
# eclist A isect B
r = filter(el, el2);
bt_assert(r = add(add(--empty--, (rt, 10, 30)), (rt, 10, 40)));
bt_assert(format(r) = "(eclist (rt, 10, 30) (rt, 10, 40))");
# eclist A \ B
r = delete(el, el2);
bt_assert(r = add(--empty--, (rt, 10, 1)));
bt_assert(format(r) = "(eclist (rt, 10, 1))");
# eclist in ec set
r = filter(el, [(rt, 10, 1), (rt, 10, 25..30), (ro, 10, 40)]);
bt_assert(r = add(add(--empty--, (rt, 10, 1)), (rt, 10, 30)));
bt_assert(format(r) = "(eclist (rt, 10, 1) (rt, 10, 30))");
# minimim & maximum element
r = add(add(add(add(add(--empty--, (rt, 2, 1)), (rt, 1, 3)), (rt, 2, 2)), (rt, 3, 1)), (rt, 2, 3));
bt_assert(format(r) = "(eclist (rt, 2, 1) (rt, 1, 3) (rt, 2, 2) (rt, 3, 1) (rt, 2, 3))");
bt_assert(r.min = (rt, 1, 3));
bt_assert(r.max = (rt, 3, 1));
# iteration over eclist
int x = 0;
for ec c in r do
if c > (rt, 2, 0) && c < (rt, 3, 0) then
x = x + 1;
bt_assert(x = 3);
}
bt_test_suite(t_eclist_old, "Testing lists of extended communities");
function t_eclist_new()
{
# New syntax
eclist el;
bt_assert(el = --empty--);
el.add((rt, 10, 20));
el.add((ro, 10.20.30.40, 100));
el.add((ro, 11.21.31.41.mask(16), 200));
bt_assert(--empty-- = --empty--);
bt_assert(((rt, 10, 20)) !~ --empty--);
bt_assert(format(el) = "(eclist (rt, 10, 20) (ro, 10.20.30.40, 100) (ro, 11.21.0.0, 200))");
bt_assert(el.len = 3);
el.delete((rt, 10, 20));
el.delete((rt, 10, 30));
bt_assert(el = (--empty--).add((ro, 10.20.30.40, 100)).add((ro, 11.21.0.0, 200)));
bt_assert(el.empty = --empty--);
el.add((unknown 2, ten, 1));
el.add((unknown 5, ten, 1));
el.add((rt, ten, one+one));
el.add((rt, 10, 3));
el.add((rt, 10, 4));
el.add((rt, 10, 5));
el.add((generic, 0x2000a, 3*ten));
el.delete([(rt, 10, 2..ten)]);
bt_assert(el = (--empty--).add((ro, 10.20.30.40, 100)).add((ro, 11.21.0.0, 200)).add((rt, 10, 1)).add((unknown 5, 10, 1)).add((rt, 10, 30)));
el.filter([(rt, 10, *)]);
bt_assert(el = (--empty--).add((rt, 10, 1)).add((rt, 10, 30)));
bt_assert((rt, 10, 1) ~ el);
bt_assert(el ~ [(rt, 10, ten..40)]);
bt_assert((rt, 10, 20) !~ el);
bt_assert((ro, 10.20.30.40, 100) !~ el);
bt_assert(el !~ [(rt, 10, 35..40)]);
bt_assert(el !~ [(ro, 10, *)]);
bt_assert(el !~ []);
el.add((rt, 10, 40));
eclist el2 = el.filter([(rt, 10, 20..40)] );
el2.add((rt, 10, 50));
bt_assert(el.delete([]) = el);
bt_assert(el.filter([]) = --empty--);
# eclist A (1,30,40)
bt_assert(el = --empty--.add((rt, 10, 1)).add((rt, 10, 30)).add((rt, 10, 40)));
bt_assert(format(el) = "(eclist (rt, 10, 1) (rt, 10, 30) (rt, 10, 40))");
# eclist B (30,40,50)
bt_assert(el2 = --empty--.add((rt, 10, 30)).add((rt, 10, 40)).add((rt, 10, 50)));
bt_assert(format(el2) = "(eclist (rt, 10, 30) (rt, 10, 40) (rt, 10, 50))");
# eclist A union B
eclist r = el2.add(el);
bt_assert(r = --empty--.add((rt, 10, 30)).add((rt, 10, 40)).add((rt, 10, 50)).add((rt, 10, 1)));
bt_assert(format(r) = "(eclist (rt, 10, 30) (rt, 10, 40) (rt, 10, 50) (rt, 10, 1))");
# eclist A isect B
r = el.filter(el2);
bt_assert(r = --empty--.add((rt, 10, 30)).add((rt, 10, 40)));
bt_assert(format(r) = "(eclist (rt, 10, 30) (rt, 10, 40))");
# eclist A \ B
r = el.delete(el2);
bt_assert(r = --empty--.add((rt, 10, 1)));
bt_assert(format(r) = "(eclist (rt, 10, 1))");
# eclist in ec set
r = el.filter([(rt, 10, 1), (rt, 10, 25..30), (ro, 10, 40)]);
bt_assert(r = --empty--.add((rt, 10, 1)).add((rt, 10, 30)));
bt_assert(format(r) = "(eclist (rt, 10, 1) (rt, 10, 30))");
# minimim & maximum element
r = --empty--.add((rt, 2, 1)).add((rt, 1, 3)).add((rt, 2, 2)).add((rt, 3, 1)).add((rt, 2, 3));
bt_assert(format(r) = "(eclist (rt, 2, 1) (rt, 1, 3) (rt, 2, 2) (rt, 3, 1) (rt, 2, 3))");
bt_assert(r.min = (rt, 1, 3));
bt_assert(r.max = (rt, 3, 1));
# iteration over eclist
int x = 0;
for ec c in r do
if c > (rt, 2, 0) && c < (rt, 3, 0) then
x = x + 1;
bt_assert(x = 3);
}
bt_test_suite(t_eclist_new, "Testing lists of extended communities");
/*
* Testing sets of Extended Communities
* ------------------------------------
*/
define ecs2 = [(rt, ten, (one+onef(0))*10), (ro, 100000, 100..200), (rt, 12345, *)];
function t_ec_set()
ec set ecs;
{
ecs = [(rt, ten, (one+onef(0))*10), (ro, 100000, 100..200), (rt, 12345, *)];
bt_assert(format(ecs) = "[(rt, 10, 20), (rt, 12345, 0)..(rt, 12345, 4294967295), (ro, 100000, 100)..(ro, 100000, 200)]");
bt_assert(format(ecs2) = "[(rt, 10, 20), (rt, 12345, 0)..(rt, 12345, 4294967295), (ro, 100000, 100)..(ro, 100000, 200)]");
bt_assert((rt, 10, 20) ~ ecs);
bt_assert((ro, 100000, 100) ~ ecs);
bt_assert((ro, 100000, 128) ~ ecs);
bt_assert((ro, 100000, 200) ~ ecs);
bt_assert((rt, 12345, 0) ~ ecs);
bt_assert((rt, 12345, 200000) ~ ecs);
bt_assert((rt, 12345, 4000000) ~ ecs);
bt_assert((ro, 10, 20) !~ ecs);
bt_assert((rt, 10, 21) !~ ecs);
bt_assert((ro, 100000, 99) !~ ecs);
bt_assert((ro, 12345, 10) !~ ecs);
bt_assert((rt, 12346, 0) !~ ecs);
bt_assert((ro, 0.1.134.160, 150) !~ ecs);
case (rt, 12345, 0) {
(rt, 123456, 20000), (rt, 12345, *): bt_assert(true);
(rt, ten, (one+onef(0))*10), (ro, 100000, 100..200): bt_assert(false);
else: bt_assert(false);
}
case (rt, 10, 20) {
(rt, 123456, 20000), (rt, 12345, *): bt_assert(false);
(rt, ten, (one+onef(0))*10), (ro, 100000, 100..200): bt_assert(true);
else: bt_assert(false);
}
case (rt, 123456, 100) {
(rt, 123456, 20000), (rt, 12345, *): bt_assert(false);
(rt, ten, (one+onef(0))*10), (ro, 100000, 100..200): bt_assert(false);
else: bt_assert(true);
}
}
bt_test_suite(t_ec_set, "Testing sets of extended communities");
/*
* Testing Large Communities
* -------------------------
*/
function mktrip(int a) -> lc
{
return (a, 2*a, 3*a);
}
function t_lclist_old()
lclist ll;
lclist ll2;
lclist r;
{
bt_assert(---empty--- = ---empty---);
bt_assert((10, 20, 30) !~ ---empty---);
bt_assert((10, 20, 30).asn = 10);
bt_assert((10, 20, 30).data1 = 20);
bt_assert((10, 20, 30).data2 = 30);
ll = --- empty ---;
ll = add(ll, (ten, 20, 30));
ll = add(ll, (1000, 2000, 3000));
ll = add(ll, mktrip(100000));
bt_assert(format(ll) = "(lclist (10, 20, 30) (1000, 2000, 3000) (100000, 200000, 300000))");
bt_assert(ll.len = 3);
bt_assert(ll = add(add(add(---empty---, (10, 20, 30)), (1000, 2000, 3000)), (100000, 200000, 300000)));
bt_assert(mktrip(1000) ~ ll);
bt_assert(mktrip(100) !~ ll);
ll = --- empty ---;
ll = add(ll, (10, 10, 10));
ll = add(ll, (20, 20, 20));
ll = add(ll, (30, 30, 30));
ll2 = --- empty ---;
ll2 = add(ll2, (20, 20, 20));
ll2 = add(ll2, (30, 30, 30));
ll2 = add(ll2, (40, 40, 40));
bt_assert(delete(ll, []) = ll);
bt_assert(filter(ll, []) = ---empty---);
# lclist A (10, 20, 30)
bt_assert(format(ll) = "(lclist (10, 10, 10) (20, 20, 20) (30, 30, 30))");
# lclist B (20, 30, 40)
bt_assert(format(ll2) = "(lclist (20, 20, 20) (30, 30, 30) (40, 40, 40))");
# lclist A union B
r = add(ll, ll2);
bt_assert(r = add(add(add(add(---empty---, (10,10,10)), (20,20,20)), (30,30,30)), (40,40,40)));
bt_assert(format(r) = "(lclist (10, 10, 10) (20, 20, 20) (30, 30, 30) (40, 40, 40))");
# lclist A isect B
r = filter(ll, ll2);
bt_assert(r = add(add(---empty---, (20, 20, 20)), (30, 30, 30)));
bt_assert(format(r) = "(lclist (20, 20, 20) (30, 30, 30))");
# lclist A \ B
r = delete(ll, ll2);
bt_assert(r = add(---empty---, (10, 10, 10)));
bt_assert(format(r) = "(lclist (10, 10, 10))");
# lclist in lc set
r = filter(ll, [(5..15, *, *), (20, 15..25, *)]);
bt_assert(r = add(add(---empty---, (10, 10, 10)), (20, 20, 20)));
bt_assert(format(r) = "(lclist (10, 10, 10) (20, 20, 20))");
# minimim & maximum element
r = add(add(add(add(add(---empty---, (2, 3, 3)), (1, 2, 3)), (2, 3, 1)), (3, 1, 2)), (2, 1, 3));
bt_assert(format(r) = "(lclist (2, 3, 3) (1, 2, 3) (2, 3, 1) (3, 1, 2) (2, 1, 3))");
bt_assert(r.min = (1, 2, 3));
bt_assert(r.max = (3, 1, 2));
# iteration over lclist
int x = 0;
int y = 0;
lc mx = (0, 0, 0);
for lc c in r do {
int asn2 = c.asn * c.asn;
x = x + asn2 * c.data1;
y = y + asn2 * c.data2;
if c > mx then mx = c;
}
bt_assert(x = 39 && y = 49);
bt_assert(mx = r.max);
}
bt_test_suite(t_lclist_old, "Testing lists of large communities");
function t_lclist_new()
{
bt_assert(---empty--- = ---empty---);
bt_assert((10, 20, 30) !~ ---empty---);
bt_assert((10, 20, 30).asn = 10);
bt_assert((10, 20, 30).data1 = 20);
bt_assert((10, 20, 30).data2 = 30);
lclist ll;
bt_assert(ll = ---empty---);
ll.add((ten, 20, 30));
ll.add((1000, 2000, 3000));
ll.add(mktrip(100000));
bt_assert(ll.empty = ---empty---);
bt_assert(format(ll) = "(lclist (10, 20, 30) (1000, 2000, 3000) (100000, 200000, 300000))");
bt_assert(ll.len = 3);
bt_assert(ll = ---empty---.add((10, 20, 30)).add((1000, 2000, 3000)).add((100000, 200000, 300000)));
bt_assert(mktrip(1000) ~ ll);
bt_assert(mktrip(100) !~ ll);
ll.empty;
ll.add((10, 10, 10));
ll.add((20, 20, 20));
ll.add((30, 30, 30));
lclist ll2;
ll2.add((20, 20, 20));
ll2.add((30, 30, 30));
ll2.add((40, 40, 40));
bt_assert(ll.delete([]) = ll);
bt_assert(ll.filter([]) = ---empty---);
# lclist A (10, 20, 30)
bt_assert(format(ll) = "(lclist (10, 10, 10) (20, 20, 20) (30, 30, 30))");
# lclist B (20, 30, 40)
bt_assert(format(ll2) = "(lclist (20, 20, 20) (30, 30, 30) (40, 40, 40))");
# lclist A union B
lclist r = ll.add(ll2);
bt_assert(r = ---empty---.add((10,10,10)).add((20,20,20)).add((30,30,30)).add((40,40,40)));
bt_assert(format(r) = "(lclist (10, 10, 10) (20, 20, 20) (30, 30, 30) (40, 40, 40))");
# lclist A isect B
r = ll.filter(ll2);
bt_assert(r = ---empty---.add((20, 20, 20)).add((30, 30, 30)));
bt_assert(format(r) = "(lclist (20, 20, 20) (30, 30, 30))");
# lclist A \ B
r = ll.delete(ll2);
bt_assert(r = ---empty---.add((10, 10, 10)));
bt_assert(format(r) = "(lclist (10, 10, 10))");
# lclist in lc set
r = ll.filter([(5..15, *, *), (20, 15..25, *)]);
bt_assert(r = ---empty---.add((10, 10, 10)).add((20, 20, 20)));
bt_assert(format(r) = "(lclist (10, 10, 10) (20, 20, 20))");
# minimim & maximum element
r = ---empty---.add((2, 3, 3)).add((1, 2, 3)).add((2, 3, 1)).add((3, 1, 2)).add((2, 1, 3));
bt_assert(format(r) = "(lclist (2, 3, 3) (1, 2, 3) (2, 3, 1) (3, 1, 2) (2, 1, 3))");
bt_assert(r.min = (1, 2, 3));
bt_assert(r.max = (3, 1, 2));
# iteration over lclist
int x = 0;
int y = 0;
lc mx = (0, 0, 0);
for lc c in r do {
int asn2 = c.asn * c.asn;
x = x + asn2 * c.data1;
y = y + asn2 * c.data2;
if c > mx then mx = c;
}
bt_assert(x = 39 && y = 49);
bt_assert(mx = r.max);
}
bt_test_suite(t_lclist_new, "Testing lists of large communities");
/*
* Testing sets of Large Communities
* ---------------------------------
*/
function t_lclist_set()
lclist ll;
lc set lls;
{
ll = --- empty ---;
ll = add(ll, (10, 20, 30));
ll = add(ll, (1000, 2000, 3000));
ll = add(ll, mktrip(100000));
bt_assert(ll ~ [(5,10,15), (10,20,30)]);
bt_assert(ll ~ [(10,15..25,*)]);
bt_assert(ll ~ [(ten, *, *)]);
bt_assert(ll !~ [(5,10,15), (10,21,30)]);
bt_assert(ll !~ [(10,21..25,*)]);
bt_assert(ll !~ [(11, *, *)]);
bt_assert(ll !~ []);
lls = [(10, 10, 10), (20, 20, 15..25), (30, 30, *), (40, 35..45, *), (50, *, *), (55..65, *, *)];
bt_assert(format(lls) = "[(10, 10, 10), (20, 20, 15)..(20, 20, 25), (30, 30, 0)..(30, 30, 4294967295), (40, 35, 0)..(40, 45, 4294967295), (50, 0, 0)..(50, 4294967295, 4294967295), (55, 0, 0)..(65, 4294967295, 4294967295)]");
bt_assert((10, 10, 10) ~ lls);
bt_assert((20, 20, 25) ~ lls);
bt_assert((20, 20, 26) !~ lls);
bt_assert((30, 30, 0) ~ lls);
bt_assert((40, 35, 40) ~ lls);
bt_assert((40, 34, 40) !~ lls);
bt_assert((50, 0, 0) ~ lls);
bt_assert((60, 60, 60) ~ lls);
bt_assert((70, 60, 60) !~ lls);
case (40, 40, 40) {
(10, 10, 10), (20, 20, 15..25), (30, 30, *), (40, 35..45, *), (50, *, *), (55..65, *, *): bt_assert(true);
(5, 10, 15), (10, 20, 30), (10, 15..25, *), (ten, *, *), (11, *, *): bt_assert(false);
else: bt_assert(false);
}
case (10, 20, 40) {
(10, 10, 10), (20, 20, 15..25), (30, 30, *), (40, 35..45, *), (50, *, *), (55..65, *, *): bt_assert(false);
(5, 10, 15), (10, 20, 30), (10, 15..25, *), (ten, *, *), (11, *, *): bt_assert(true);
else: bt_assert(false);
}
case (12, 50, 40) {
(10, 10, 10), (20, 20, 15..25), (30, 30, *), (40, 35..45, *), (50, *, *), (55..65, *, *): bt_assert(false);
(5, 10, 15), (10, 20, 30), (10, 15..25, *), (ten, *, *), (11, *, *): bt_assert(false);
else: bt_assert(true);
}
}
bt_test_suite(t_lclist_set, "Testing sets of large communities");
/*
* Testing Route Distinguishers
* ----------------------------
*/
function t_rd()
rd x;
{
x = 12345:20000;
bt_assert(format(x) = "12345:20000");
bt_assert(x = 12345:20000);
bt_assert(x < 12345:20010);
bt_assert(x != 12346:20000);
bt_assert(x != 2:12345:20000);
bt_assert(!(x > 12345:200010));
bt_assert(format(0:1:2) = "1:2");
bt_assert(format(10.0.0.1:1000) = "10.0.0.1:1000");
bt_assert(format(100000:20000) = "100000:20000");
bt_assert(format(2:100000:20000) = "100000:20000");
bt_assert(format(2:1000:1000) = "2:1000:1000");
}
bt_test_suite(t_rd, "Testing route distinguishers");
/*
* Testing sets of Route Distinguishers
* ------------------------------------
*/
function t_rd_set()
rd set rds;
{
rds = [];
bt_assert(rds = []);
bt_assert(10:20 !~ rds);
rds = [10:20, 100000:100..100000:200];
bt_assert(format(rds) = "[10:20, 100000:100..100000:200]");
bt_assert(10:20 ~ rds);
bt_assert(10:21 !~ rds);
bt_assert(100000:90 !~ rds);
bt_assert(100000:100 ~ rds);
bt_assert(100000:128 ~ rds);
bt_assert(100000:200 ~ rds);
bt_assert(100010:150 !~ rds);
bt_assert(100010:150 !~ []);
case 100000:130 {
10:20, 100000:100..100000:200: bt_assert(true);
10:21, 100000:90, 100010:150: bt_assert(false);
else: bt_assert(false);
}
case 100000:90 {
10:20, 100000:100..100000:200: bt_assert(false);
10:21, 100000:90, 100010:150: bt_assert(true);
else: bt_assert(false);
}
case 100000:230 {
10:20, 100000:100..100000:200: bt_assert(false);
10:21, 100000:90, 100010:150: bt_assert(false);
else: bt_assert(true);
}
}
bt_test_suite(t_rd_set, "Testing sets of route distinguishers");
/*
* Testing VPN nets
* ----------------
*/
function t_net_vpn()
{
prefix p;
p = 100:200 10.0.1.0/24;
bt_assert(format(p) = "100:200 10.0.1.0/24");
bt_assert(p.type = NET_VPN4);
bt_assert(p.len = 24);
bt_assert(p.ip = 10.0.1.0);
bt_assert(p.rd = 100:200);
p = 1012:2024 fe80:386c::/32;
bt_assert(format(p) = "1012:2024 fe80:386c::/32");
bt_assert(p.type = NET_VPN6);
bt_assert(p.len = 32);
bt_assert(p.ip = fe80:386c::);
bt_assert(p.rd = 1012:2024);
}
bt_test_suite(t_net_vpn, "Testing VPN nets");
/*
* Testing ROA nets
* ----------------
*/
function t_net_roa()
{
prefix p;
p = 12.13.0.0/16 max 24 as 1234;
bt_assert(format(p) = "12.13.0.0/16-24 AS1234");
bt_assert(p.type = NET_ROA4);
bt_assert(p.ip = 12.13.0.0);
bt_assert(p.len = 16);
bt_assert(p.maxlen = 24);
bt_assert(p.asn = 1234);
p = 1000::/8 max 32 as 1234;
bt_assert(format(p) = "1000::/8-32 AS1234");
bt_assert(p.type = NET_ROA6);
bt_assert(p.ip = 1000::);
bt_assert(p.len = 8);
bt_assert(p.maxlen = 32);
bt_assert(p.asn = 1234);
}
bt_test_suite(t_net_roa, "Testing ROA nets");
/*
* Testing Flowspec nets
* ---------------------
*/
function t_net_flowspec()
{
prefix p;
p = flow4 { dst 10.0.0.0/8; };
bt_assert(p.type = NET_FLOW4);
bt_assert(p.ip = 10.0.0.0);
bt_assert(p.len = 8);
bt_assert(p.src = 0.0.0.0/0);
bt_assert(p.dst = 10.0.0.0/8);
bt_assert(p !~ [ 10.0.0.0/8 ] );
bt_assert(p.dst ~ [ 10.0.0.0/8 ] );
p = flow6 { dst ::1/128; };
bt_assert(p.type = NET_FLOW6);
bt_assert(p.ip = ::1);
bt_assert(p.len = 128);
bt_assert(p.src = ::/0);
bt_assert(p.dst = ::1/128);
bt_assert(format(flow4 { dst 10.0.0.0/8; proto = 23; }) = "flow4 { dst 10.0.0.0/8; proto 23; }");
bt_assert(format(flow6 { dst ::1/128; src ::2/127; }) = "flow6 { dst ::1/128; src ::2/127; }");
bt_assert(format(flow6 { next header false 42; }) = "flow6 { next header false 42; }");
bt_assert(format(flow6 { port 80; }) = "flow6 { port 80; }");
bt_assert(format(flow6 { dport > 24 && < 30 || 40..50,60..70,80 && >= 90; }) = "flow6 { dport > 24 && < 30 || 40..50,60..70,80 && >= 90; }");
bt_assert(format(flow6 { sport 0..0x400; }) = "flow6 { sport 0..1024; }");
bt_assert(format(flow6 { icmp type 80; }) = "flow6 { icmp type 80; }");
bt_assert(format(flow6 { icmp code 90; }) = "flow6 { icmp code 90; }");
bt_assert(format(flow6 { tcp flags 0x03/0x0f; }) = "flow6 { tcp flags 0x3/0x3 && 0x0/0xc; }");
bt_assert(format(flow6 { length 0..65535; }) = "flow6 { length 0..65535; }");
bt_assert(format(flow6 { dscp = 63; }) = "flow6 { dscp 63; }");
bt_assert(format(flow6 { fragment is_fragment || !first_fragment; }) = "flow6 { fragment is_fragment || !first_fragment; }");
bt_assert(format(flow6 { label 1000..2000; }) = "flow6 { label 1000..2000; }");
bt_assert(format(flow6 { }) = "flow6 { }");
}
bt_test_suite(t_net_flowspec, "Testing flowspec networks");
/*
* Testing IPv6 SADR nets
* ----------------------
*/
function t_net_sadr()
{
prefix p;
p = fe80:386c::/32 from 2001:db8:1:13::/64;
bt_assert(format(p) = "fe80:386c::/32 from 2001:db8:1:13::/64");
bt_assert(p.type = NET_IP6_SADR);
bt_assert(p.ip = fe80:386c::);
bt_assert(p.len = 32);
bt_assert(p.src = 2001:db8:1:13::/64);
bt_assert(p.dst = fe80:386c::/32);
}
bt_test_suite(t_net_sadr, "Testing IPv6 SADR nets");
/*
* Testing defined() function
* --------------------------
*/
function test_undef(int a)
int b;
{
if a = 3 then {
b = 4;
bt_assert(defined(b));
}
else {
bt_assert(!defined(b));
}
}
function t_define()
int i;
{
test_undef(2);
test_undef(3);
test_undef(2);
bt_assert(defined(1));
bt_assert(defined(1.2.3.4));
}
bt_test_suite(t_define, "Testing defined() function");
/*
* Testing calling functions
* -------------------------
*/
function callme(int arg1; int arg2) -> int
int i;
{
case arg1 {
1, 42: return 42;
else: return arg1 * arg2;
}
return 0;
}
function callmeagain(int a; int b; int c) -> int
{
return a + b + c;
}
function fifteen() -> int
{
return 15;
}
function local_vars(int j)
{
int k = 10;
bt_assert(j = 5 && k = 10);
{
int j = 15;
k = 20;
bt_assert(j = 15 && k = 20);
}
bt_assert(j = 5 && k = 20);
if j < 10 then
{
int j = 25;
string k = "hello";
bt_assert(j = 25 && k = "hello");
}
bt_assert(j = 5 && k = 20);
int m = 100;
{
j = 35;
int k = 40;
bt_assert(j = 35 && k = 40 && m = 100);
}
bt_assert(j = 35 && k = 20 && m = 100);
}
function factorial(int x) -> int
{
if x = 0 then return 0;
if x = 1 then return 1;
else return x * factorial(x - 1);
}
function fibonacci(int x) -> int
{
if x = 0 then return 0;
if x = 1 then return 1;
else return fibonacci(x - 1) + fibonacci(x - 2);
}
function hanoi_init(int a; int b) -> bgppath
{
if b = 0
then return +empty+;
else return prepend(hanoi_init(a + 1, b - 1), a);
}
function hanoi_solve(int n; bgppath h_src; bgppath h_dst; bgppath h_aux; bool x; bool y) -> bgppath
{
# x -> return src or dst
# y -> print state
if n = 0 then { if x then return h_src; else return h_dst; }
bgppath tmp1 = hanoi_solve(n - 1, h_src, h_aux, h_dst, true, y);
bgppath tmp2 = hanoi_solve(n - 1, h_src, h_aux, h_dst, false, false);
h_src = tmp1;
h_aux = tmp2;
int v = h_src.first;
# bt_assert(h_dst = +empty+ || v < h_dst.first);
h_src = delete(h_src, v);
h_dst = prepend(h_dst, v);
if y then
print "move: ", v, " src: ", h_src, " dst:", h_dst, " aux:", h_aux;
tmp1 = hanoi_solve(n - 1, h_aux, h_dst, h_src, true, y);
tmp2 = hanoi_solve(n - 1, h_aux, h_dst, h_src, false, false);
h_aux = tmp1;
h_dst = tmp2;
if x then return h_src; else return h_dst;
}
function t_call_function()
bgppath h_src;
{
bt_assert(fifteen() = 15);
bt_assert(callme(1, 2) = 42);
bt_assert(callme(42, 2) = 42);
bt_assert(callme(2, 2) = 4);
bt_assert(callme(3, 2) = 6);
bt_assert(callme(4, 4) = 16);
bt_assert(callme(7, 2) = 14);
bt_assert(callmeagain(1, 2, 3) = 6);
local_vars(5);
bt_assert(factorial(5) = 120);
bt_assert(factorial(10) = 3628800);
bt_assert(fibonacci(10) = 55);
bt_assert(fibonacci(20) = 6765);
h_src = hanoi_init(1, 6);
bt_assert(format(h_src) = "(path 1 2 3 4 5 6)");
bt_assert(hanoi_solve(6, h_src, +empty+, +empty+, false, false) = h_src);
}
bt_test_suite(t_call_function, "Testing calling functions");
/*
* Test including another config file
* ----------------------------------
*/
function t_include()
int i;
{
i = 1;
include "test.conf.inc";
bt_assert(i = 42);
}
bt_test_suite(t_include, "Testing including another config file");
/*
* Test if-else statement
* ----------------------
*/
function t_if_else()
int i;
{
/* Empty blocks regression test */
if true then {}
else {}
if true then
bt_assert(true);
if false then
bt_assert(false);
else if true then
bt_assert(true);
else
bt_assert(false);
/* Empty blocks regression test */
if true then {}
else {}
}
bt_test_suite(t_if_else, "Testing if-else statement");
/*
* Test for-in statement
* ---------------------
*/
function t_for_in()
{
bgppath p = +empty+.prepend(5).prepend(4).prepend(3).prepend(2).prepend(1);
bgppath q = +empty+.prepend(30).prepend(20).prepend(10);
int a;
# basic for loop
a = 0;
for int i in p do {
a = 2 * a + i;
}
bt_assert(a = 57);
# basic for loop, no braces
a = 0;
for int i in p do a = 2 * a + i;
bt_assert(a = 57);
# for loop with empty body
a = 0;
for int i in p do { }
bt_assert(a = 0);
# for loop over empty path
a = 0;
for int i in +empty+ do a = 1;
bt_assert(a = 0);
# for loop with var name shadowing
a = 0;
for int p in p do {
a = 2 * a + p;
}
bt_assert(a = 57);
# nested for loops
a = 0;
int n = 1;
for int i in p do {
for int j in q do {
a = a + i * j * n;
n = n + 1;
}
}
bt_assert(a = 9300);
}
bt_test_suite(t_for_in, "Testing for-in statement");
/*
* Unused functions -- testing only parsing
* ----------------------------------------
*/
function __test1()
{
if source ~ [ RTS_BGP, RTS_STATIC ] then {
# ospf_metric1 = 65535;
# ospf_metric2 = 1000;
ospf_tag = 0x12345678;
accept;
}
reject;
}
function __test2()
{
if source ~ [ RTS_BGP, RTS_STATIC ] then {
# ospf_metric1 = 65535;
# ospf_metric2 = 1000;
ospf_tag = 0x12345678;
accept;
}
reject;
}
filter testf
int j;
{
print "Heya, filtering route to ", net.ip, " prefixlen ", net.len, " source ", source;
print "This route was from ", from;
j = 7;
j = 17;
if rip_metric > 15 then {
reject "RIP Metric is more than infinity";
}
rip_metric = 14;
unset(rip_metric);
accept "ok I take that";
}
filter roa_filter
{
if net ~ [ 10.0.0.0/8{16,24} ] || net ~ [ 2000::/3{16,96} ] then {
accept;
}
reject;
}
roa4 table r4;
roa6 table r6;
protocol static
{
roa4 { table r4; import filter roa_filter; };
route 10.110.0.0/16 max 16 as 1000;
route 10.120.0.0/16 max 24 as 1000;
route 10.130.0.0/16 max 24 as 2000;
route 10.130.128.0/18 max 24 as 3000;
}
protocol static
{
roa6 { table r6; import filter roa_filter; };
route 2001:0db8:85a3:8a2e::/64 max 96 as 1000;
}
function t_roa_check()
prefix pfx;
{
bt_assert(roa_check(r4, 10.10.0.0/16, 1000) = ROA_UNKNOWN);
bt_assert(roa_check(r4, 10.0.0.0/8, 1000) = ROA_UNKNOWN);
bt_assert(roa_check(r4, 10.110.0.0/16, 1000) = ROA_VALID);
bt_assert(roa_check(r4, 10.110.0.0/16, 2000) = ROA_INVALID);
bt_assert(roa_check(r4, 10.110.32.0/20, 1000) = ROA_INVALID);
bt_assert(roa_check(r4, 10.120.32.0/20, 1000) = ROA_VALID);
bt_assert(roa_check(r4, 10.120.32.0/20, 2000) = ROA_INVALID);
bt_assert(roa_check(r4, 10.120.32.32/28, 1000) = ROA_INVALID);
bt_assert(roa_check(r4, 10.130.130.0/24, 1000) = ROA_INVALID);
bt_assert(roa_check(r4, 10.130.130.0/24, 2000) = ROA_VALID);
bt_assert(roa_check(r4, 10.130.30.0/24, 3000) = ROA_INVALID);
bt_assert(roa_check(r4, 10.130.130.0/24, 3000) = ROA_VALID);
bt_assert(roa_check(r6, 2001:0db8:85a3:8a2e:1234::/80, 1000) = ROA_VALID);
bt_assert(roa_check(r6, 2001:0db8:85a3:8a2e:1234::/97, 1000) = ROA_INVALID);
bt_assert(roa_check(r6, 2001:0db8:85a3:8a2e::/64, 1000) = ROA_VALID);
bt_assert(roa_check(r6, 2001:0db8:85a3::/48, 1000) = ROA_UNKNOWN);
bt_assert(roa_check(r4, 10.10.0.0/16, 1000) = ROA_UNKNOWN);
bt_assert(roa_check(r4, 10.0.0.0/8, 1000) = ROA_UNKNOWN);
bt_assert(roa_check(r4, 10.110.0.0/16, 1000) = ROA_VALID);
bt_assert(roa_check(r4, 10.110.0.0/16, 2000) = ROA_INVALID);
bt_assert(roa_check(r4, 10.110.32.0/20, 1000) = ROA_INVALID);
bt_assert(roa_check(r4, 10.120.32.0/20, 1000) = ROA_VALID);
bt_assert(roa_check(r6, 2001:0db8:85a3:8a2e:1234::/80, 1000) = ROA_VALID);
bt_assert(roa_check(r6, 2001:0db8:85a3:8a2e:1234::/97, 1000) = ROA_INVALID);
bt_assert(roa_check(r6, 2001:0db8:85a3:8a2e::/64, 1000) = ROA_VALID);
bt_assert(roa_check(r6, 2001:0db8:85a3::/48, 1000) = ROA_UNKNOWN);
bt_assert(roa_check(r4, 2001:0db8:85a3:8a2e:1234::/97, 1000) = ROA_UNKNOWN);
bt_assert(roa_check(r6, 2001:0db8:85a3:8a2e:1234::/97, 1000) = ROA_INVALID);
bt_assert(roa_check(r4, 2001:0db8:85a3:8a2e:1234::/80, 1000) = ROA_UNKNOWN);
bt_assert(roa_check(r6, 2001:0db8:85a3:8a2e:1234::/80, 1000) = ROA_VALID);
bt_assert(roa_check(r4, 2001:0db8:85a3::/48, 1000) = ROA_UNKNOWN);
bt_assert(roa_check(r6, 2001:0db8:85a3::/48, 1000) = ROA_UNKNOWN);
bt_assert(10.130.130.0/24 ~ 0.0.0.0/0);
bt_assert(2001:0db8:85a3:8a2e::/64 ~ ::/0);
bt_assert(10.130.130.0/24 !~ ::/0);
bt_assert(2001:0db8:85a3:8a2e::/64 !~ 0.0.0.0/0);
}
bt_test_suite(t_roa_check, "Testing ROA");
aspa table at;
# ASPA structure:
#
#
# 65544 65545
# | \ / \ / |
# 65540 65542 65543 65541
# | |
# 65550 65551
protocol static
{
aspa { table at; };
route aspa 65540 providers 65544, 65549;
route aspa 65541 providers 65545;
route aspa 65542 providers 65544, 65545;
route aspa 65543 providers 65544, 65545;
route aspa 65544 transit;
route aspa 65545 transit;
route aspa 65550 providers 65540;
route aspa 65551 providers 65543;
}
function t_aspa_check()
{
bgppath p1 = +empty+;
p1.prepend(65540);
p1.prepend(65544);
bt_assert(aspa_check(at, p1, false) = ASPA_VALID);
bt_assert(aspa_check(at, p1, true) = ASPA_VALID);
p1.prepend(65542);
bt_assert(aspa_check(at, p1, false) = ASPA_VALID);
bt_assert(aspa_check(at, p1, true) = ASPA_INVALID);
p1.prepend(65555);
bt_assert(aspa_check(at, p1, false) = ASPA_UNKNOWN);
bt_assert(aspa_check(at, p1, true) = ASPA_INVALID);
bgppath p2 = +empty+;
p2.prepend(65554);
p2.prepend(65541);
p2.prepend(65545);
bt_assert(aspa_check(at, p2, false) = ASPA_UNKNOWN);
bt_assert(aspa_check(at, p2, true) = ASPA_UNKNOWN);
p2.prepend(65543);
bt_assert(aspa_check(at, p2, false) = ASPA_UNKNOWN);
bt_assert(aspa_check(at, p2, true) = ASPA_INVALID);
bgppath p3 = +empty+;
p3.prepend(65541);
p3.prepend(65544);
bt_assert(aspa_check(at, p3, false) = ASPA_VALID);
bt_assert(aspa_check(at, p3, true) = ASPA_INVALID);
bgppath p4 = +empty+;
p4.prepend(65540);
p4.prepend(65544);
bt_assert(aspa_check(at, p4, false) = ASPA_VALID);
bt_assert(aspa_check(at, p4, true) = ASPA_VALID);
p4.prepend(65545);
bt_assert(aspa_check(at, p4, false) = ASPA_VALID);
bt_assert(aspa_check(at, p4, true) = ASPA_INVALID);
p4.prepend(65555);
bt_assert(aspa_check(at, p4, false) = ASPA_UNKNOWN);
bt_assert(aspa_check(at, p4, true) = ASPA_INVALID);
bgppath p5 = +empty+.prepend(65550).prepend(65540).prepend(65549);
bt_assert(aspa_check(at, p5, false) = ASPA_VALID);
bt_assert(aspa_check(at, p5, true) = ASPA_VALID);
}
bt_test_suite(t_aspa_check, "Testing ASPA (our tests)");
# Tests from https://github.com/ksriram25/IETF/blob/main/ASPA_path_verification_examples.pdf
aspa table at_official;
protocol static
{
aspa { table at_official; };
route aspa 65541 providers 65543, 65544;
route aspa 65542 providers 65545;
route aspa 65543 providers 65546;
route aspa 65544 providers 65546, 65547;
route aspa 65547 transit;
route aspa 65548 transit;
route aspa 65550 transit;
route aspa 65551 providers 65550;
route aspa 65552 transit;
route aspa 65553 transit;
route aspa 65554 providers 65553;
route aspa 65555 providers 65554;
}
function t_aspa_check_official()
{
int A = 65541; int B = 65542; int C = 65543; int D = 65544;
int E = 65545; int F = 65546; int G = 65547;
bool UP = true; bool DOWN = false;
bgppath p;
# Examples of Upstream Path Verification
# F-G is a lateral peer, we do not prepend
p = +empty+.prepend(A).prepend(C).prepend(F);
bt_assert(aspa_check(at_official, p, UP) = ASPA_VALID);
# D-G is a customer, we do prepend
p = +empty+.prepend(A).prepend(C).prepend(D).prepend(G);
bt_assert(aspa_check(at_official, p, UP) = ASPA_INVALID);
# D-G is a customer, we do prepend
p = +empty+.prepend(A).prepend(C).prepend(F).prepend(D).prepend(G);
bt_assert(aspa_check(at_official, p, UP) = ASPA_UNKNOWN);
# D-C is a lateral peer, we do not prepend
p = +empty+.prepend(B).prepend(E).prepend(D);
bt_assert(aspa_check(at_official, p, UP) = ASPA_UNKNOWN);
# A-C is a customer, we do prepend
p = +empty+.prepend(B).prepend(E).prepend(D).prepend(A).prepend(C);
bt_assert(aspa_check(at_official, p, UP) = ASPA_INVALID);
# A-C is a customer, we do prepend
p = +empty+.prepend(B).prepend(E).prepend(G).prepend(D).prepend(A).prepend(C);
bt_assert(aspa_check(at_official, p, UP) = ASPA_INVALID);
# A-D is a customer, we do prepend
p = +empty+.prepend(F).prepend(C).prepend(A).prepend(D);
bt_assert(aspa_check(at_official, p, UP) = ASPA_INVALID);
# A-D is a customer, we do prepend
p = +empty+.prepend(G).prepend(F).prepend(C).prepend(A).prepend(D);
bt_assert(aspa_check(at_official, p, UP) = ASPA_INVALID);
# E-D is a lateral peer, we do not prepend
p = +empty+.prepend(B).prepend(E);
bt_assert(aspa_check(at_official, p, UP) = ASPA_VALID);
# Examples of Downstream Path Verification
p = +empty+.prepend(A).prepend(C).prepend(F).prepend(G).prepend(E);
bt_assert(aspa_check(at_official, p, DOWN) = ASPA_UNKNOWN);
p = +empty+.prepend(A).prepend(D).prepend(G).prepend(E);
bt_assert(aspa_check(at_official, p, DOWN) = ASPA_VALID);
p = +empty+.prepend(A).prepend(C).prepend(D).prepend(E);
bt_assert(aspa_check(at_official, p, DOWN) = ASPA_UNKNOWN);
p = +empty+.prepend(A).prepend(C).prepend(D).prepend(G).prepend(E);
bt_assert(aspa_check(at_official, p, DOWN) = ASPA_INVALID);
p = +empty+.prepend(G).prepend(D).prepend(F).prepend(C);
bt_assert(aspa_check(at_official, p, DOWN) = ASPA_UNKNOWN);
p = +empty+.prepend(B).prepend(E).prepend(G).prepend(D);
bt_assert(aspa_check(at_official, p, DOWN) = ASPA_VALID);
p = +empty+.prepend(B).prepend(E).prepend(G).prepend(D).prepend(C);
bt_assert(aspa_check(at_official, p, DOWN) = ASPA_INVALID);
p = +empty+.prepend(A).prepend(C).prepend(F);
bt_assert(aspa_check(at_official, p, DOWN) = ASPA_VALID);
# Topology Contains Complex BGP Relationships
int H = 65548; int J = 65549; int K = 65550; int L = 65551;
int P = 65552; int Q = 65553; int R = 65554; int S = 65555;
p = +empty+.prepend(H).prepend(J);
bt_assert(aspa_check(at_official, p, UP) = ASPA_INVALID);
p = +empty+.prepend(H).prepend(J).prepend(K);
bt_assert(aspa_check(at_official, p, DOWN) = ASPA_INVALID);
p = +empty+.prepend(P).prepend(Q);
bt_assert(aspa_check(at_official, p, UP) = ASPA_INVALID);
p = +empty+.prepend(P).prepend(Q);
bt_assert(aspa_check(at_official, p, DOWN) = ASPA_VALID);
p = +empty+.prepend(P).prepend(Q).prepend(R);
bt_assert(aspa_check(at_official, p, DOWN) = ASPA_VALID);
}
bt_test_suite(t_aspa_check_official, "Testing ASPA (official tests)");
filter vpn_filter
{
bt_assert(format(net) = "1:2 10.1.10.0/24");
bt_assert(net.type = NET_VPN4);
bt_assert(net.type != NET_IP4);
bt_assert(net.type != NET_IP6);
bt_assert(net.rd = 0:1:2);
bool b = false;
case (net.type) {
NET_IP4: print "IPV4";
NET_IP6: print "IPV6";
else: b = true;
}
bt_assert(b);
bt_check_assign(from, 10.20.30.40);
# bt_check_assign(gw, 55.55.55.44);
bgp_community.add((3,5));
bgp_ext_community.add((ro, 135, 999));
bgp_large_community.add((6464156, 89646354, 8675643));
mypath.prepend(65533);
mylclist.add((1234, 5678, 90123));
bgppath locpath;
lclist loclclist;
locpath.prepend(65533);
loclclist.add((1234, 5678, 90123));
accept;
}
vpn4 table v4;
vpn4 table v6;
protocol static
{
vpn4 { table v4; import filter vpn_filter; };
route 0:1:2 10.1.10.0/24 unreachable;
}
protocol static
{
ipv6 { import where false; };
route fd01::/48 unreachable;
}
bird2-2.17.5/filter/test.conf.inc 0000664 0000000 0000000 00000000035 15211753245 0016476 0 ustar 00root root 0000000 0000000
bt_assert(1+1 = 2);
i = 42;
bird2-2.17.5/filter/test.conf.overlay 0000664 0000000 0000000 00000000060 15211753245 0017404 0 ustar 00root root 0000000 0000000 attribute int peek_a_boo;
include "test.conf";
bird2-2.17.5/filter/test.conf2 0000664 0000000 0000000 00000003067 15211753245 0016020 0 ustar 00root root 0000000 0000000 /*
* This is an example configuration file.
*/
# Yet another comment
router id 62.168.0.1;
define xyzzy = (120+10);
protocol device {
# disabled;
# interface "eth*", "ppp*";
}
protocol direct {
}
protocol kernel {
disabled;
ipv4; # Must be specified at least one channel
# learn; # Learn all routes from the kernel
# scan time 10; # Scan kernel tables every 10 seconds
}
protocol static {
# disabled;
ipv4 {
export all;
import filter {
print "ahoj";
print source;
if source = RTS_STATIC then {
print "It is from static";
}
print from;
from = 1.2.3.4;
print from;
print scope;
scope = SCOPE_HOST;
print scope;
if !(scope ~ [ SCOPE_HOST, SCOPE_SITE ]) then {
print "Failed in test";
}
preference = 15;
print preference;
preference = 29;
print preference;
rip_metric = 1;
print rip_metric;
rip_metric = rip_metric + 5;
print rip_metric;
bgp_community = -empty-;
print "hi";
bgp_community = add(bgp_community, (1,2));
print "hello";
bgp_community = add(bgp_community, (2,3));
bgp_community.add((4,5));
print "community = ", bgp_community;
bgp_community.delete((2,3));
print "community = ", bgp_community;
bgp_community.empty;
print "community = ", bgp_community;
print "done";
accept;
};
};
route 0.0.0.0/0 via 195.113.31.113;
route 62.168.0.0/25 reject;
route 1.2.3.4/32 via 195.113.31.124;
route 10.0.0.0/8 reject;
route 10.1.1.0/24 via 62.168.0.3;
route 10.1.2.0/24 via 62.168.0.3;
route 10.1.3.0/24 via 62.168.0.4;
route 10.2.0.0/24 via "arc0";
}
bird2-2.17.5/filter/tree.c 0000664 0000000 0000000 00000010501 15211753245 0015202 0 ustar 00root root 0000000 0000000 /*
* Filters: utility functions
*
* Copyright 1998 Pavel Machek
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "lib/alloca.h"
#include "nest/bird.h"
#include "conf/conf.h"
#include "filter/filter.h"
#include "filter/data.h"
/**
* find_tree
* @t: tree to search in
* @val: value to find
*
* Search for given value in the tree. I relies on fact that sorted tree is populated
* by &f_val structures (that can be compared by val_compare()). In each node of tree,
* either single value (then t->from==t->to) or range is present.
*
* Both set matching and |switch() { }| construction is implemented using this function,
* thus both are as fast as they can be.
*/
const struct f_tree *
find_tree(const struct f_tree *t, const struct f_val *val)
{
if (!t)
return NULL;
if ((val_compare(&(t->from), val) != 1) &&
(val_compare(&(t->to), val) != -1))
return t;
if (val_compare(&(t->from), val) == -1)
return find_tree(t->right, val);
else
return find_tree(t->left, val);
}
/**
* find_tree_linear
* @t: tree to search in
* @val: value to find
*
* Search for given value in the degenerated linear tree, which is generated by
* parser before build_tree() is applied. The tree is not sorted and all nodes
* are linked by left ptr.
*/
const struct f_tree *
find_tree_linear(const struct f_tree *t, const struct f_val *val)
{
for (; t; t = t->left)
if ((val_compare(&(t->from), val) != 1) &&
(val_compare(&(t->to), val) != -1))
return t;
return NULL;
}
static struct f_tree *
build_tree_rec(struct f_tree **buf, int l, int h)
{
struct f_tree *n;
int pos;
if (l >= h)
return NULL;
pos = (l+h)/2;
n = buf[pos];
n->left = build_tree_rec(buf, l, pos);
n->right = build_tree_rec(buf, pos+1, h);
return n;
}
static int
tree_compare(const void *p1, const void *p2)
{
return val_compare(&((* (struct f_tree **) p1)->from), &((* (struct f_tree **) p2)->from));
}
/**
* build_tree
* @from: degenerated tree (linked by @tree->left) to be transformed into form suitable for find_tree()
*
* Transforms degenerated tree into balanced tree.
*/
struct f_tree *
build_tree(struct f_tree *from)
{
struct f_tree *tmp, *root;
struct f_tree **buf;
int len, i;
if (from == NULL)
return NULL;
len = 0;
for (tmp = from; tmp != NULL; tmp = tmp->left)
len++;
if (len <= 1024)
buf = alloca(len * sizeof(struct f_tree *));
else
buf = xmalloc(len * sizeof(struct f_tree *));
/* Convert a degenerated tree into an sorted array */
i = 0;
for (tmp = from; tmp != NULL; tmp = tmp->left)
buf[i++] = tmp;
qsort(buf, len, sizeof(struct f_tree *), tree_compare);
root = build_tree_rec(buf, 0, len);
if (len > 1024)
xfree(buf);
return root;
}
struct f_tree *
f_new_tree(void)
{
struct f_tree *ret = cfg_allocz(sizeof(struct f_tree));
return ret;
}
/**
* same_tree
* @t1: first tree to be compared
* @t2: second one
*
* Compares two trees and returns 1 if they are same
*/
int
same_tree(const struct f_tree *t1, const struct f_tree *t2)
{
if ((!!t1) != (!!t2))
return 0;
if (!t1)
return 1;
if (val_compare(&(t1->from), &(t2->from)))
return 0;
if (val_compare(&(t1->to), &(t2->to)))
return 0;
if (!same_tree(t1->left, t2->left))
return 0;
if (!same_tree(t1->right, t2->right))
return 0;
if (!f_same(t1->data, t2->data))
return 0;
return 1;
}
int
tree_node_count(const struct f_tree *t)
{
if (t == NULL)
return 0;
return 1 + tree_node_count(t->left) + tree_node_count(t->right);
}
static void
tree_node_format(const struct f_tree *t, buffer *buf)
{
if (t == NULL)
return;
tree_node_format(t->left, buf);
val_format(&(t->from), buf);
if (val_compare(&(t->from), &(t->to)) != 0)
{
buffer_puts(buf, "..");
val_format(&(t->to), buf);
}
buffer_puts(buf, ", ");
tree_node_format(t->right, buf);
}
void
tree_format(const struct f_tree *t, buffer *buf)
{
buffer_puts(buf, "[");
tree_node_format(t, buf);
if (buf->pos == buf->end)
return;
/* Undo last separator */
if (buf->pos[-1] != '[')
buf->pos -= 2;
buffer_puts(buf, "]");
}
void
tree_walk(const struct f_tree *t, void (*hook)(const struct f_tree *, void *), void *data)
{
if (!t)
return;
tree_walk(t->left, hook, data);
hook(t, data);
tree_walk(t->right, hook, data);
}
bird2-2.17.5/filter/tree_test.c 0000664 0000000 0000000 00000015411 15211753245 0016246 0 ustar 00root root 0000000 0000000 /*
* Filters: Utility Functions Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "test/bt-utils.h"
#include "filter/filter.h"
#include "filter/data.h"
#include "conf/conf.h"
#define MAX_TREE_HEIGHT 13
static void
start_conf_env(void)
{
bt_bird_init();
cfg_mem = tmp_linpool;
}
static struct f_tree *
new_tree(uint id)
{
struct f_tree *tree = f_new_tree();
tree->from.type = tree->to.type = T_INT;
tree->from.val.i = tree->to.val.i = id;
return tree;
}
/*
* Show subtree in infix notation
*/
static void
show_subtree(struct f_tree *node)
{
if (!node)
return;
show_subtree(node->left);
if (node->from.val.i == node->to.val.i)
bt_debug("%u ", node->from.val.i);
else
bt_debug("%u..%u ", node->from.val.i, node->to.val.i);
show_subtree(node->right);
}
static void
show_tree2(struct f_tree *root_node, const char *tree_name)
{
bt_debug("%s: \n", tree_name);
bt_debug("[ ");
show_subtree(root_node);
bt_debug("]\n\n");
}
#define show_tree(tree) show_tree2(tree, #tree);
static uint
get_nodes_count_full_bin_tree(uint height)
{
return (bt_naive_pow(2, height+1) - 1);
}
static struct f_tree *
get_balanced_full_subtree(uint height, uint idx)
{
struct f_tree *node = new_tree(idx);
if (height > 0)
{
uint nodes_in_subtree = get_nodes_count_full_bin_tree(--height);
node->left = get_balanced_full_subtree(height, idx - nodes_in_subtree/2 - 1);
node->right = get_balanced_full_subtree(height, idx + nodes_in_subtree/2 + 1);
}
return node;
}
static struct f_tree *
get_balanced_full_tree(uint height)
{
return get_balanced_full_subtree(height, get_nodes_count_full_bin_tree(height)/2);
}
static struct f_tree *
get_degenerated_left_tree(uint nodes_count)
{
struct f_tree *old = NULL;
struct f_tree *new = NULL;
uint i;
for (i = 0; i < nodes_count; i++)
{
old = new;
new = new_tree(nodes_count-1-i);
new->left = old;
}
return new;
}
static struct f_tree *
get_random_degenerated_left_tree(uint nodes_count)
{
struct f_tree *tree = get_degenerated_left_tree(nodes_count);
size_t avaible_indexes_size = nodes_count * sizeof(byte);
byte *avaible_indexes = malloc(avaible_indexes_size);
memset(avaible_indexes, 0, avaible_indexes_size);
struct f_tree *n;
for (n = tree; n; n = n->left)
{
uint selected_idx;
do
{
selected_idx = bt_random() % nodes_count;
} while(avaible_indexes[selected_idx] != 0);
avaible_indexes[selected_idx] = 1;
n->from.type = n->to.type = T_INT;
n->from.val.i = n->to.val.i = selected_idx;
}
free(avaible_indexes);
return tree;
}
static struct f_tree *
get_balanced_tree_with_ranged_values(uint nodes_count)
{
struct f_tree *tree = get_degenerated_left_tree(nodes_count);
uint idx = 0;
struct f_tree *n;
for (n = tree; n; n = n->left)
{
n->from.type = n->to.type = T_INT;
n->from.val.i = idx;
idx += (uint)bt_random() / nodes_count; /* (... / nodes_count) preventing overflow an uint idx */
n->to.val.i = idx++;
}
return build_tree(tree);
}
static int
t_balancing(void)
{
start_conf_env();
uint height;
for (height = 1; height < MAX_TREE_HEIGHT; height++)
{
uint nodes_count = get_nodes_count_full_bin_tree(height);
struct f_tree *simple_degenerated_tree = get_degenerated_left_tree(nodes_count);
show_tree(simple_degenerated_tree);
struct f_tree *expected_balanced_tree = get_balanced_full_tree(height);
show_tree(expected_balanced_tree);
struct f_tree *balanced_tree_from_simple = build_tree(simple_degenerated_tree);
show_tree(balanced_tree_from_simple);
bt_assert(same_tree(balanced_tree_from_simple, expected_balanced_tree));
}
return 1;
}
static int
t_balancing_random(void)
{
start_conf_env();
uint height;
for (height = 1; height < MAX_TREE_HEIGHT; height++)
{
uint nodes_count = get_nodes_count_full_bin_tree(height);
struct f_tree *expected_balanced_tree = get_balanced_full_tree(height);
uint i;
for(i = 0; i < 10; i++)
{
struct f_tree *random_degenerated_tree = get_random_degenerated_left_tree(nodes_count);
show_tree(random_degenerated_tree);
struct f_tree *balanced_tree_from_random = build_tree(random_degenerated_tree);
show_tree(expected_balanced_tree);
show_tree(balanced_tree_from_random);
bt_assert(same_tree(balanced_tree_from_random, expected_balanced_tree));
}
}
return 1;
}
static int
t_find(void)
{
start_conf_env();
uint height;
for (height = 1; height < MAX_TREE_HEIGHT; height++)
{
uint nodes_count = get_nodes_count_full_bin_tree(height);
struct f_tree *tree = get_balanced_full_tree(height);
show_tree(tree);
struct f_val looking_up_value = {
.type = T_INT
};
for(looking_up_value.val.i = 0; looking_up_value.val.i < nodes_count; looking_up_value.val.i++)
{
const struct f_tree *found_tree = find_tree(tree, &looking_up_value);
bt_assert((val_compare(&looking_up_value, &(found_tree->from)) == 0) && (val_compare(&looking_up_value, &(found_tree->to)) == 0));
}
}
return 1;
}
static uint
get_max_value_in_unbalanced_tree(struct f_tree *node, uint max)
{
if (!node)
return max;
if (node->to.val.i > max)
max = node->to.val.i;
uint max_left = get_max_value_in_unbalanced_tree(node->left, max);
if (max_left > max)
max = max_left;
uint max_right = get_max_value_in_unbalanced_tree(node->right, max);
if (max_right > max)
max = max_right;
return max;
}
static int
t_find_ranges(void)
{
start_conf_env();
uint height;
for (height = 1; height < MAX_TREE_HEIGHT; height++)
{
uint nodes_count = get_nodes_count_full_bin_tree(height);
struct f_tree *tree = get_balanced_tree_with_ranged_values(nodes_count);
uint max_value = get_max_value_in_unbalanced_tree(tree, 0);
show_tree(tree);
bt_debug("max_value: %u \n", max_value);
struct f_val needle = {
.type = T_INT
};
uint *i = &needle.val.i;
for(*i = 0; *i <= max_value; *i += (uint)bt_random()/nodes_count)
{
const struct f_tree *found_tree = find_tree(tree, &needle);
bt_debug("searching: %u \n", *i);
bt_assert(
(val_compare(&needle, &(found_tree->from)) == 0) || (val_compare(&needle, &(found_tree->to)) == 0) ||
((val_compare(&needle, &(found_tree->from)) == 1) && (val_compare(&needle, &(found_tree->to)) == -1))
);
}
}
return 1;
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_balancing, "Balancing strong unbalanced trees");
bt_test_suite(t_balancing_random, "Balancing random unbalanced trees");
bt_test_suite(t_find, "Finding values in trees");
bt_test_suite(t_find_ranges, "Finding values in trees with random ranged values");
return bt_exit_value();
}
bird2-2.17.5/filter/trie.c 0000664 0000000 0000000 00000100371 15211753245 0015213 0 ustar 00root root 0000000 0000000 /*
* Filters: Trie for prefix sets
*
* (c) 2009--2021 Ondrej Zajicek
* (c) 2009--2021 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
/**
* DOC: Trie for prefix sets
*
* We use a (compressed) trie to represent prefix sets. Every node in the trie
* represents one prefix (&addr/&plen) and &plen also indicates the index of
* bits in the address that are used to branch at the node. Note that such
* prefix is not necessary a member of the prefix set, it is just a canonical
* prefix associated with a node. Prefix lengths of nodes are aligned to
* multiples of &TRIE_STEP (4) and there is 16-way branching in each
* node. Therefore, we say that a node is associated with a range of prefix
* lengths (&plen .. &plen + TRIE_STEP - 1).
*
* The prefix set is not just a set of prefixes, it is defined by a set of
* prefix patterns. Each prefix pattern consists of &ppaddr/&pplen and two
* integers: &low and &high. The tested prefix &paddr/&plen matches that pattern
* if the first MIN(&plen, &pplen) bits of &paddr and &ppaddr are the same and
* &low <= &plen <= &high.
*
* There are two ways to represent accepted prefixes for a node. First, there is
* a bitmask &local, which represents independently all 15 prefixes that extend
* the canonical prefix of the node and are within a range of prefix lengths
* associated with the node. E.g., for node 10.0.0.0/8 they are 10.0.0.0/8,
* 10.0.0.0/9, 10.128.0.0/9, .. 10.224.0.0/11. This order (first by length, then
* lexicographically) is used for indexing the bitmask &local, starting at
* position 1. I.e., index is 2^(plen - base) + offset within the same length,
* see function trie_local_mask6() for details.
*
* Second, we use a bitmask &accept to represent accepted prefix lengths at a
* node. The bit is set means that all prefixes of given length that are either
* subprefixes or superprefixes of the canonical prefix are accepted. As there
* are 33 prefix lengths (0..32 for IPv4), but there is just one prefix of zero
* length in the whole trie so we have &zero flag in &f_trie (indicating whether
* the trie accepts prefix 0.0.0.0/0) as a special case, and &accept bitmask
* represents accepted prefix lengths from 1 to 32.
*
* One complication is handling of prefix patterns with unaligned prefix length.
* When such pattern is to be added, we add a primary node above (with rounded
* down prefix length &nlen) and a set of secondary nodes below (with rounded up
* prefix lengths &slen). Accepted prefix lengths of the original prefix pattern
* are then represented in different places based on their lengths. For prefixes
* shorter than &nlen, it is &accept bitmask of the primary node, for prefixes
* between &nlen and &slen - 1 it is &local bitmask of the primary node, and for
* prefixes longer of equal &slen it is &accept bitmasks of secondary nodes.
*
* There are two cases in prefix matching - a match when the length of the
* prefix is smaller that the length of the prefix pattern, (&plen < &pplen) and
* otherwise. The second case is simple - we just walk through the trie and look
* at every visited node whether that prefix accepts our prefix length (&plen).
* The first case is tricky - we do not want to examine every descendant of a
* final node, so (when we create the trie) we have to propagate that
* information from nodes to their ascendants.
*
* There are two kinds of propagations - propagation from child's &accept
* bitmask to parent's &accept bitmask, and propagation from child's &accept
* bitmask to parent's &local bitmask. The first kind is simple - as all
* superprefixes of a parent are also all superprefixes of appropriate length of
* a child, then we can just add (by bitwise or) a child &accept mask masked by
* parent prefix length mask to the parent &accept mask. This handles prefixes
* shorter than node &plen.
*
* The second kind of propagation is necessary to handle superprefixes of a
* child that are represented by parent &local mask - that are in the range of
* prefix lengths associated with the parent. For each accepted (by child
* &accept mask) prefix length from that range, we need to set appropriate bit
* in &local mask. See function trie_amask_to_local() for details.
*
* There are four cases when we walk through a trie:
*
* - we are in NULL
* - we are out of path (prefixes are inconsistent)
* - we are in the wanted (final) node (node length == &plen)
* - we are beyond the end of path (node length > &plen)
* - we are still on path and keep walking (node length < &plen)
*
* The walking code in trie_match_net() is structured according to these cases.
*
* Iteration over prefixes in a trie can be done using TRIE_WALK() macro, or
* directly using trie_walk_init() and trie_walk_next() functions. The second
* approach allows suspending the iteration and continuing in it later.
* Prefixes are enumerated in the usual lexicographic order and may be
* restricted to a subset of the trie (all subnets of a specified prefix).
*
* Note that the trie walk does not reliably enumerate `implicit' prefixes
* defined by &low and &high fields in prefix patterns, it is supposed to be
* used on tries constructed from `explicit' prefixes (&low == &plen == &high
* in call to trie_add_prefix()).
*
* The trie walk has three basic state variables stored in the struct
* &f_trie_walk_state -- the current node in &stack[stack_pos], &accept_length
* for iteration over inter-node prefixes (non-branching prefixes on compressed
* path between the current node and its parent node, stored in the bitmap
* &accept of the current node) and &local_pos for iteration over intra-node
* prefixes (stored in the bitmap &local).
*
* The trie also supports longest-prefix-match query by trie_match_longest_ip4()
* and it can be extended to iteration over all covering prefixes for a given
* prefix (from longest to shortest) using TRIE_WALK_TO_ROOT_IP4() macro. There
* are also IPv6 versions (for practical reasons, these functions and macros are
* separate for IPv4 and IPv6). There is the same limitation to enumeration of
* `implicit' prefixes like with the previous TRIE_WALK() macro.
*/
#include "nest/bird.h"
#include "lib/string.h"
#include "conf/conf.h"
#include "filter/filter.h"
#include "filter/data.h"
/*
* In the trie_add_prefix(), we use ip_addr (assuming that it is the same as
* ip6_addr) to handle both IPv4 and IPv6 prefixes. In contrast to rest of the
* BIRD, IPv4 addresses are just zero-padded from right. That is why we have
* ipt_from_ip4() and ipt_to_ip4() macros below.
*/
#define ipa_mkmask(x) ip6_mkmask(x)
#define ipa_masklen(x) ip6_masklen(&x)
#define ipa_pxlen(x,y) ip6_pxlen(x,y)
#define ipa_getbit(a,p) ip6_getbit(a,p)
#define ipa_getbits(a,p,n) ip6_getbits(a,p,n)
#define ipa_setbits(a,p,n) ip6_setbits(a,p,n)
#define trie_local_mask(a,b,c) trie_local_mask6(a,b,c)
#define ipt_from_ip4(x) _MI6(_I(x), 0, 0, 0)
#define ipt_to_ip4(x) _MI4(_I0(x))
/**
* f_new_trie - allocates and returns a new empty trie
* @lp: linear pool to allocate items from
* @data_size: user data attached to node
*/
struct f_trie *
f_new_trie(linpool *lp, uint data_size)
{
struct f_trie * ret;
ret = lp_allocz(lp, sizeof(struct f_trie) + data_size);
ret->lp = lp;
ret->ipv4 = -1;
ret->data_size = data_size;
return ret;
}
static inline struct f_trie_node4 *
new_node4(struct f_trie *t, uint plen, uint local, ip4_addr paddr, ip4_addr pmask, ip4_addr amask)
{
struct f_trie_node4 *n = lp_allocz(t->lp, sizeof(struct f_trie_node4) + t->data_size);
n->plen = plen;
n->local = local;
n->addr = paddr;
n->mask = pmask;
n->accept = amask;
return n;
}
static inline struct f_trie_node6 *
new_node6(struct f_trie *t, uint plen, uint local, ip6_addr paddr, ip6_addr pmask, ip6_addr amask)
{
struct f_trie_node6 *n = lp_allocz(t->lp, sizeof(struct f_trie_node6) + t->data_size);
n->plen = plen;
n->local = local;
n->addr = paddr;
n->mask = pmask;
n->accept = amask;
return n;
}
static inline struct f_trie_node *
new_node(struct f_trie *t, uint plen, uint local, ip_addr paddr, ip_addr pmask, ip_addr amask)
{
if (t->ipv4)
return (struct f_trie_node *) new_node4(t, plen, local, ipt_to_ip4(paddr), ipt_to_ip4(pmask), ipt_to_ip4(amask));
else
return (struct f_trie_node *) new_node6(t, plen, local, ipa_to_ip6(paddr), ipa_to_ip6(pmask), ipa_to_ip6(amask));
}
static inline void
attach_node4(struct f_trie_node4 *parent, struct f_trie_node4 *child)
{
parent->c[ip4_getbits(child->addr, parent->plen, TRIE_STEP)] = child;
}
static inline void
attach_node6(struct f_trie_node6 *parent, struct f_trie_node6 *child)
{
parent->c[ip6_getbits(child->addr, parent->plen, TRIE_STEP)] = child;
}
static inline void
attach_node(struct f_trie_node *parent, struct f_trie_node *child, int v4)
{
if (v4)
attach_node4(&parent->v4, &child->v4);
else
attach_node6(&parent->v6, &child->v6);
}
/*
* Internal prefixes of a node a represented by the local bitmask, each bit for
* one prefix. Bit 0 is unused, Bit 1 is for the main prefix of the node,
* remaining bits correspond to subprefixes by this pattern:
*
* 1
* 2 3
* 4 5 6 7
* 8 9 A B C D E F
*
* E.g. for 10.0.0.0/8 node, the 10.64.0.0/10 would be position 5.
*/
/*
* Compute appropriate mask representing prefix px/plen in local bitmask of node
* with prefix length nlen. Assuming that nlen <= plen < (nlen + TRIE_STEP).
*/
static inline uint
trie_local_mask4(ip4_addr px, uint plen, uint nlen)
{
uint step = plen - nlen;
uint pos = (1u << step) + ip4_getbits(px, nlen, step);
return 1u << pos;
}
static inline uint
trie_local_mask6(ip6_addr px, uint plen, uint nlen)
{
uint step = plen - nlen;
uint pos = (1u << step) + ip6_getbits(px, nlen, step);
return 1u << pos;
}
/*
* Compute an appropriate local mask (for a node with prefix length nlen)
* representing prefixes of px that are accepted by amask and fall within the
* range associated with that node. Used for propagation of child accept mask
* to parent local mask.
*/
static inline uint
trie_amask_to_local(ip_addr px, ip_addr amask, uint nlen)
{
uint local = 0;
for (uint plen = MAX(nlen, 1); plen < (nlen + TRIE_STEP); plen++)
if (ipa_getbit(amask, plen - 1))
local |= trie_local_mask(px, plen, nlen);
return local;
}
/*
* Compute a bitmask representing a level of subprefixes (of the same length),
* using specified position as a root. E.g., level 2 from root position 3 would
* be bit positions C-F, returned as bitmask 0xf000.
*/
static inline uint
trie_level_mask(uint pos, uint level)
{
return ((1u << (1u << level)) - 1) << (pos << level);
}
#define GET_ADDR(N,F,X) ((X) ? ipt_from_ip4((N)->v4.F) : ipa_from_ip6((N)->v6.F))
#define SET_ADDR(N,F,X,V) ({ if (X) (N)->v4.F =ipt_to_ip4(V); else (N)->v6.F =ipa_to_ip6(V); })
#define GET_LOCAL(N,X) ((X) ? (N)->v4.local : (N)->v6.local)
#define ADD_LOCAL(N,X,V) ({ uint v_ = (V); if (X) (N)->v4.local |= v_; else (N)->v6.local |= v_; })
#define GET_CHILD(N,X,I) ((X) ? (struct f_trie_node *) (N)->v4.c[I] : (struct f_trie_node *) (N)->v6.c[I])
static void *
trie_add_node(struct f_trie *t, uint plen, ip_addr px, uint local, uint l, uint h)
{
uint l_ = l ? (l - 1) : 0;
ip_addr amask = (l_ < h) ? ipa_xor(ipa_mkmask(l_), ipa_mkmask(h)) : IPA_NONE;
ip_addr pmask = ipa_mkmask(plen);
ip_addr paddr = ipa_and(px, pmask);
struct f_trie_node *o = NULL;
struct f_trie_node *n = &t->root;
int v4 = t->ipv4;
/* Add all bits for each active level (0x0002 0x000c 0x00f0 0xff00) */
for (uint i = 0; i < TRIE_STEP; i++)
if ((l <= (plen + i)) && ((plen + i) <= h))
local |= trie_level_mask(1, i);
DBG("Insert node %I/%u (%I %x)\n", paddr, plen, amask, local);
while (n)
{
ip_addr naddr = GET_ADDR(n, addr, v4);
ip_addr nmask = GET_ADDR(n, mask, v4);
ip_addr accept = GET_ADDR(n, accept, v4);
ip_addr cmask = ipa_and(nmask, pmask);
uint nlen = v4 ? n->v4.plen : n->v6.plen;
DBG("Found node %I/%u (%I %x)\n",
naddr, nlen, accept, v4 ? n->v4.local : n->v6.local);
if (ipa_compare(ipa_and(paddr, cmask), ipa_and(naddr, cmask)))
{
/* We are out of path - we have to add branching node 'b'
between node 'o' and node 'n', and attach new node 'a'
as the other child of 'b'. */
int blen = ROUND_DOWN_POW2(ipa_pxlen(paddr, naddr), TRIE_STEP);
ip_addr bmask = ipa_mkmask(blen);
ip_addr baddr = ipa_and(px, bmask);
/* Merge accept masks from children to get accept mask for node 'b' */
ip_addr baccm = ipa_and(ipa_or(amask, accept), bmask);
uint bloc = trie_amask_to_local(naddr, accept, blen) |
trie_amask_to_local(paddr, amask, blen);
struct f_trie_node *a = new_node(t, plen, local, paddr, pmask, amask);
struct f_trie_node *b = new_node(t, blen, bloc, baddr, bmask, baccm);
attach_node(o, b, v4);
attach_node(b, n, v4);
attach_node(b, a, v4);
t->prefix_count++;
DBG("Case 1\n");
return a;
}
if (plen < nlen)
{
/* We add new node 'a' between node 'o' and node 'n' */
amask = ipa_or(amask, ipa_and(accept, pmask));
local |= trie_amask_to_local(naddr, accept, plen);
struct f_trie_node *a = new_node(t, plen, local, paddr, pmask, amask);
attach_node(o, a, v4);
attach_node(a, n, v4);
t->prefix_count++;
DBG("Case 2\n");
return a;
}
if (plen == nlen)
{
/* We already found added node in trie. Just update accept and local mask */
accept = ipa_or(accept, amask);
SET_ADDR(n, accept, v4, accept);
if ((GET_LOCAL(n, v4) & local) != local)
t->prefix_count++;
ADD_LOCAL(n, v4, local);
DBG("Case 3\n");
return n;
}
/* Update accept mask part M2 and go deeper */
accept = ipa_or(accept, ipa_and(amask, nmask));
SET_ADDR(n, accept, v4, accept);
ADD_LOCAL(n, v4, trie_amask_to_local(paddr, amask, nlen));
DBG("Step %u\n", ipa_getbits(paddr, nlen));
/* n->plen < plen and plen <= 32 (128) */
o = n;
n = GET_CHILD(n, v4, ipa_getbits(paddr, nlen, TRIE_STEP));
}
/* We add new tail node 'a' after node 'o' */
struct f_trie_node *a = new_node(t, plen, local, paddr, pmask, amask);
attach_node(o, a, v4);
t->prefix_count++;
DBG("Case 4\n");
return a;
}
/**
* trie_add_prefix
* @t: trie to add to
* @net: IP network prefix
* @l: prefix lower bound
* @h: prefix upper bound
*
* Adds prefix (prefix pattern) @n to trie @t. @l and @h are lower
* and upper bounds on accepted prefix lengths, both inclusive.
* 0 <= l, h <= 32 (128 for IPv6).
*
* Returns a pointer to the allocated node. The function can return a pointer to
* an existing node if @px and @plen are the same. If px/plen == 0/0 (or ::/0),
* a pointer to the root node is returned. Returns NULL when called with
* mismatched IPv4/IPv6 net type.
*/
void *
trie_add_prefix(struct f_trie *t, const net_addr *net, uint l, uint h)
{
uint plen = net_pxlen(net);
ip_addr px;
int v4;
switch (net->type)
{
case NET_IP4:
case NET_VPN4:
case NET_ROA4:
px = ipt_from_ip4(net4_prefix(net));
v4 = 1;
break;
case NET_IP6:
case NET_VPN6:
case NET_ROA6:
case NET_IP6_SADR:
px = ipa_from_ip6(net6_prefix(net));
v4 = 0;
break;
default:
bug("invalid type");
}
if (t->ipv4 != v4)
{
if (t->ipv4 < 0)
t->ipv4 = v4;
else
return NULL;
}
DBG("\nInsert net %N (%u-%u)\n", net, l, h);
if (l == 0)
t->zero = 1;
if (h < plen)
plen = h;
/* Primary node length, plen rounded down */
uint nlen = ROUND_DOWN_POW2(plen, TRIE_STEP);
if (plen == nlen)
return trie_add_node(t, nlen, px, 0, l, h);
/* Secondary node length, plen rouned up */
uint slen = nlen + TRIE_STEP;
void *node = NULL;
/*
* For unaligned prefix lengths it is more complicated. We need to encode
* matching prefixes of lengths from l to h. There are three cases of lengths:
*
* 1) 0..nlen are encoded by the accept mask of the primary node
* 2) nlen..(slen-1) are encoded by the local mask of the primary node
* 3) slen..max are encoded in secondary nodes
*/
if (l < slen)
{
uint local = 0;
/* Compute local bits for accepted nlen..(slen-1) prefixes */
for (uint i = 0; i < TRIE_STEP; i++)
if ((l <= (nlen + i)) && ((nlen + i) <= h))
{
uint pos = (1u << i) + ipa_getbits(px, nlen, i);
uint len = ((nlen + i) <= plen) ? 1 : (1u << (nlen + i - plen));
/* We need to fill 'len' bits starting at 'pos' position */
local |= ((1u << len) - 1) << pos;
}
/* Add the primary node */
node = trie_add_node(t, nlen, px, local, l, nlen);
}
if (slen <= h)
{
uint l2 = MAX(l, slen);
uint max = (1u << (slen - plen));
/* Add secondary nodes */
for (uint i = 0; i < max; i++)
node = trie_add_node(t, slen, ipa_setbits(px, slen - 1, i), 0, l2, h);
}
return node;
}
static int
trie_match_net4(const struct f_trie *t, ip4_addr px, uint plen)
{
if (plen == 0)
return t->zero;
int plentest = plen - 1;
uint nlen = ROUND_DOWN_POW2(plen, TRIE_STEP);
uint local = trie_local_mask4(px, plen, nlen);
const struct f_trie_node4 *n = &t->root.v4;
while (n)
{
/* We are out of path */
if (!ip4_prefix_equal(px, n->addr, MIN(plen, n->plen)))
return 0;
/* Check local mask */
if ((n->plen == nlen) && (n->local & local))
return 1;
/* Check accept mask */
if (ip4_getbit(n->accept, plentest))
return 1;
/* We finished trie walk and still no match */
if (nlen <= n->plen)
return 0;
/* Choose children */
n = n->c[ip4_getbits(px, n->plen, TRIE_STEP)];
}
return 0;
}
static int
trie_match_net6(const struct f_trie *t, ip6_addr px, uint plen)
{
if (plen == 0)
return t->zero;
int plentest = plen - 1;
uint nlen = ROUND_DOWN_POW2(plen, TRIE_STEP);
uint local = trie_local_mask6(px, plen, nlen);
const struct f_trie_node6 *n = &t->root.v6;
while (n)
{
/* We are out of path */
if (!ip6_prefix_equal(px, n->addr, MIN(plen, n->plen)))
return 0;
/* Check local mask */
if ((n->plen == nlen) && (n->local & local))
return 1;
/* Check accept mask */
if (ip6_getbit(n->accept, plentest))
return 1;
/* We finished trie walk and still no match */
if (nlen <= n->plen)
return 0;
/* Choose children */
n = n->c[ip6_getbits(px, n->plen, TRIE_STEP)];
}
return 0;
}
/**
* trie_match_net
* @t: trie
* @n: net address
*
* Tries to find a matching net in the trie such that
* prefix @n matches that prefix pattern. Returns 1 if there
* is such prefix pattern in the trie.
*/
int
trie_match_net(const struct f_trie *t, const net_addr *n)
{
switch (n->type)
{
case NET_IP4:
case NET_VPN4:
case NET_ROA4:
return t->ipv4 ? trie_match_net4(t, net4_prefix(n), net_pxlen(n)) : 0;
case NET_IP6:
case NET_VPN6:
case NET_ROA6:
return !t->ipv4 ? trie_match_net6(t, net6_prefix(n), net_pxlen(n)) : 0;
default:
return 0;
}
}
/**
* trie_match_longest_ip4
* @t: trie
* @net: net address
* @dst: return value
* @found0: optional returned bitmask of found nodes
*
* Perform longest prefix match for the address @net and return the resulting
* prefix in the buffer @dst. The bitmask @found0 is used to report lengths of
* prefixes on the path from the root to the resulting prefix. E.g., if there is
* also a /20 shorter matching prefix, then 20-th bit is set in @found0. This
* can be used to enumerate all matching prefixes for the network @net using
* function trie_match_next_longest_ip4() or macro TRIE_WALK_TO_ROOT_IP4().
*
* This function assumes IPv4 trie, there is also an IPv6 variant. The @net
* argument is typed as net_addr_ip4, but would accept any IPv4-based net_addr,
* like net4_prefix(). Anyway, returned @dst is always net_addr_ip4.
*
* Result: 1 if a matching prefix was found, 0 if not.
*/
int
trie_match_longest_ip4(const struct f_trie *t, const net_addr_ip4 *net, net_addr_ip4 *dst, ip4_addr *found0)
{
ASSERT(t->ipv4);
const ip4_addr prefix = net->prefix;
const int pxlen = net->pxlen;
const struct f_trie_node4 *n = &t->root.v4;
int len = 0;
ip4_addr found = IP4_NONE;
int last = -1;
while (n)
{
/* We are out of path */
if (!ip4_prefix_equal(prefix, n->addr, MIN(pxlen, n->plen)))
goto done;
/* Check accept mask */
for (; len < n->plen; len++)
{
if (len > pxlen)
goto done;
if (ip4_getbit(n->accept, len - 1))
{
/* len is always < 32 due to len < n->plen */
ip4_setbit(&found, len);
last = len;
}
}
/* Special case for max length, there is only one valid local position */
if (len == IP4_MAX_PREFIX_LENGTH)
{
if (n->local & (1u << 1))
last = len;
goto done;
}
/* Check local mask */
for (int pos = 1; pos < (1 << TRIE_STEP); pos = 2 * pos + ip4_getbit(prefix, len), len++)
{
if (len > pxlen)
goto done;
if (n->local & (1u << pos))
{
/* len is always < 32 due to special case above */
ip4_setbit(&found, len);
last = len;
}
}
/* Choose child */
n = n->c[ip4_getbits(prefix, n->plen, TRIE_STEP)];
}
done:
if (last < 0)
return 0;
*dst = NET_ADDR_IP4(ip4_and(prefix, ip4_mkmask(last)), last);
if (found0)
*found0 = found;
return 1;
}
/**
* trie_match_longest_ip6
* @t: trie
* @net: net address
* @dst: return value
* @found0: optional returned bitmask of found nodes
*
* Perform longest prefix match for the address @net and return the resulting
* prefix in the buffer @dst. The bitmask @found0 is used to report lengths of
* prefixes on the path from the root to the resulting prefix. E.g., if there is
* also a /20 shorter matching prefix, then 20-th bit is set in @found0. This
* can be used to enumerate all matching prefixes for the network @net using
* function trie_match_next_longest_ip6() or macro TRIE_WALK_TO_ROOT_IP6().
*
* This function assumes IPv6 trie, there is also an IPv4 variant. The @net
* argument is typed as net_addr_ip6, but would accept any IPv6-based net_addr,
* like net6_prefix(). Anyway, returned @dst is always net_addr_ip6.
*
* Result: 1 if a matching prefix was found, 0 if not.
*/
int
trie_match_longest_ip6(const struct f_trie *t, const net_addr_ip6 *net, net_addr_ip6 *dst, ip6_addr *found0)
{
ASSERT(!t->ipv4);
const ip6_addr prefix = net->prefix;
const int pxlen = net->pxlen;
const struct f_trie_node6 *n = &t->root.v6;
int len = 0;
ip6_addr found = IP6_NONE;
int last = -1;
while (n)
{
/* We are out of path */
if (!ip6_prefix_equal(prefix, n->addr, MIN(pxlen, n->plen)))
goto done;
/* Check accept mask */
for (; len < n->plen; len++)
{
if (len > pxlen)
goto done;
if (ip6_getbit(n->accept, len - 1))
{
/* len is always < 128 due to len < n->plen */
ip6_setbit(&found, len);
last = len;
}
}
/* Special case for max length, there is only one valid local position */
if (len == IP6_MAX_PREFIX_LENGTH)
{
if (n->local & (1u << 1))
last = len;
goto done;
}
/* Check local mask */
for (int pos = 1; pos < (1 << TRIE_STEP); pos = 2 * pos + ip6_getbit(prefix, len), len++)
{
if (len > pxlen)
goto done;
if (n->local & (1u << pos))
{
/* len is always < 128 due to special case above */
ip6_setbit(&found, len);
last = len;
}
}
/* Choose child */
n = n->c[ip6_getbits(prefix, n->plen, TRIE_STEP)];
}
done:
if (last < 0)
return 0;
*dst = NET_ADDR_IP6(ip6_and(prefix, ip6_mkmask(last)), last);
if (found0)
*found0 = found;
return 1;
}
#define SAME_PREFIX(A,B,X,L) ((X) ? ip4_prefix_equal((A)->v4.addr, net4_prefix(B), (L)) : ip6_prefix_equal((A)->v6.addr, net6_prefix(B), (L)))
#define GET_NET_BITS(N,X,A,B) ((X) ? ip4_getbits(net4_prefix(N), (A), (B)) : ip6_getbits(net6_prefix(N), (A), (B)))
/**
* trie_walk_init
* @s: walk state
* @t: trie
* @net: optional subnet for walk
*
* Initialize walk state for subsequent walk through nodes of the trie @t by
* trie_walk_next(). The argument @net allows to restrict walk to given subnet,
* otherwise full walk over all nodes is used. This is done by finding node at
* or below @net and starting position in it.
*/
void
trie_walk_init(struct f_trie_walk_state *s, const struct f_trie *t, const net_addr *net)
{
*s = (struct f_trie_walk_state) {
.ipv4 = t->ipv4,
.accept_length = 0,
.start_pos = 1,
.local_pos = 1,
.stack_pos = 0,
.stack[0] = &t->root
};
if (!net)
return;
/* We want to find node of level at least plen */
int plen = ROUND_DOWN_POW2(net->pxlen, TRIE_STEP);
const struct f_trie_node *n = &t->root;
const int v4 = t->ipv4;
while (n)
{
int nlen = v4 ? n->v4.plen : n->v6.plen;
/* We are out of path */
if (!SAME_PREFIX(n, net, v4, MIN(net->pxlen, nlen)))
break;
/* We found final node */
if (nlen >= plen)
{
if (nlen == plen)
{
/* Find proper local_pos, while accept_length is not used */
int step = net->pxlen - plen;
s->start_pos = s->local_pos = (1u << step) + GET_NET_BITS(net, v4, plen, step);
s->accept_length = plen;
}
else
{
/* Start from pos 1 in local node, but first try accept mask */
s->accept_length = net->pxlen;
}
s->stack[0] = n;
return;
}
/* Choose child */
n = GET_CHILD(n, v4, GET_NET_BITS(net, v4, nlen, TRIE_STEP));
}
s->stack[0] = NULL;
return;
}
#define GET_ACCEPT_BIT(N,X,B) ((X) ? ip4_getbit((N)->v4.accept, (B)) : ip6_getbit((N)->v6.accept, (B)))
#define GET_LOCAL_BIT(N,X,B) (((X) ? (N)->v4.local : (N)->v6.local) & (1u << (B)))
/**
* trie_walk_next
* @s: walk state
* @net: return value
*
* Find the next prefix in the trie walk and return it in the buffer @net.
* Prefixes are walked in the usual lexicographic order and may be restricted
* to a subset of the trie during walk setup by trie_walk_init(). Note that the
* trie walk does not iterate reliably over 'implicit' prefixes defined by &low
* and &high fields in prefix patterns, it is supposed to be used on tries
* constructed from 'explicit' prefixes (&low == &plen == &high in call to
* trie_add_prefix()).
*
* Result: 1 if the next prefix was found, 0 for the end of walk.
*/
int
trie_walk_next(struct f_trie_walk_state *s, net_addr *net)
{
const struct f_trie_node *n = s->stack[s->stack_pos];
int len = s->accept_length;
int pos = s->local_pos;
int v4 = s->ipv4;
/*
* The walk has three basic state variables -- n, len and pos. In each node n,
* we first walk superprefixes (by len in &accept bitmask), and then we walk
* internal positions (by pos in &local bitmask). These positions are:
*
* 1
* 2 3
* 4 5 6 7
* 8 9 A B C D E F
*
* We walk them depth-first, including virtual positions 10-1F that are
* equivalent of position 1 in child nodes 0-F.
*/
if (!n)
{
memset(net, 0, v4 ? sizeof(net_addr_ip4) : sizeof(net_addr_ip6));
return 0;
}
next_node:;
/* Current node prefix length */
int nlen = v4 ? n->v4.plen : n->v6.plen;
/* First, check for accept prefix */
for (; len < nlen; len++)
if (GET_ACCEPT_BIT(n, v4, len - 1))
{
if (v4)
net_fill_ip4(net, ip4_and(n->v4.addr, ip4_mkmask(len)), len);
else
net_fill_ip6(net, ip6_and(n->v6.addr, ip6_mkmask(len)), len);
s->local_pos = pos;
s->accept_length = len + 1;
return 1;
}
next_pos:
/* Bottom of this node */
if (pos >= (1 << TRIE_STEP))
{
const struct f_trie_node *child = GET_CHILD(n, v4, pos - (1 << TRIE_STEP));
int dir = 0;
/* No child node */
if (!child)
{
/* Step up until return from left child (pos is even) */
do
{
/* Step up from start node */
if ((s->stack_pos == 0) && (pos == s->start_pos))
{
s->stack[0] = NULL;
memset(net, 0, v4 ? sizeof(net_addr_ip4) : sizeof(net_addr_ip6));
return 0;
}
/* Top of this node */
if (pos == 1)
{
ASSERT(s->stack_pos);
const struct f_trie_node *old = n;
/* Move to parent node */
s->stack_pos--;
n = s->stack[s->stack_pos];
nlen = v4 ? n->v4.plen : n->v6.plen;
pos = v4 ?
ip4_getbits(old->v4.addr, nlen, TRIE_STEP) :
ip6_getbits(old->v6.addr, nlen, TRIE_STEP);
pos += (1 << TRIE_STEP);
len = nlen;
ASSERT(GET_CHILD(n, v4, pos - (1 << TRIE_STEP)) == old);
}
/* Step up */
dir = pos % 2;
pos = pos / 2;
}
while (dir);
/* Continue with step down to the right child */
pos = 2 * pos + 1;
goto next_pos;
}
/* Move to child node */
pos = 1;
len = nlen + TRIE_STEP;
s->stack_pos++;
n = s->stack[s->stack_pos] = child;
goto next_node;
}
/* Check for local prefix */
if (GET_LOCAL_BIT(n, v4, pos))
{
/* Convert pos to address of local network */
int x = (pos >= 2) + (pos >= 4) + (pos >= 8);
int y = pos & ((1u << x) - 1);
if (v4)
net_fill_ip4(net, !x ? n->v4.addr : ip4_setbits(n->v4.addr, nlen + x - 1, y), nlen + x);
else
net_fill_ip6(net, !x ? n->v6.addr : ip6_setbits(n->v6.addr, nlen + x - 1, y), nlen + x);
s->local_pos = 2 * pos;
s->accept_length = len;
return 1;
}
/* Step down */
pos = 2 * pos;
goto next_pos;
}
static int
trie_node_same4(const struct f_trie_node4 *t1, const struct f_trie_node4 *t2)
{
if ((t1 == NULL) && (t2 == NULL))
return 1;
if ((t1 == NULL) || (t2 == NULL))
return 0;
if ((t1->plen != t2->plen) ||
(! ip4_equal(t1->addr, t2->addr)) ||
(! ip4_equal(t1->accept, t2->accept)))
return 0;
for (uint i = 0; i < (1 << TRIE_STEP); i++)
if (! trie_node_same4(t1->c[i], t2->c[i]))
return 0;
return 1;
}
static int
trie_node_same6(const struct f_trie_node6 *t1, const struct f_trie_node6 *t2)
{
if ((t1 == NULL) && (t2 == NULL))
return 1;
if ((t1 == NULL) || (t2 == NULL))
return 0;
if ((t1->plen != t2->plen) ||
(! ip6_equal(t1->addr, t2->addr)) ||
(! ip6_equal(t1->accept, t2->accept)))
return 0;
for (uint i = 0; i < (1 << TRIE_STEP); i++)
if (! trie_node_same6(t1->c[i], t2->c[i]))
return 0;
return 1;
}
/**
* trie_same
* @t1: first trie to be compared
* @t2: second one
*
* Compares two tries and returns 1 if they are same
*/
int
trie_same(const struct f_trie *t1, const struct f_trie *t2)
{
if ((t1->zero != t2->zero) || (t1->ipv4 != t2->ipv4))
return 0;
if (t1->ipv4)
return trie_node_same4(&t1->root.v4, &t2->root.v4);
else
return trie_node_same6(&t1->root.v6, &t2->root.v6);
}
static const u8 log2[16] = {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3};
static void
trie_node_format(const struct f_trie_node *n, buffer *buf, int v4)
{
if (n == NULL)
return;
if (v4)
{
if (ip4_nonzero(n->v4.accept))
buffer_print(buf, "%I4/%d{%I4}, ", n->v4.addr, n->v4.plen, n->v4.accept);
}
else
{
if (ip6_nonzero(n->v6.accept))
buffer_print(buf, "%I6/%d{%I6}, ", n->v6.addr, n->v6.plen, n->v6.accept);
}
int nlen = v4 ? n->v4.plen : n->v6.plen;
uint local = v4 ? n->v4.local : n->v6.local;
for (int i = (nlen ? 0 : 1); i < TRIE_STEP; i++)
if (GET_ACCEPT_BIT(n, v4, nlen + i - 1))
local &= ~trie_level_mask(1, i);
for (int pos = 2; local && (pos < (1 << TRIE_STEP)); pos++)
if (local & (1u << pos))
{
int lvl = log2[pos];
int plen = nlen + lvl;
int i;
for (i = 0; lvl + i < TRIE_STEP; i++)
{
uint lmask = trie_level_mask(pos, i);
if ((local & lmask) != lmask)
break;
local &= ~lmask;
}
uint addr_bits = pos & ((1u << lvl) - 1);
uint accept_bits = (1u << i) - 1;
int h = plen + i - 1;
if (v4)
{
ip4_addr addr = ip4_setbits(n->v4.addr, plen - 1, addr_bits);
ip4_addr mask = ip4_setbits(IP4_NONE, h - 1, accept_bits);
buffer_print(buf, "%I4/%d{%I4}, ", addr, plen, mask);
}
else
{
ip6_addr addr = ip6_setbits(n->v6.addr, plen - 1, addr_bits);
ip6_addr mask = ip6_setbits(IP6_NONE, h - 1, accept_bits);
buffer_print(buf, "%I6/%d{%I6}, ", addr, plen, mask);
}
}
for (int i = 0; i < (1 << TRIE_STEP); i++)
trie_node_format(GET_CHILD(n, v4, i), buf, v4);
}
/**
* trie_format
* @t: trie to be formatted
* @buf: destination buffer
*
* Prints the trie to the supplied buffer.
*/
void
trie_format(const struct f_trie *t, buffer *buf)
{
buffer_puts(buf, "[");
if (t->zero)
buffer_print(buf, "%I/%d, ", t->ipv4 ? IPA_NONE4 : IPA_NONE6, 0);
trie_node_format(&t->root, buf, t->ipv4);
if (buf->pos == buf->end)
return;
/* Undo last separator */
if (buf->pos[-1] != '[')
buf->pos -= 2;
buffer_puts(buf, "]");
}
bird2-2.17.5/filter/trie_test.c 0000664 0000000 0000000 00000051613 15211753245 0016256 0 ustar 00root root 0000000 0000000 /*
* Filters: Utility Functions Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "test/bt-utils.h"
#include "filter/filter.h"
#include "filter/data.h"
#include "conf/conf.h"
#define TESTS_NUM 10
#define PREFIXES_NUM 32
#define PREFIX_TESTS_NUM 10000
#define PREFIX_BENCH_NUM 100000000
#define TRIE_BUFFER_SIZE 1024
#define TEST_BUFFER_SIZE (1024*1024)
#define BIG_BUFFER_SIZE 10000
/* Wrapping structure for storing f_prefixes structures in list */
struct f_prefix_node {
node n;
struct f_prefix prefix;
};
static inline uint
get_exp_random(void)
{
uint r, n = 0;
for (r = bt_random(); r & 1; r = r >> 1)
n++;
return n;
}
static int
compare_prefixes(const void *a, const void *b)
{
return net_compare(&((const struct f_prefix *) a)->net,
&((const struct f_prefix *) b)->net);
}
static inline int
matching_ip4_nets(const net_addr_ip4 *a, const net_addr_ip4 *b)
{
ip4_addr cmask = ip4_mkmask(MIN(a->pxlen, b->pxlen));
return ip4_compare(ip4_and(a->prefix, cmask), ip4_and(b->prefix, cmask)) == 0;
}
static inline int
matching_ip6_nets(const net_addr_ip6 *a, const net_addr_ip6 *b)
{
ip6_addr cmask = ip6_mkmask(MIN(a->pxlen, b->pxlen));
return ip6_compare(ip6_and(a->prefix, cmask), ip6_and(b->prefix, cmask)) == 0;
}
static inline int
matching_nets(const net_addr *a, const net_addr *b)
{
if (a->type != b->type)
return 0;
return (a->type == NET_IP4) ?
matching_ip4_nets((const net_addr_ip4 *) a, (const net_addr_ip4 *) b) :
matching_ip6_nets((const net_addr_ip6 *) a, (const net_addr_ip6 *) b);
}
static int
is_prefix_included(list *prefixes, const net_addr *needle)
{
struct f_prefix_node *n;
WALK_LIST(n, *prefixes)
if (matching_nets(&n->prefix.net, needle) &&
(n->prefix.lo <= needle->pxlen) && (needle->pxlen <= n->prefix.hi))
{
char buf[64];
bt_format_net(buf, 64, &n->prefix.net);
bt_debug("FOUND %s %d-%d\n", buf, n->prefix.lo, n->prefix.hi);
return 1; /* OK */
}
return 0; /* FAIL */
}
static void
get_random_prefix(struct f_prefix *px, int v6, int tight)
{
bt_random_net(&px->net, !v6 ? NET_IP4 : NET_IP6);
if (tight)
{
px->lo = px->hi = px->net.pxlen;
}
else if (bt_random() % 2)
{
px->lo = 0;
px->hi = px->net.pxlen;
}
else
{
px->lo = px->net.pxlen;
px->hi = net_max_prefix_length[px->net.type];
}
}
static void
get_random_ip4_subnet(net_addr_ip4 *net, const net_addr_ip4 *src, int pxlen)
{
*net = NET_ADDR_IP4(ip4_and(src->prefix, ip4_mkmask(pxlen)), pxlen);
if (pxlen > src->pxlen)
{
ip4_addr rnd = ip4_from_u32((u32) bt_random());
ip4_addr mask = ip4_xor(ip4_mkmask(src->pxlen), ip4_mkmask(pxlen));
net->prefix = ip4_or(net->prefix, ip4_and(rnd, mask));
}
}
static void
get_random_ip6_subnet(net_addr_ip6 *net, const net_addr_ip6 *src, int pxlen)
{
*net = NET_ADDR_IP6(ip6_and(src->prefix, ip6_mkmask(pxlen)), pxlen);
if (pxlen > src->pxlen)
{
ip6_addr rnd = ip6_build(bt_random(), bt_random(), bt_random(), bt_random());
ip6_addr mask = ip6_xor(ip6_mkmask(src->pxlen), ip6_mkmask(pxlen));
net->prefix = ip6_or(net->prefix, ip6_and(rnd, mask));
}
}
static void
get_random_subnet(net_addr *net, const net_addr *src, int pxlen)
{
if (src->type == NET_IP4)
get_random_ip4_subnet((net_addr_ip4 *) net, (const net_addr_ip4 *) src, pxlen);
else
get_random_ip6_subnet((net_addr_ip6 *) net, (const net_addr_ip6 *) src, pxlen);
}
static void
get_inner_net(net_addr *net, const struct f_prefix *src)
{
int pxlen, step;
if (bt_random() % 2)
{
step = get_exp_random();
step = MIN(step, src->hi - src->lo);
pxlen = (bt_random() % 2) ? (src->lo + step) : (src->hi - step);
}
else
pxlen = src->lo + bt_random() % (src->hi - src->lo + 1);
get_random_subnet(net, &src->net, pxlen);
}
static void
swap_random_bits_ip4(net_addr_ip4 *net, int num)
{
for (int i = 0; i < num; i++)
{
ip4_addr swap = IP4_NONE;
ip4_setbit(&swap, bt_random() % net->pxlen);
net->prefix = ip4_xor(net->prefix, swap);
}
}
static void
swap_random_bits_ip6(net_addr_ip6 *net, int num)
{
for (int i = 0; i < num; i++)
{
ip6_addr swap = IP6_NONE;
ip6_setbit(&swap, bt_random() % net->pxlen);
net->prefix = ip6_xor(net->prefix, swap);
}
}
static void
swap_random_bits(net_addr *net, int num)
{
if (net->type == NET_IP4)
swap_random_bits_ip4((net_addr_ip4 *) net, num);
else
swap_random_bits_ip6((net_addr_ip6 *) net, num);
}
static void
get_outer_net(net_addr *net, const struct f_prefix *src)
{
int pxlen, step;
int inside = 0;
int max = net_max_prefix_length[src->net.type];
if ((src->lo > 0) && (bt_random() % 3))
{
step = 1 + get_exp_random();
step = MIN(step, src->lo);
pxlen = src->lo - step;
}
else if ((src->hi < max) && (bt_random() % 2))
{
step = 1 + get_exp_random();
step = MIN(step, max - src->hi);
pxlen = src->hi + step;
}
else
{
pxlen = src->lo + bt_random() % (src->hi - src->lo + 1);
inside = 1;
}
get_random_subnet(net, &src->net, pxlen);
/* Perhaps swap some bits in prefix */
if ((net->pxlen > 0) && (inside || (bt_random() % 4)))
swap_random_bits(net, 1 + get_exp_random());
}
static list *
make_random_prefix_list(int num, int v6, int tight)
{
list *prefixes = lp_allocz(tmp_linpool, sizeof(struct f_prefix_node));
init_list(prefixes);
for (int i = 0; i < num; i++)
{
struct f_prefix_node *px = lp_allocz(tmp_linpool, sizeof(struct f_prefix_node));
get_random_prefix(&px->prefix, v6, tight);
add_tail(prefixes, &px->n);
char buf[64];
bt_format_net(buf, 64, &px->prefix.net);
bt_debug("ADD %s{%d,%d}\n", buf, px->prefix.lo, px->prefix.hi);
}
return prefixes;
}
static struct f_trie *
make_trie_from_prefix_list(list *prefixes)
{
struct f_trie *trie = f_new_trie(tmp_linpool, 0);
struct f_prefix_node *n;
WALK_LIST(n, *prefixes)
trie_add_prefix(trie, &n->prefix.net, n->prefix.lo, n->prefix.hi);
return trie;
}
/*
* Read sequence of prefixes from file handle and return prefix list.
* Each prefix is on one line, sequence terminated by empty line or eof.
* Arg @plus means prefix should include all longer ones.
*/
static list *
read_prefix_list(FILE *f, int v6, int plus)
{
ASSERT(!v6);
uint a0, a1, a2, a3, pl;
char s[32];
int n;
list *pxlist = lp_allocz(tmp_linpool, sizeof(struct f_prefix_node));
init_list(pxlist);
errno = 0;
while (fgets(s, 32, f))
{
if (s[0] == '\n')
return pxlist;
n = sscanf(s, "%u.%u.%u.%u/%u", &a0, &a1, &a2, &a3, &pl);
if (n != 5)
bt_abort_msg("Invalid content of trie_data");
struct f_prefix_node *px = lp_allocz(tmp_linpool, sizeof(struct f_prefix_node));
net_fill_ip4(&px->prefix.net, ip4_build(a0, a1, a2, a3), pl);
px->prefix.lo = pl;
px->prefix.hi = plus ? IP4_MAX_PREFIX_LENGTH : pl;
add_tail(pxlist, &px->n);
char buf[64];
bt_format_net(buf, 64, &px->prefix.net);
bt_debug("ADD %s{%d,%d}\n", buf, px->prefix.lo, px->prefix.hi);
}
bt_syscall(errno, "fgets()");
return EMPTY_LIST(*pxlist) ? NULL : pxlist;
}
/*
* Open file, read multiple sequences of prefixes from it. Fill @data with
* prefix lists and @trie with generated tries. Return number of sequences /
* tries. Use separate linpool @lp0 for prefix lists and @lp1 for tries.
* Arg @plus means prefix should include all longer ones.
*/
static int
read_prefix_file(const char *filename, int plus,
list *data[], struct f_trie *trie[])
{
FILE *f = fopen(filename, "r");
bt_syscall(!f, "fopen(%s)", filename);
int n = 0;
list *pxlist;
while (pxlist = read_prefix_list(f, 0, plus))
{
data[n] = pxlist;
trie[n] = make_trie_from_prefix_list(pxlist);
bt_debug("NEXT\n");
n++;
}
fclose(f);
bt_debug("DONE reading %d tries\n", n);
return n;
}
/*
* Select random subset of @dn prefixes from prefix list @src of length @sn,
* and store them to buffer @dst (of size @dn). Prefixes may be chosen multiple
* times. Randomize order of prefixes in @dst buffer.
*/
static void
select_random_prefix_subset(list *src[], net_addr dst[], int sn, int dn)
{
int pn = 0;
if (!dn)
return;
/* Compute total prefix number */
for (int i = 0; i < sn; i++)
pn += list_length(src[i]);
/* Change of selecting a prefix */
int rnd = (pn / dn) + 10;
int n = 0;
/* Iterate indefinitely over src array */
for (int i = 0; 1; i++, i = (i < sn) ? i : 0)
{
struct f_prefix_node *px;
WALK_LIST(px, *src[i])
{
if (bt_random_n(rnd) != 0)
continue;
net_copy(&dst[n], &px->prefix.net);
n++;
/* We have enough */
if (n == dn)
goto done;
}
}
done:
/* Shuffle networks */
for (int i = 0; i < dn; i++)
{
int j = bt_random_n(dn);
if (i == j)
continue;
net_addr tmp;
net_copy(&tmp, &dst[i]);
net_copy(&dst[i], &dst[j]);
net_copy(&dst[j], &tmp);
}
}
/* Fill @dst buffer with @dn randomly generated /32 prefixes */
static void
make_random_addresses(net_addr dst[], int dn)
{
for (int i = 0; i < dn; i++)
net_fill_ip4(&dst[i], ip4_from_u32((u32) bt_random()), IP4_MAX_PREFIX_LENGTH);
}
static void
test_match_net(list *prefixes, struct f_trie *trie, const net_addr *net)
{
char buf[64];
bt_format_net(buf, 64, net);
bt_debug("TEST %s\n", buf);
int should_be = is_prefix_included(prefixes, net);
int is_there = trie_match_net(trie, net);
bt_assert_msg(should_be == is_there, "Prefix %s %s match", buf,
(should_be ? "should" : "should not"));
}
static int
t_match_random_net(void)
{
bt_bird_init();
bt_config_parse(BT_CONFIG_SIMPLE);
int v6 = 0;
for (int round = 0; round < TESTS_NUM; round++)
{
list *prefixes = make_random_prefix_list(PREFIXES_NUM, v6, 0);
struct f_trie *trie = make_trie_from_prefix_list(prefixes);
for (int i = 0; i < PREFIX_TESTS_NUM; i++)
{
net_addr net;
bt_random_net(&net, !v6 ? NET_IP4 : NET_IP6);
test_match_net(prefixes, trie, &net);
}
v6 = !v6;
tmp_flush();
}
bt_bird_cleanup();
return 1;
}
static int
t_match_inner_net(void)
{
bt_bird_init();
bt_config_parse(BT_CONFIG_SIMPLE);
int v6 = 0;
for (int round = 0; round < TESTS_NUM; round++)
{
list *prefixes = make_random_prefix_list(PREFIXES_NUM, v6, 0);
struct f_trie *trie = make_trie_from_prefix_list(prefixes);
struct f_prefix_node *n = HEAD(*prefixes);
for (int i = 0; i < PREFIX_TESTS_NUM; i++)
{
net_addr net;
get_inner_net(&net, &n->prefix);
test_match_net(prefixes, trie, &net);
n = NODE_VALID(NODE_NEXT(n)) ? NODE_NEXT(n) : HEAD(*prefixes);
}
v6 = !v6;
tmp_flush();
}
bt_bird_cleanup();
return 1;
}
static int
t_match_outer_net(void)
{
bt_bird_init();
bt_config_parse(BT_CONFIG_SIMPLE);
int v6 = 0;
for (int round = 0; round < TESTS_NUM; round++)
{
list *prefixes = make_random_prefix_list(PREFIXES_NUM, v6, 0);
struct f_trie *trie = make_trie_from_prefix_list(prefixes);
struct f_prefix_node *n = HEAD(*prefixes);
for (int i = 0; i < PREFIX_TESTS_NUM; i++)
{
net_addr net;
get_outer_net(&net, &n->prefix);
test_match_net(prefixes, trie, &net);
n = NODE_VALID(NODE_NEXT(n)) ? NODE_NEXT(n) : HEAD(*prefixes);
}
v6 = !v6;
tmp_flush();
}
v6 = !v6;
bt_bird_cleanup();
return 1;
}
/*
* Read prefixes from @filename, build set of tries, prepare test data and do
* PREFIX_BENCH_NUM trie lookups. With @plus = 0, use random subset of known
* prefixes as test data, with @plus = 1, use randomly generated /32 prefixes
* as test data.
*/
static int
benchmark_trie_dataset(const char *filename, int plus)
{
int n = 0;
list *data[TRIE_BUFFER_SIZE];
struct f_trie *trie[TRIE_BUFFER_SIZE];
net_addr *nets;
bt_reset_suite_case_timer();
bt_log_suite_case_result(1, "Reading %s", filename, n);
n = read_prefix_file(filename, plus, data, trie);
bt_log_suite_case_result(1, "Read prefix data, %d lists, ", n);
size_t trie_size = rmemsize(tmp_linpool).effective * 1000 / (1024*1024);
bt_log_suite_case_result(1, "Trie size %u.%03u MB",
(uint) (trie_size / 1000), (uint) (trie_size % 1000));
int t = PREFIX_BENCH_NUM / n;
int tb = MIN(t, TEST_BUFFER_SIZE);
nets = tmp_alloc(tb * sizeof(net_addr));
if (!plus)
select_random_prefix_subset(data, nets, n, tb);
else
make_random_addresses(nets, tb);
bt_log_suite_case_result(1, "Make test data, %d (%d) tests", t, tb);
bt_reset_suite_case_timer();
/*
int match = 0;
for (int i = 0; i < t; i++)
for (int j = 0; j < n; j++)
test_match_net(data[j], trie[j], &nets[i]);
*/
int match = 0;
for (int i = 0; i < t; i++)
for (int j = 0; j < n; j++)
if (trie_match_net(trie[j], &nets[i % TEST_BUFFER_SIZE]))
match++;
bt_log_suite_case_result(1, "Matching done, %d / %d matches", match, t * n);
tmp_flush();
return 1;
}
static int UNUSED
t_bench_trie_datasets_subset(void)
{
bt_bird_init();
bt_config_parse(BT_CONFIG_SIMPLE);
/* Specific datasets, not included */
benchmark_trie_dataset("trie-data-bgp-1", 0);
benchmark_trie_dataset("trie-data-bgp-10", 0);
benchmark_trie_dataset("trie-data-bgp-100", 0);
benchmark_trie_dataset("trie-data-bgp-1000", 0);
bt_bird_cleanup();
return 1;
}
static int UNUSED
t_bench_trie_datasets_random(void)
{
bt_bird_init();
bt_config_parse(BT_CONFIG_SIMPLE);
/* Specific datasets, not included */
benchmark_trie_dataset("trie-data-bgp-1", 1);
benchmark_trie_dataset("trie-data-bgp-10", 1);
benchmark_trie_dataset("trie-data-bgp-100", 1);
benchmark_trie_dataset("trie-data-bgp-1000", 1);
bt_bird_cleanup();
return 1;
}
static int
t_trie_same(void)
{
bt_bird_init();
bt_config_parse(BT_CONFIG_SIMPLE);
int v6 = 0;
for (int round = 0; round < TESTS_NUM*4; round++)
{
list *prefixes = make_random_prefix_list(100 * PREFIXES_NUM, v6, 0);
struct f_trie *trie1 = f_new_trie(tmp_linpool, 0);
struct f_trie *trie2 = f_new_trie(tmp_linpool, 0);
struct f_prefix_node *n;
WALK_LIST(n, *prefixes)
trie_add_prefix(trie1, &n->prefix.net, n->prefix.lo, n->prefix.hi);
WALK_LIST_BACKWARDS(n, *prefixes)
trie_add_prefix(trie2, &n->prefix.net, n->prefix.lo, n->prefix.hi);
bt_assert(trie_same(trie1, trie2));
v6 = !v6;
tmp_flush();
}
bt_bird_cleanup();
return 1;
}
static inline void
log_networks(const net_addr *a, const net_addr *b)
{
if (bt_verbose >= BT_VERBOSE_ABSOLUTELY_ALL)
{
char buf0[64];
char buf1[64];
bt_format_net(buf0, 64, a);
bt_format_net(buf1, 64, b);
bt_debug("Found %s expected %s\n", buf0, buf1);
}
}
static int
t_trie_walk(void)
{
bt_bird_init();
bt_config_parse(BT_CONFIG_SIMPLE);
for (int round = 0; round < TESTS_NUM*8; round++)
{
int level = round / TESTS_NUM;
int v6 = level % 2;
int num = PREFIXES_NUM * (int[]){1, 10, 100, 1000}[level / 2];
int pos = 0, end = 0;
list *prefixes = make_random_prefix_list(num, v6, 1);
struct f_trie *trie = make_trie_from_prefix_list(prefixes);
struct f_prefix *pxset = malloc((num + 1) * sizeof(struct f_prefix));
struct f_prefix_node *n;
WALK_LIST(n, *prefixes)
pxset[pos++] = n->prefix;
memset(&pxset[pos], 0, sizeof (struct f_prefix));
qsort(pxset, num, sizeof(struct f_prefix), compare_prefixes);
/* Full walk */
bt_debug("Full walk (round %d, %d nets)\n", round, num);
pos = 0;
uint pxc = 0;
TRIE_WALK(trie, net, NULL)
{
log_networks(&net, &pxset[pos].net);
bt_assert(net_equal(&net, &pxset[pos].net));
/* Skip possible duplicates */
while (net_equal(&pxset[pos].net, &pxset[pos + 1].net))
pos++;
pos++;
pxc++;
}
TRIE_WALK_END;
bt_assert(pos == num);
bt_assert(pxc == trie->prefix_count);
bt_debug("Full walk done\n");
/* Prepare net for subnet walk - start with random prefix */
pos = bt_random() % num;
end = pos + (int[]){2, 2, 3, 4}[level / 2];
end = MIN(end, num);
struct f_prefix from = pxset[pos];
/* Find a common superprefix to several subsequent prefixes */
for (; pos < end; pos++)
{
if (net_equal(&from.net, &pxset[pos].net))
continue;
int common = !v6 ?
ip4_pxlen(net4_prefix(&from.net), net4_prefix(&pxset[pos].net)) :
ip6_pxlen(net6_prefix(&from.net), net6_prefix(&pxset[pos].net));
from.net.pxlen = MIN(from.net.pxlen, common);
if (!v6)
((net_addr_ip4 *) &from.net)->prefix =
ip4_and(net4_prefix(&from.net), net4_prefix(&pxset[pos].net));
else
((net_addr_ip6 *) &from.net)->prefix =
ip6_and(net6_prefix(&from.net), net6_prefix(&pxset[pos].net));
}
/* Fix irrelevant bits */
if (!v6)
((net_addr_ip4 *) &from.net)->prefix =
ip4_and(net4_prefix(&from.net), ip4_mkmask(net4_pxlen(&from.net)));
else
((net_addr_ip6 *) &from.net)->prefix =
ip6_and(net6_prefix(&from.net), ip6_mkmask(net6_pxlen(&from.net)));
/* Find initial position for final prefix */
for (pos = 0; pos < num; pos++)
if (compare_prefixes(&pxset[pos], &from) >= 0)
break;
int p0 = pos;
char buf0[64];
bt_format_net(buf0, 64, &from.net);
bt_debug("Subnet walk for %s (round %d, %d nets)\n", buf0, round, num);
/* Subnet walk */
TRIE_WALK(trie, net, &from.net)
{
log_networks(&net, &pxset[pos].net);
bt_assert(net_equal(&net, &pxset[pos].net));
bt_assert(net_in_netX(&net, &from.net));
/* Skip possible duplicates */
while (net_equal(&pxset[pos].net, &pxset[pos + 1].net))
pos++;
pos++;
}
TRIE_WALK_END;
bt_assert((pos == num) || !net_in_netX(&pxset[pos].net, &from.net));
bt_debug("Subnet walk done for %s (found %d nets)\n", buf0, pos - p0);
tmp_flush();
}
bt_bird_cleanup();
return 1;
}
static int
find_covering_nets(struct f_prefix *prefixes, int num, const net_addr *net, net_addr *found)
{
struct f_prefix key;
net_addr *n = &key.net;
int found_num = 0;
net_copy(n, net);
while (1)
{
struct f_prefix *px =
bsearch(&key, prefixes, num, sizeof(struct f_prefix), compare_prefixes);
if (px)
{
net_copy(&found[found_num], n);
found_num++;
}
if (n->pxlen == 0)
return found_num;
n->pxlen--;
if (n->type == NET_IP4)
ip4_clrbit(&((net_addr_ip4 *) n)->prefix, n->pxlen);
else
ip6_clrbit(&((net_addr_ip6 *) n)->prefix, n->pxlen);
}
}
static int
t_trie_walk_to_root(void)
{
bt_bird_init();
bt_config_parse(BT_CONFIG_SIMPLE);
for (int round = 0; round < TESTS_NUM * 4; round++)
{
int level = round / TESTS_NUM;
int v6 = level % 2;
int num = PREFIXES_NUM * (int[]){32, 512}[level / 2];
int pos = 0;
int st = 0, sn = 0, sm = 0;
list *prefixes = make_random_prefix_list(num, v6, 1);
struct f_trie *trie = make_trie_from_prefix_list(prefixes);
struct f_prefix *pxset = malloc((num + 1) * sizeof(struct f_prefix));
struct f_prefix_node *pxn;
WALK_LIST(pxn, *prefixes)
pxset[pos++] = pxn->prefix;
memset(&pxset[pos], 0, sizeof (struct f_prefix));
qsort(pxset, num, sizeof(struct f_prefix), compare_prefixes);
int i;
for (i = 0; i < (PREFIX_TESTS_NUM / 10); i++)
{
net_addr from;
bt_random_net(&from, !v6 ? NET_IP4 : NET_IP6);
net_addr found[129];
int found_num = find_covering_nets(pxset, num, &from, found);
int n = 0;
if (bt_verbose >= BT_VERBOSE_ABSOLUTELY_ALL)
{
char buf[64];
bt_format_net(buf, 64, &from);
bt_debug("Lookup for %s (expect %d)\n", buf, found_num);
}
/* Walk to root, separate for IPv4 and IPv6 */
if (!v6)
{
TRIE_WALK_TO_ROOT_IP4(trie, (net_addr_ip4 *) &from, net)
{
log_networks((net_addr *) &net, &found[n]);
bt_assert((n < found_num) && net_equal((net_addr *) &net, &found[n]));
n++;
}
TRIE_WALK_TO_ROOT_END;
}
else
{
TRIE_WALK_TO_ROOT_IP6(trie, (net_addr_ip6 *) &from, net)
{
log_networks((net_addr *) &net, &found[n]);
bt_assert((n < found_num) && net_equal((net_addr *) &net, &found[n]));
n++;
}
TRIE_WALK_TO_ROOT_END;
}
bt_assert(n == found_num);
/* Stats */
st += n;
sn += !!n;
sm = MAX(sm, n);
}
bt_debug("Success in %d / %d, sum %d, max %d\n", sn, i, st, sm);
tmp_flush();
}
bt_bird_cleanup();
return 1;
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_match_random_net, "Testing random prefix matching");
bt_test_suite(t_match_inner_net, "Testing random inner prefix matching");
bt_test_suite(t_match_outer_net, "Testing random outer prefix matching");
bt_test_suite(t_trie_same, "A trie filled forward should be same with a trie filled backward.");
bt_test_suite(t_trie_walk, "Testing TRIE_WALK() on random tries");
bt_test_suite(t_trie_walk_to_root, "Testing TRIE_WALK_TO_ROOT() on random tries");
// bt_test_suite(t_bench_trie_datasets_subset, "Benchmark tries from datasets by random subset of nets");
// bt_test_suite(t_bench_trie_datasets_random, "Benchmark tries from datasets by generated addresses");
return bt_exit_value();
}
bird2-2.17.5/gitlab/ 0000775 0000000 0000000 00000000000 15211753245 0014057 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/Dockerfile.j2 0000664 0000000 0000000 00000006070 15211753245 0016366 0 ustar 00root root 0000000 0000000 {% for distro in distros %}{% if distro.name == target -%}
{% set d = distro.docker -%}
{% if d == "static" %}{{ fail("Docker for " ~ target ~ " is static, edit that file directly and don't forget to commit the changes into Git.") }}{% endif -%}
# Autogenerated Dockerfile for {{ target }}.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM {{ d.parent }}
{%- if distro.type == "deb" %}
ENV DEBIAN_FRONTEND=noninteractive
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
{%- for ca in distro.crossarch %}
RUN dpkg --add-architecture {{ ca }}
{%- endfor %}
{%- if distro.name == "ubuntu-22.04-amd64" %}
RUN find /etc/apt/sourc* -type f -exec sed -i 's/^deb /deb [arch=amd64] /' '{}' +
RUN find /etc/apt/sourc* -type f -exec sed -r '/^deb /{s#arch=amd64#arch={{ distro.crossarch | join(",") }}#;s#https?://[^ ]+#http://ports.ubuntu.com/ubuntu-ports/#}' '{}' + > /etc/apt/sources.list.d/crossbuild.list
{%- elif distro.shortname == "ubuntu" and distro.crossarch %}
RUN find /etc/apt/sourc* -type f -exec sed -i '/Components: /a\
Architectures: amd64' '{}' +
RUN find /etc/apt/sourc* -type f -exec sed 's#URIs: .*#URIs: http://ports.ubuntu.com/ubuntu-ports/#;s#Architectures: amd64#Architectures: {{ distro.crossarch | join(",") }}#' '{}' + > /etc/apt/sources.list.d/crossbuild.sources
{%- endif %}
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
{%- if distro.shortname == "ubuntu" %}
tzdata \
{%- endif %}
build-essential \
flex \
bison \
autoconf \
ncurses-dev \
libreadline-dev \
{{ d.libssh_kind }}-dev \
{%- for ca in distro.crossarch %}
crossbuild-essential-{{ ca }} \
libreadline-dev:{{ ca }} \
ncurses-dev:{{ ca }} \
{%- endfor %}
{%- if distro.crossarch %}
qemu-user \
qemu-user-binfmt \
binfmt-support \
{%- endif %}
linuxdoc-tools-latex \
texlive-latex-extra \
opensp \
docbook-xsl \
xsltproc{% if d.needs_adduser %} \
adduser{% endif %}
RUN apt-get -y --no-install-recommends install \
git \
dpkg-dev \
debhelper \
lsb-release \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
RUN apt-get -y clean
{%- elif distro.type == "rpm" %}
{%- if d.preinstall %}
{{ d.preinstall }}
{%- endif %}
RUN {{ d.installer }} up{% if d.installer[:6] != "zypper" %}grade{% endif %}
RUN {{ d.installer }} install \
gcc \
make \
flex \
bison \
autoconf \
{%- if d.pkgconfig %}
pkgconfig \
{%- endif %}
libssh-devel \
ncurses-devel \
readline-devel
RUN {{ d.installer }} install \
git \
{%- if d.alternative_lsb %}
{{ d.alternative_lsb }} \
{%- else %}
lsb-release \
{%- endif %}
rpm-build \
{%- if d.faketime == "lib" %}
libfaketime \
{%- elif d.faketime %}
faketime \
{%- endif %}
{%- if d.systemd %}
systemd \
{%- endif %}
systemd-rpm-macros \
{%- if d.sysuser %}
sysuser-tools \
{%- endif %}
python3 \
python3-pip \
python3-setuptools
{%- endif %}
{%- endif %}{% endfor %}
bird2-2.17.5/gitlab/Makefile 0000664 0000000 0000000 00000002570 15211753245 0015523 0 ustar 00root root 0000000 0000000 # Gitlab CI tests
#GITLAB_SECTIONS := template
#$(s)%.yml: $(s)pipeline.py $(s)%.yml.j2 $(s)data.yml.j2
.gitlab-ci.yml: $(s)pipeline.py $(s)template.yml.j2 $(s)data.yml.j2
python3 $^ > $@
@if grep -n ' ' $@; then echo "Found a tab in yaml output!"; false; fi
#gitlab-local: $(patsubst %,$(s)%.yml,$(GITLAB_SECTIONS))
gitlab-local: .gitlab-ci.yml
# Conditionally include Dockerfile build but only if required
ifneq ($(filter gitlab-docker $(s)docker,$(MAKECMDGOALS)),)
$(s)docker/%/Dockerfile: $(s)pipeline.py $(s)Dockerfile.j2 $(s)data.yml.j2
$(if $(VENV),$(MAKE) $(GITLAB_VENV))
mkdir -p $(dir $@)
$(if $(VENV),$(call VPYTHON,$(GITLAB_VENV)),python3) $^ target=$* > $@
$(s)docker.mk: $(s)pipeline.py $(s)docker.mk.j2 $(s)data.yml.j2
$(if $(VENV),$(MAKE) $(GITLAB_VENV))
$(if $(VENV),$(call VPYTHON,$(GITLAB_VENV)),python3) $^ > $@
include $(s)docker.mk
endif
VPYTHON = VIRTUAL_ENV=$(1) PATH="$(1)/bin:$$PATH" $(1)/bin/python3
VPIP = VIRTUAL_ENV=$(1) PATH="$(1)/bin:$$PATH" $(1)/bin/pip3
VRUN = VIRTUAL_ENV=$(1) PATH="$(1)/bin:$$PATH" $(2)
GITLAB_VENV := $(o)venv
$(GITLAB_VENV): INSTALL_PACKAGES := jinja2 pyaml
%/venv:
python3 -m venv $@
$(call VPIP,$@) install $(INSTALL_PACKAGES)
gitlab-venv: $(GITLAB_VENV)
$(call VRUN,$<,$(MAKE)) gitlab-local
gitlab-clean: s := $(s)
gitlab-clean:
rm $(s)*.yml
clean::
rm -rf $(GITLAB_VENV)
.PHONY: gitlab-local gitlab-venv gitlab-clean
bird2-2.17.5/gitlab/README.md 0000664 0000000 0000000 00000013261 15211753245 0015341 0 ustar 00root root 0000000 0000000 # BIRD CI Pipelines
There is quite a lot to do during our CI to ensure that BIRD stays stable and
no regression is introduced by regular development. We do as much as possible
in an automated way so that routine tasks aren't botched by somebody missing
a step.
## Pipeline structure
The main [main `.gitlab-ci.yml` file](../../.gitlab-ci.yml) is double-templated.
Primary data is in [data.yml.j2](data.yml.j2) which is itself processed by
Jinja to expand various data structures. The expanded data is then passed to
the templater, converting [template.yml.j2](template.yml.j2) to the final
target file.
The main file is committed into the repository, and therefore every change to
the source files must be accompanied with `make gitlab-local` (if you have
`jinja2` and `pyaml` installed locally) or `make gitlab-venv` which creates a
venv for that job on the fly. If that file was generated on the fly, it would
add some unnecessary half a minute to the CI run time, and make the CI output
more confusing.
We would love to split the main CI file to some nice smaller parts but it would
probably impose quite a lot of repetitive work because of Gitlab. At least
we can document these parts as separate chapters.
## Consistency
Release-worthy commits are put into specific branches. These are:
- `master` for BIRD 2
- `thread-next` for BIRD 3
- `stable-v*` for patch release branches
These branches require some commit hygiene, which is checked by the script
in `tools/git-check-commits`, and if anybody pushes a commit which fails the
consistency check, they should immediately force-push a fixed history.
Notably, this check requires all the commits to not be marked as `fixup!` or
as `WIP`, which both marks unfinished work.
TODO:
- add also check that the gitlab CI file is up-to-date with the sources
## Build tests
We have been historically hit by multiple integration problems arising from
distributions either keeping old tooling versions (e.g. old compilers),
breaking things by updates, or simply using different libraries and tools
than the core team which runs mostly Debian, Ubuntu and Fedora (as of 2026).
Therefore, we check builds for multiple distribution versions from last about
5-10 years, depending on customer requirements and actual possibility to get a
docker image for that distro.
We also run build tests for FreeBSD, OpenBSD and NetBSD inside QEMU. The images
are half-defined inside our
[temporary virtualization platform](https://gitlab.nic.cz/labs/bird-tools/-/tree/master/birdlab-tmp)
but please note that there are quite some updates local to the deployment, which
have not been applied back to that repository.
Last but not least, we check partial builds where some of the protocols are switched off.
TODO:
- commit changes for the virtualization platform and test deployment from scratch
- add partial builds checking other `configure` checks, e.g. presence of `libssh`
- add cross platform builds at least nightly
## Runtime tests
These tests use the [Netlab infrastructure](https://gitlab.nic.cz/labs/bird-tools/-/tree/master/netlab) (yes, another Netlab), and we gradually add more tests covering more
BIRD functionality. There are also regression tests included.
## Packaging and install tests
These tasks build BIRD packages for various Linux distributions, and check whether these
actually install cleanly.
TODO:
- add automated cross platform packaging
- add package signing and repo upload
- add alpine
- add production docker image build
## Tag build collection
Release helper to collect all built packages when tag is made.
## Internal docker rebuild
All the distro build and packaging is done in docker build environments,
prepared with all the build dependencies, to shorten build times.
TODO:
- add on-demand triggers from the gitlab web ui
# Docker files for our test machinery
**These files are not distribution files for running BIRD. We currently
do not supply official BIRD images and do not prepare any Docker files ourselves.**
We build for the major Linux distributions, FreeBSD and OpenBSD. If you feel
that your favourite Linux distribution is missing, please send a patch.
Where to add your favourite Linux distribution:
- add an appropriate dockerfile here
- possibly add `pkg-*` and `install-*` template job in `gitlab/template.yml.j2`
- add your distribution into the `distros` list in `gitlab/data.yml.j2`
- run `make gitlab-local` or `make gitlab-venv` to rebuild `.gitlab-ci.yml`
Rebuilding the docker images is done by triggering the appropriate pipeline manually in Gitlab.
When images are disused, check [the registry](https://gitlab.nic.cz/labs/bird/container_registry/)
and untag them so that they can be garbage-collected.
## Debian-based distributions
We support Debian between oldoldstable and testing. If not, poke us.
We support Ubuntu LTS at least 5 years old and non-LTS before EOL. After EOL,
the non-LTS package repositories tend to disappear quite quickly so we don't
have resources to build against.
## RedHat-based distributions
We support OpenSUSE, Fedora, CentOS 7+8, Rocky Linux and Oracle Linux. If you are
missing your favourite new release, poke us. We are discontinuing the old
releases as they stop working.
The current support for CentOS 7 and 8 has been paid for and we may drop it without
further notice at the exact moment the customer stops using it.
We failed to find a reliable Docker image for Rocky Linux 10.
## Any other based distributions
We currently don't package for e.g. Alpine, Arch, Gentoo, Mint or Slackware.
Contributions are open, please refer to `CONTRIBUTING.md` for further information.
## FreeBSD and OpenBSD
These are not built in Docker but in proper virtuals in QEMU, refer to
bird2-2.17.5/gitlab/data.yml.j2 0000664 0000000 0000000 00000016447 15211753245 0016041 0 ustar 00root root 0000000 0000000 # Regex denoting stable branches for which we want to build packages
stable_branch_regex: '^(stable-.*|thread-next|master)$'
# Note: Dockerfiles must be rebuilt by manually triggering the pipeline
# with an appropriate input via https://gitlab.nic.cz/labs/bird/-/pipelines/new
distros:
# CentOS 7 with quite some hacks
- name: centos-7-amd64
variables:
LC_ALL: en_US.UTF-8
CC: /opt/rh/devtoolset-8/root/usr/bin/gcc
type: rpm
docker: static
- name: centos-8-amd64
type: rpm
docker:
parent: 'centos:8'
installer: yum -y
alternative_lsb: redhat-lsb-core
systemd: false
preinstall: |
# Has to be done for yum to work properly. CentOS 8 is EOL.
RUN sed -i s/mirror.centos.org/vault.centos.org/g /etc/yum.repos.d/CentOS-*.repo
RUN sed -i s/^#.*baseurl=http/baseurl=http/g /etc/yum.repos.d/CentOS-*.repo
RUN sed -i s/^mirrorlist=http/#mirrorlist=http/g /etc/yum.repos.d/CentOS-*.repo
# Rocky and Oracle Linux, forks of CentOS/RHEL
# check latest supported version at https://wiki.rockylinux.org/rocky/version/#__tabbed_1_2
{% for inum,snum in ((8,10),(9,5)) -%}
{% if inum >= 10 %}{% set num = inum ~ "" %}{% else %}{% set num = "0" ~ inum %}{% endif -%}
- name: rocky-{{ num }}-amd64
type: rpm
docker:
parent: 'rockylinux/rockylinux:{{ inum }}.{{snum}}'
installer: yum -y
{%- if num == "08" %}
alternative_lsb: redhat-lsb-core
systemd: false
{%- else %}
systemd: true
faketime: true
preinstall: 'RUN dnf -y install https://dl.fedoraproject.org/pub/epel/epel-release-latest-{{ inum }}.noarch.rpm'
{%- endif %}
{% endfor %}
{% for inum in (8,9,10) -%}
{% if inum >= 10 %}{% set num = inum ~ "" %}{% else %}{% set num = "0" ~ inum %}{% endif -%}
- name: oracle-{{ num }}-amd64
type: rpm
docker:
parent: 'oraclelinux:{{ inum }}'
installer: yum -y
{%- if num == "08" %}
alternative_lsb: redhat-lsb-core
systemd: false
{%- else %}
systemd: true
faketime: true
preinstall: 'RUN dnf -y install https://dl.fedoraproject.org/pub/epel/epel-release-latest-{{ inum }}.noarch.rpm'
{%- endif %}
{% endfor %}
# Last 7 years of OpenSUSE
{% for num in (0,1,2,3,4,5) -%}
- name: opensuse-15.{{ num }}-amd64
type: rpm
docker:
parent: 'opensuse/leap:15.{{num}}'
installer: zypper -n
pkgconfig: true
systemd: true
faketime: lib
sysuser: true
{% endfor %}
{% for num in (0,) -%}
- name: opensuse-16.{{ num }}-amd64
type: rpm
docker:
parent: 'opensuse/leap:16.{{num}}'
installer: zypper -n
pkgconfig: true
systemd: true
faketime: lib
sysuser: true
{% endfor %}
# Last 12 versions of Fedora
{% for num in (33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44) -%}
- name: fedora-{{ num }}-amd64
type: rpm
docker:
parent: fedora:{{ num }}
installer: dnf -y
pkgconfig: true
faketime: true
{%- if num <= 36 %}
alternative_lsb: redhat-lsb-core
{%- endif %}
systemd: true
{% endfor %}
# Debian from oldoldstable up to testing
{% for num, codename, crossarch in (
(11, "bullseye", []),
(12, "bookworm", ["mips64el", "s390x"]),
(13, "trixie", ["arm64", "armel", "armhf", "riscv64", "s390x"]),
("testing", "testing", ["arm64", "armhf", "riscv64", "s390x"])
) -%}
{% for arch in ('amd64', 'i386') -%}
- name: debian-{{num}}-{{arch}}
type: deb
shortname: debian
{%- if arch == "amd64" %}
crossarch: {{ crossarch }}
{%- endif %}
docker:
parent: {{ arch }}/debian:{{ codename }}-slim
libssh_kind: {% if (num != "testing") and (num < 13) %}libssh-gcrypt{% else %}libssh{% endif %}
needs_adduser: {% if (num != "testing") and (num < 13) %}false{% else %}true{% endif %}
{% endfor %}
{% endfor %}
# These debian don't crossbuild. TODO fix that.
# 12 -> ["arm64", "armel", "armhf"] -> Error 127 from `make check` probably because qemu-user is somehow botched
# Last 7 years of Ubuntu LTS
{% for num, crossarch in (
('18.04', []),
('20.04', []),
('22.04', []),
('24.04', ["arm64", "armhf", "ppc64el", "riscv64", "s390x"]),
('25.04', ["armhf", "ppc64el", "riscv64", "s390x"]),
('25.10', ["arm64", "armhf", "ppc64el", "riscv64", "s390x"]),
('26.04', ["arm64", "armhf", "ppc64el", "riscv64", "s390x"]),
) -%}
- name: ubuntu-{{ num }}-amd64
type: deb
shortname: ubuntu
crossarch: {{ crossarch }}
docker:
parent: "ubuntu:{{ num }}"
libssh_kind: {% if (num[:2] | int) < 25 %}libssh-gcrypt{% else %}libssh{% endif %}
needs_adduser: {% if (num[:2] | int) > 22 %}true{% else %}false{% endif %}
{% endfor %}
# These ubuntu don't crossbuild. TODO fix that.
# '22.04' -> ["arm64", "armhf", "ppc64el"] -> Error 127 from `make check` probably because qemu-user is somehow botched
# -> ["s390x"] doesn't pack -> debugedit --build-id --build-id-seed=bird2/2.18\+branch.mq.nightly.d0b6b85ebc17-cznic.1\~jammy debian/bird2/usr/sbin/birdc died with signal 11
# -> ["riscv64"] fails on dynamic linking libatomic.so.1 when running tests
# '25.04' -> ["arm64"] fails in `make check` with Timeout expired on `rt-fib_test`
birdlab:
- name: openbsd-76
variables:
AUTOCONF_VERSION: "2.72"
{% for num in ("09", "10") -%}
- name: netbsd-{{ num }}
{% endfor %}
{% for num in (13, 14) -%}
- name: freebsd-{{ num }}
- name: freebsd-{{ num }}-netlink
dist: freebsd-{{ num }}
variables:
CONFIGURE_OPTIONS: --with-sysconfig=bsd-netlink --disable-client
{% endfor %}
partial_build_image:
name: debian-12-amd64
partial_build:
- protocols: aggregator
- protocols: babel
- protocols: bfd
- protocols: bgp
- protocols: bgp,bmp
- protocols: l3vpn
- protocols: mrt
- protocols: ospf
- protocols: pipe
- protocols: radv
- protocols: rip
- protocols: rpki
- protocols: static
netlab:
- name: babel-base
- name: babel-auth
- name: ospf-base
- name: ospf-default
- name: ospf-priority
- name: ospf-nbma
- name: ospf-ptmp
- name: ospf-authentication
- name: ospf-bfd
- name: ospf-custom
- name: ospf-area
- name: ospf-vrf
- name: bgp-base
- name: bgp-auth
- name: bgp-int
- name: bgp-merged
- name: bgp-flowspec
- name: bgp-rs-multitab
- name: bgp-rs-singletab
- name: ebgp-graceful
- name: ebgp-loop
- name: ebgp-star
- name: ebgp-role
- name: ebgp-import-limit
- name: ebgp-hostname
- name: ebgp-bfd-auth
- name: ibgp-loop
- name: ibgp-loop-big
- name: ibgp-flat
- name: ibgp-bfd-auth
- name: rip-base
- name: rip-vrf
- name: kernel-learn
- name: mpls-bgp
- name: mpls-bgp-l3vpn
- name: pipe-collision
- name: ebgp-refresh/gen/imno-basic-imex-basic
- name: ebgp-refresh/gen/noex-basic-imno-enhanced
- name: ebgp-refresh/gen/imex-basic-noex-none
- name: ebgp-refresh/gen/nono-enhanced-nono-basic
- name: ebgp-refresh/gen/imno-none-imex-basic
- name: ebgp-refresh/gen/noex-none-imno-enhanced
- name: ebgp-refresh/gen/imex-none-noex-none
- name: ebgp-refresh/gen/nono-none-nono-basic
- name: ebgp-refresh/gen/imno-enhanced-imex-enhanced
- name: ebgp-refresh/gen/noex-enhanced-imno-enhanced
- name: ebgp-refresh/gen/imex-enhanced-noex-enhanced
- name: ebgp-refresh/gen/nono-enhanced-nono-enhanced
bird2-2.17.5/gitlab/docker.mk.j2 0000664 0000000 0000000 00000000552 15211753245 0016173 0 ustar 00root root 0000000 0000000 GITLAB_DOCKER_IMAGES := \
{% for distro in distros -%}
$(s)docker/{{ distro.name }}/Dockerfile \
{% endfor %}
gitlab-docker: $(GITLAB_DOCKER_IMAGES)
{% for distro in distros -%}
{% if distro.docker == "static" %}
$(s)docker/{{ distro.name }}/Dockerfile: $(s)docker.mk.j2 $(s)data.yml.j2
@echo "KEEP $@ (marked as static)"
touch $@
{% endif %}
{% endfor %}
bird2-2.17.5/gitlab/docker/ 0000775 0000000 0000000 00000000000 15211753245 0015326 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/centos-7-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017676 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/centos-7-amd64/Dockerfile 0000664 0000000 0000000 00000003145 15211753245 0021673 0 ustar 00root root 0000000 0000000 # bump number for image rebuild: 0
FROM centos:7
# Has to be done for yum to work properly. CentOS 7 is EOL.
RUN sed -i s/mirror.centos.org/vault.centos.org/g /etc/yum.repos.d/CentOS-*.repo
RUN sed -i s/^#.*baseurl=http/baseurl=http/g /etc/yum.repos.d/CentOS-*.repo
RUN sed -i s/^mirrorlist=http/#mirrorlist=http/g /etc/yum.repos.d/CentOS-*.repo
# Add new repos for devtoolset-8-gcc.
# We need to use devtoolset, because BIRD cannot be correctly compiled with CentOS 7 version of gcc.
RUN echo -e \
"\n[centos-sclo-rh]\nname=CentOS-7.8.2003 - SCLo rh\nbaseurl=https://vault.centos.org/7.8.2003/sclo/\$basearch/rh/\ngpgcheck=0\nenabled=1" \
>> /etc/yum.repos.d/CentOS-Base.repo
RUN echo -e \
"\n[centos-sclo-sclo]\nname=CentOS-7.8.2003 - SCLo sclo\nbaseurl=https://vault.centos.org/7.8.2003/sclo/\$basearch/sclo/\ngpgcheck=0\nenabled=1" \
>> /etc/yum.repos.d/CentOS-Base.repo
RUN yum -y upgrade
# Change kernel-headers
RUN yum -y remove \
kernel-headers
RUN yum -y install \
https://dl.lamp.sh/kernel/el7/kernel-ml-headers-6.6.41-1.el7.x86_64.rpm
RUN yum -y install \
gcc \
make \
flex \
bison \
autoconf \
libssh-devel \
ncurses-devel \
readline-devel \
centos-release-scl
RUN yum -y install \
git \
rpm-build \
faketime \
redhat-lsb-core \
python3 \
python3-pip \
python3-setuptools \
devtoolset-8-toolchain
# Backported newer RPM macros, hoping that it stays there for some while until we drop CentOS 7 support
RUN yum -y install \
ftp://ftp.icm.edu.pl/packages/linux-pbone/ftp5.gwdg.de/pub/opensuse/repositories/systemsmanagement:/Ardana:/8:/CentOS/CentOS_7.3/noarch/systemd-rpm-macros-3-5.2.noarch.rpm
bird2-2.17.5/gitlab/docker/centos-8-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017677 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/centos-8-amd64/Dockerfile 0000664 0000000 0000000 00000001455 15211753245 0021676 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for centos-8-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM centos:8
# Has to be done for yum to work properly. CentOS 8 is EOL.
RUN sed -i s/mirror.centos.org/vault.centos.org/g /etc/yum.repos.d/CentOS-*.repo
RUN sed -i s/^#.*baseurl=http/baseurl=http/g /etc/yum.repos.d/CentOS-*.repo
RUN sed -i s/^mirrorlist=http/#mirrorlist=http/g /etc/yum.repos.d/CentOS-*.repo
RUN yum -y upgrade
RUN yum -y install \
gcc \
make \
flex \
bison \
autoconf \
libssh-devel \
ncurses-devel \
readline-devel
RUN yum -y install \
git \
redhat-lsb-core \
rpm-build \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/debian-11-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017700 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/debian-11-amd64/Dockerfile 0000664 0000000 0000000 00000001614 15211753245 0021674 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for debian-11-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM amd64/debian:bullseye-slim
ENV DEBIAN_FRONTEND=noninteractive
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
build-essential \
flex \
bison \
autoconf \
ncurses-dev \
libreadline-dev \
libssh-gcrypt-dev \
linuxdoc-tools-latex \
texlive-latex-extra \
opensp \
docbook-xsl \
xsltproc
RUN apt-get -y --no-install-recommends install \
git \
dpkg-dev \
debhelper \
lsb-release \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
RUN apt-get -y clean
bird2-2.17.5/gitlab/docker/debian-11-i386/ 0000775 0000000 0000000 00000000000 15211753245 0017456 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/debian-11-i386/Dockerfile 0000664 0000000 0000000 00000001612 15211753245 0021450 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for debian-11-i386.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM i386/debian:bullseye-slim
ENV DEBIAN_FRONTEND=noninteractive
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
build-essential \
flex \
bison \
autoconf \
ncurses-dev \
libreadline-dev \
libssh-gcrypt-dev \
linuxdoc-tools-latex \
texlive-latex-extra \
opensp \
docbook-xsl \
xsltproc
RUN apt-get -y --no-install-recommends install \
git \
dpkg-dev \
debhelper \
lsb-release \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
RUN apt-get -y clean
bird2-2.17.5/gitlab/docker/debian-12-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017701 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/debian-12-amd64/Dockerfile 0000664 0000000 0000000 00000002247 15211753245 0021700 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for debian-12-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM amd64/debian:bookworm-slim
ENV DEBIAN_FRONTEND=noninteractive
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN dpkg --add-architecture mips64el
RUN dpkg --add-architecture s390x
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
build-essential \
flex \
bison \
autoconf \
ncurses-dev \
libreadline-dev \
libssh-gcrypt-dev \
crossbuild-essential-mips64el \
libreadline-dev:mips64el \
ncurses-dev:mips64el \
crossbuild-essential-s390x \
libreadline-dev:s390x \
ncurses-dev:s390x \
qemu-user \
qemu-user-binfmt \
binfmt-support \
linuxdoc-tools-latex \
texlive-latex-extra \
opensp \
docbook-xsl \
xsltproc
RUN apt-get -y --no-install-recommends install \
git \
dpkg-dev \
debhelper \
lsb-release \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
RUN apt-get -y clean
bird2-2.17.5/gitlab/docker/debian-12-i386/ 0000775 0000000 0000000 00000000000 15211753245 0017457 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/debian-12-i386/Dockerfile 0000664 0000000 0000000 00000001612 15211753245 0021451 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for debian-12-i386.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM i386/debian:bookworm-slim
ENV DEBIAN_FRONTEND=noninteractive
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
build-essential \
flex \
bison \
autoconf \
ncurses-dev \
libreadline-dev \
libssh-gcrypt-dev \
linuxdoc-tools-latex \
texlive-latex-extra \
opensp \
docbook-xsl \
xsltproc
RUN apt-get -y --no-install-recommends install \
git \
dpkg-dev \
debhelper \
lsb-release \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
RUN apt-get -y clean
bird2-2.17.5/gitlab/docker/debian-13-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017702 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/debian-13-amd64/Dockerfile 0000664 0000000 0000000 00000002757 15211753245 0021707 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for debian-13-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM amd64/debian:trixie-slim
ENV DEBIAN_FRONTEND=noninteractive
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN dpkg --add-architecture arm64
RUN dpkg --add-architecture armel
RUN dpkg --add-architecture armhf
RUN dpkg --add-architecture riscv64
RUN dpkg --add-architecture s390x
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
build-essential \
flex \
bison \
autoconf \
ncurses-dev \
libreadline-dev \
libssh-dev \
crossbuild-essential-arm64 \
libreadline-dev:arm64 \
ncurses-dev:arm64 \
crossbuild-essential-armel \
libreadline-dev:armel \
ncurses-dev:armel \
crossbuild-essential-armhf \
libreadline-dev:armhf \
ncurses-dev:armhf \
crossbuild-essential-riscv64 \
libreadline-dev:riscv64 \
ncurses-dev:riscv64 \
crossbuild-essential-s390x \
libreadline-dev:s390x \
ncurses-dev:s390x \
qemu-user \
qemu-user-binfmt \
binfmt-support \
linuxdoc-tools-latex \
texlive-latex-extra \
opensp \
docbook-xsl \
xsltproc \
adduser
RUN apt-get -y --no-install-recommends install \
git \
dpkg-dev \
debhelper \
lsb-release \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
RUN apt-get -y clean
bird2-2.17.5/gitlab/docker/debian-13-i386/ 0000775 0000000 0000000 00000000000 15211753245 0017460 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/debian-13-i386/Dockerfile 0000664 0000000 0000000 00000001614 15211753245 0021454 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for debian-13-i386.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM i386/debian:trixie-slim
ENV DEBIAN_FRONTEND=noninteractive
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
build-essential \
flex \
bison \
autoconf \
ncurses-dev \
libreadline-dev \
libssh-dev \
linuxdoc-tools-latex \
texlive-latex-extra \
opensp \
docbook-xsl \
xsltproc \
adduser
RUN apt-get -y --no-install-recommends install \
git \
dpkg-dev \
debhelper \
lsb-release \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
RUN apt-get -y clean
bird2-2.17.5/gitlab/docker/debian-testing-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0021134 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/debian-testing-amd64/Dockerfile 0000664 0000000 0000000 00000002607 15211753245 0023133 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for debian-testing-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM amd64/debian:testing-slim
ENV DEBIAN_FRONTEND=noninteractive
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN dpkg --add-architecture arm64
RUN dpkg --add-architecture armhf
RUN dpkg --add-architecture riscv64
RUN dpkg --add-architecture s390x
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
build-essential \
flex \
bison \
autoconf \
ncurses-dev \
libreadline-dev \
libssh-dev \
crossbuild-essential-arm64 \
libreadline-dev:arm64 \
ncurses-dev:arm64 \
crossbuild-essential-armhf \
libreadline-dev:armhf \
ncurses-dev:armhf \
crossbuild-essential-riscv64 \
libreadline-dev:riscv64 \
ncurses-dev:riscv64 \
crossbuild-essential-s390x \
libreadline-dev:s390x \
ncurses-dev:s390x \
qemu-user \
qemu-user-binfmt \
binfmt-support \
linuxdoc-tools-latex \
texlive-latex-extra \
opensp \
docbook-xsl \
xsltproc \
adduser
RUN apt-get -y --no-install-recommends install \
git \
dpkg-dev \
debhelper \
lsb-release \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
RUN apt-get -y clean
bird2-2.17.5/gitlab/docker/debian-testing-i386/ 0000775 0000000 0000000 00000000000 15211753245 0020712 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/debian-testing-i386/Dockerfile 0000664 0000000 0000000 00000001622 15211753245 0022705 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for debian-testing-i386.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM i386/debian:testing-slim
ENV DEBIAN_FRONTEND=noninteractive
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
build-essential \
flex \
bison \
autoconf \
ncurses-dev \
libreadline-dev \
libssh-dev \
linuxdoc-tools-latex \
texlive-latex-extra \
opensp \
docbook-xsl \
xsltproc \
adduser
RUN apt-get -y --no-install-recommends install \
git \
dpkg-dev \
debhelper \
lsb-release \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
RUN apt-get -y clean
bird2-2.17.5/gitlab/docker/docbuilder/ 0000775 0000000 0000000 00000000000 15211753245 0017442 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/docbuilder/Dockerfile 0000664 0000000 0000000 00000001074 15211753245 0021436 0 ustar 00root root 0000000 0000000 # bump this to recreate the image: 2
FROM debian:trixie-slim
ENV DEBIAN_FRONTEND=noninteractive
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
build-essential \
flex \
bison \
autoconf \
git \
pandoc \
ncurses-dev \
libreadline-dev \
libssh-dev \
linuxdoc-tools-latex \
texlive-latex-extra \
groff \
opensp \
docbook-xsl \
xsltproc
RUN apt-get -y --no-install-recommends install \
dpkg-dev \
debhelper \
distro-info-data \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
bird2-2.17.5/gitlab/docker/fedora-33-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017722 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/fedora-33-amd64/Dockerfile 0000664 0000000 0000000 00000001051 15211753245 0021711 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for fedora-33-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM fedora:33
RUN dnf -y upgrade
RUN dnf -y install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN dnf -y install \
git \
redhat-lsb-core \
rpm-build \
faketime \
systemd \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/fedora-34-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017723 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/fedora-34-amd64/Dockerfile 0000664 0000000 0000000 00000001051 15211753245 0021712 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for fedora-34-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM fedora:34
RUN dnf -y upgrade
RUN dnf -y install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN dnf -y install \
git \
redhat-lsb-core \
rpm-build \
faketime \
systemd \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/fedora-35-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017724 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/fedora-35-amd64/Dockerfile 0000664 0000000 0000000 00000001051 15211753245 0021713 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for fedora-35-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM fedora:35
RUN dnf -y upgrade
RUN dnf -y install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN dnf -y install \
git \
redhat-lsb-core \
rpm-build \
faketime \
systemd \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/fedora-36-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017725 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/fedora-36-amd64/Dockerfile 0000664 0000000 0000000 00000001051 15211753245 0021714 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for fedora-36-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM fedora:36
RUN dnf -y upgrade
RUN dnf -y install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN dnf -y install \
git \
redhat-lsb-core \
rpm-build \
faketime \
systemd \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/fedora-37-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017726 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/fedora-37-amd64/Dockerfile 0000664 0000000 0000000 00000001045 15211753245 0021720 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for fedora-37-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM fedora:37
RUN dnf -y upgrade
RUN dnf -y install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN dnf -y install \
git \
lsb-release \
rpm-build \
faketime \
systemd \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/fedora-38-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017727 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/fedora-38-amd64/Dockerfile 0000664 0000000 0000000 00000001045 15211753245 0021721 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for fedora-38-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM fedora:38
RUN dnf -y upgrade
RUN dnf -y install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN dnf -y install \
git \
lsb-release \
rpm-build \
faketime \
systemd \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/fedora-39-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017730 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/fedora-39-amd64/Dockerfile 0000664 0000000 0000000 00000001045 15211753245 0021722 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for fedora-39-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM fedora:39
RUN dnf -y upgrade
RUN dnf -y install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN dnf -y install \
git \
lsb-release \
rpm-build \
faketime \
systemd \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/fedora-40-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017720 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/fedora-40-amd64/Dockerfile 0000664 0000000 0000000 00000001045 15211753245 0021712 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for fedora-40-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM fedora:40
RUN dnf -y upgrade
RUN dnf -y install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN dnf -y install \
git \
lsb-release \
rpm-build \
faketime \
systemd \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/fedora-41-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017721 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/fedora-41-amd64/Dockerfile 0000664 0000000 0000000 00000001045 15211753245 0021713 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for fedora-41-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM fedora:41
RUN dnf -y upgrade
RUN dnf -y install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN dnf -y install \
git \
lsb-release \
rpm-build \
faketime \
systemd \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/fedora-42-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017722 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/fedora-42-amd64/Dockerfile 0000664 0000000 0000000 00000001045 15211753245 0021714 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for fedora-42-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM fedora:42
RUN dnf -y upgrade
RUN dnf -y install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN dnf -y install \
git \
lsb-release \
rpm-build \
faketime \
systemd \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/fedora-43-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017723 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/fedora-43-amd64/Dockerfile 0000664 0000000 0000000 00000001045 15211753245 0021715 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for fedora-43-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM fedora:43
RUN dnf -y upgrade
RUN dnf -y install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN dnf -y install \
git \
lsb-release \
rpm-build \
faketime \
systemd \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/fedora-44-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017724 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/fedora-44-amd64/Dockerfile 0000664 0000000 0000000 00000001045 15211753245 0021716 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for fedora-44-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM fedora:44
RUN dnf -y upgrade
RUN dnf -y install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN dnf -y install \
git \
lsb-release \
rpm-build \
faketime \
systemd \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/opensuse-15.0-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0020461 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/opensuse-15.0-amd64/Dockerfile 0000664 0000000 0000000 00000001112 15211753245 0022446 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for opensuse-15.0-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM opensuse/leap:15.0
RUN zypper -n up
RUN zypper -n install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN zypper -n install \
git \
lsb-release \
rpm-build \
libfaketime \
systemd \
systemd-rpm-macros \
sysuser-tools \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/opensuse-15.1-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0020462 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/opensuse-15.1-amd64/Dockerfile 0000664 0000000 0000000 00000001112 15211753245 0022447 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for opensuse-15.1-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM opensuse/leap:15.1
RUN zypper -n up
RUN zypper -n install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN zypper -n install \
git \
lsb-release \
rpm-build \
libfaketime \
systemd \
systemd-rpm-macros \
sysuser-tools \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/opensuse-15.2-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0020463 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/opensuse-15.2-amd64/Dockerfile 0000664 0000000 0000000 00000001112 15211753245 0022450 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for opensuse-15.2-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM opensuse/leap:15.2
RUN zypper -n up
RUN zypper -n install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN zypper -n install \
git \
lsb-release \
rpm-build \
libfaketime \
systemd \
systemd-rpm-macros \
sysuser-tools \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/opensuse-15.3-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0020464 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/opensuse-15.3-amd64/Dockerfile 0000664 0000000 0000000 00000001112 15211753245 0022451 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for opensuse-15.3-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM opensuse/leap:15.3
RUN zypper -n up
RUN zypper -n install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN zypper -n install \
git \
lsb-release \
rpm-build \
libfaketime \
systemd \
systemd-rpm-macros \
sysuser-tools \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/opensuse-15.4-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0020465 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/opensuse-15.4-amd64/Dockerfile 0000664 0000000 0000000 00000001112 15211753245 0022452 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for opensuse-15.4-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM opensuse/leap:15.4
RUN zypper -n up
RUN zypper -n install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN zypper -n install \
git \
lsb-release \
rpm-build \
libfaketime \
systemd \
systemd-rpm-macros \
sysuser-tools \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/opensuse-15.5-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0020466 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/opensuse-15.5-amd64/Dockerfile 0000664 0000000 0000000 00000001112 15211753245 0022453 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for opensuse-15.5-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM opensuse/leap:15.5
RUN zypper -n up
RUN zypper -n install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN zypper -n install \
git \
lsb-release \
rpm-build \
libfaketime \
systemd \
systemd-rpm-macros \
sysuser-tools \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/opensuse-16.0-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0020462 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/opensuse-16.0-amd64/Dockerfile 0000664 0000000 0000000 00000001112 15211753245 0022447 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for opensuse-16.0-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM opensuse/leap:16.0
RUN zypper -n up
RUN zypper -n install \
gcc \
make \
flex \
bison \
autoconf \
pkgconfig \
libssh-devel \
ncurses-devel \
readline-devel
RUN zypper -n install \
git \
lsb-release \
rpm-build \
libfaketime \
systemd \
systemd-rpm-macros \
sysuser-tools \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/oracle-08-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017731 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/oracle-08-amd64/Dockerfile 0000664 0000000 0000000 00000001011 15211753245 0021714 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for oracle-08-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM oraclelinux:8
RUN yum -y upgrade
RUN yum -y install \
gcc \
make \
flex \
bison \
autoconf \
libssh-devel \
ncurses-devel \
readline-devel
RUN yum -y install \
git \
redhat-lsb-core \
rpm-build \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/oracle-09-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017732 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/oracle-09-amd64/Dockerfile 0000664 0000000 0000000 00000001166 15211753245 0021730 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for oracle-09-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM oraclelinux:9
RUN dnf -y install https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm
RUN yum -y upgrade
RUN yum -y install \
gcc \
make \
flex \
bison \
autoconf \
libssh-devel \
ncurses-devel \
readline-devel
RUN yum -y install \
git \
lsb-release \
rpm-build \
faketime \
systemd \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/oracle-10-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017722 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/oracle-10-amd64/Dockerfile 0000664 0000000 0000000 00000001170 15211753245 0021713 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for oracle-10-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM oraclelinux:10
RUN dnf -y install https://dl.fedoraproject.org/pub/epel/epel-release-latest-10.noarch.rpm
RUN yum -y upgrade
RUN yum -y install \
gcc \
make \
flex \
bison \
autoconf \
libssh-devel \
ncurses-devel \
readline-devel
RUN yum -y install \
git \
lsb-release \
rpm-build \
faketime \
systemd \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/rocky-08-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017613 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/rocky-08-amd64/Dockerfile 0000664 0000000 0000000 00000001025 15211753245 0021603 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for rocky-08-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM rockylinux/rockylinux:8.10
RUN yum -y upgrade
RUN yum -y install \
gcc \
make \
flex \
bison \
autoconf \
libssh-devel \
ncurses-devel \
readline-devel
RUN yum -y install \
git \
redhat-lsb-core \
rpm-build \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/rocky-09-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0017614 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/rocky-09-amd64/Dockerfile 0000664 0000000 0000000 00000001201 15211753245 0021600 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for rocky-09-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM rockylinux/rockylinux:9.5
RUN dnf -y install https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm
RUN yum -y upgrade
RUN yum -y install \
gcc \
make \
flex \
bison \
autoconf \
libssh-devel \
ncurses-devel \
readline-devel
RUN yum -y install \
git \
lsb-release \
rpm-build \
faketime \
systemd \
systemd-rpm-macros \
python3 \
python3-pip \
python3-setuptools
bird2-2.17.5/gitlab/docker/ubuntu-18.04-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0020231 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/ubuntu-18.04-amd64/Dockerfile 0000664 0000000 0000000 00000001613 15211753245 0022224 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for ubuntu-18.04-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM ubuntu:18.04
ENV DEBIAN_FRONTEND=noninteractive
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
tzdata \
build-essential \
flex \
bison \
autoconf \
ncurses-dev \
libreadline-dev \
libssh-gcrypt-dev \
linuxdoc-tools-latex \
texlive-latex-extra \
opensp \
docbook-xsl \
xsltproc
RUN apt-get -y --no-install-recommends install \
git \
dpkg-dev \
debhelper \
lsb-release \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
RUN apt-get -y clean
bird2-2.17.5/gitlab/docker/ubuntu-20.04-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0020222 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/ubuntu-20.04-amd64/Dockerfile 0000664 0000000 0000000 00000001613 15211753245 0022215 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for ubuntu-20.04-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM ubuntu:20.04
ENV DEBIAN_FRONTEND=noninteractive
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
tzdata \
build-essential \
flex \
bison \
autoconf \
ncurses-dev \
libreadline-dev \
libssh-gcrypt-dev \
linuxdoc-tools-latex \
texlive-latex-extra \
opensp \
docbook-xsl \
xsltproc
RUN apt-get -y --no-install-recommends install \
git \
dpkg-dev \
debhelper \
lsb-release \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
RUN apt-get -y clean
bird2-2.17.5/gitlab/docker/ubuntu-22.04-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0020224 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/ubuntu-22.04-amd64/Dockerfile 0000664 0000000 0000000 00000002223 15211753245 0022215 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for ubuntu-22.04-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM ubuntu:22.04
ENV DEBIAN_FRONTEND=noninteractive
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN find /etc/apt/sourc* -type f -exec sed -i 's/^deb /deb [arch=amd64] /' '{}' +
RUN find /etc/apt/sourc* -type f -exec sed -r '/^deb /{s#arch=amd64#arch=#;s#https?://[^ ]+#http://ports.ubuntu.com/ubuntu-ports/#}' '{}' + > /etc/apt/sources.list.d/crossbuild.list
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
tzdata \
build-essential \
flex \
bison \
autoconf \
ncurses-dev \
libreadline-dev \
libssh-gcrypt-dev \
linuxdoc-tools-latex \
texlive-latex-extra \
opensp \
docbook-xsl \
xsltproc
RUN apt-get -y --no-install-recommends install \
git \
dpkg-dev \
debhelper \
lsb-release \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
RUN apt-get -y clean
bird2-2.17.5/gitlab/docker/ubuntu-24.04-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0020226 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/ubuntu-24.04-amd64/Dockerfile 0000664 0000000 0000000 00000003476 15211753245 0022232 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for ubuntu-24.04-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM ubuntu:24.04
ENV DEBIAN_FRONTEND=noninteractive
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN dpkg --add-architecture arm64
RUN dpkg --add-architecture armhf
RUN dpkg --add-architecture ppc64el
RUN dpkg --add-architecture riscv64
RUN dpkg --add-architecture s390x
RUN find /etc/apt/sourc* -type f -exec sed -i '/Components: /a\
Architectures: amd64' '{}' +
RUN find /etc/apt/sourc* -type f -exec sed 's#URIs: .*#URIs: http://ports.ubuntu.com/ubuntu-ports/#;s#Architectures: amd64#Architectures: arm64,armhf,ppc64el,riscv64,s390x#' '{}' + > /etc/apt/sources.list.d/crossbuild.sources
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
tzdata \
build-essential \
flex \
bison \
autoconf \
ncurses-dev \
libreadline-dev \
libssh-gcrypt-dev \
crossbuild-essential-arm64 \
libreadline-dev:arm64 \
ncurses-dev:arm64 \
crossbuild-essential-armhf \
libreadline-dev:armhf \
ncurses-dev:armhf \
crossbuild-essential-ppc64el \
libreadline-dev:ppc64el \
ncurses-dev:ppc64el \
crossbuild-essential-riscv64 \
libreadline-dev:riscv64 \
ncurses-dev:riscv64 \
crossbuild-essential-s390x \
libreadline-dev:s390x \
ncurses-dev:s390x \
qemu-user \
qemu-user-binfmt \
binfmt-support \
linuxdoc-tools-latex \
texlive-latex-extra \
opensp \
docbook-xsl \
xsltproc \
adduser
RUN apt-get -y --no-install-recommends install \
git \
dpkg-dev \
debhelper \
lsb-release \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
RUN apt-get -y clean
bird2-2.17.5/gitlab/docker/ubuntu-25.04-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0020227 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/ubuntu-25.04-amd64/Dockerfile 0000664 0000000 0000000 00000003303 15211753245 0022220 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for ubuntu-25.04-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM ubuntu:25.04
ENV DEBIAN_FRONTEND=noninteractive
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN dpkg --add-architecture armhf
RUN dpkg --add-architecture ppc64el
RUN dpkg --add-architecture riscv64
RUN dpkg --add-architecture s390x
RUN find /etc/apt/sourc* -type f -exec sed -i '/Components: /a\
Architectures: amd64' '{}' +
RUN find /etc/apt/sourc* -type f -exec sed 's#URIs: .*#URIs: http://ports.ubuntu.com/ubuntu-ports/#;s#Architectures: amd64#Architectures: armhf,ppc64el,riscv64,s390x#' '{}' + > /etc/apt/sources.list.d/crossbuild.sources
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
tzdata \
build-essential \
flex \
bison \
autoconf \
ncurses-dev \
libreadline-dev \
libssh-dev \
crossbuild-essential-armhf \
libreadline-dev:armhf \
ncurses-dev:armhf \
crossbuild-essential-ppc64el \
libreadline-dev:ppc64el \
ncurses-dev:ppc64el \
crossbuild-essential-riscv64 \
libreadline-dev:riscv64 \
ncurses-dev:riscv64 \
crossbuild-essential-s390x \
libreadline-dev:s390x \
ncurses-dev:s390x \
qemu-user \
qemu-user-binfmt \
binfmt-support \
linuxdoc-tools-latex \
texlive-latex-extra \
opensp \
docbook-xsl \
xsltproc \
adduser
RUN apt-get -y --no-install-recommends install \
git \
dpkg-dev \
debhelper \
lsb-release \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
RUN apt-get -y clean
bird2-2.17.5/gitlab/docker/ubuntu-25.10-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0020224 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/ubuntu-25.10-amd64/Dockerfile 0000664 0000000 0000000 00000003467 15211753245 0022230 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for ubuntu-25.10-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM ubuntu:25.10
ENV DEBIAN_FRONTEND=noninteractive
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN dpkg --add-architecture arm64
RUN dpkg --add-architecture armhf
RUN dpkg --add-architecture ppc64el
RUN dpkg --add-architecture riscv64
RUN dpkg --add-architecture s390x
RUN find /etc/apt/sourc* -type f -exec sed -i '/Components: /a\
Architectures: amd64' '{}' +
RUN find /etc/apt/sourc* -type f -exec sed 's#URIs: .*#URIs: http://ports.ubuntu.com/ubuntu-ports/#;s#Architectures: amd64#Architectures: arm64,armhf,ppc64el,riscv64,s390x#' '{}' + > /etc/apt/sources.list.d/crossbuild.sources
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
tzdata \
build-essential \
flex \
bison \
autoconf \
ncurses-dev \
libreadline-dev \
libssh-dev \
crossbuild-essential-arm64 \
libreadline-dev:arm64 \
ncurses-dev:arm64 \
crossbuild-essential-armhf \
libreadline-dev:armhf \
ncurses-dev:armhf \
crossbuild-essential-ppc64el \
libreadline-dev:ppc64el \
ncurses-dev:ppc64el \
crossbuild-essential-riscv64 \
libreadline-dev:riscv64 \
ncurses-dev:riscv64 \
crossbuild-essential-s390x \
libreadline-dev:s390x \
ncurses-dev:s390x \
qemu-user \
qemu-user-binfmt \
binfmt-support \
linuxdoc-tools-latex \
texlive-latex-extra \
opensp \
docbook-xsl \
xsltproc \
adduser
RUN apt-get -y --no-install-recommends install \
git \
dpkg-dev \
debhelper \
lsb-release \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
RUN apt-get -y clean
bird2-2.17.5/gitlab/docker/ubuntu-26.04-amd64/ 0000775 0000000 0000000 00000000000 15211753245 0020230 5 ustar 00root root 0000000 0000000 bird2-2.17.5/gitlab/docker/ubuntu-26.04-amd64/Dockerfile 0000664 0000000 0000000 00000003467 15211753245 0022234 0 ustar 00root root 0000000 0000000 # Autogenerated Dockerfile for ubuntu-26.04-amd64.
# Update data in gitlab/data.yml.j2 and gitlab/Dockerfile.j2
# to change this file.
# Request a manual pipeline to rebuild the image here:
# https://gitlab.nic.cz/labs/bird/-/pipelines/new
FROM ubuntu:26.04
ENV DEBIAN_FRONTEND=noninteractive
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN dpkg --add-architecture arm64
RUN dpkg --add-architecture armhf
RUN dpkg --add-architecture ppc64el
RUN dpkg --add-architecture riscv64
RUN dpkg --add-architecture s390x
RUN find /etc/apt/sourc* -type f -exec sed -i '/Components: /a\
Architectures: amd64' '{}' +
RUN find /etc/apt/sourc* -type f -exec sed 's#URIs: .*#URIs: http://ports.ubuntu.com/ubuntu-ports/#;s#Architectures: amd64#Architectures: arm64,armhf,ppc64el,riscv64,s390x#' '{}' + > /etc/apt/sources.list.d/crossbuild.sources
RUN find /etc/apt/sourc* -type f -exec grep -nH '.*' '{}' +
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y --no-install-recommends install \
tzdata \
build-essential \
flex \
bison \
autoconf \
ncurses-dev \
libreadline-dev \
libssh-dev \
crossbuild-essential-arm64 \
libreadline-dev:arm64 \
ncurses-dev:arm64 \
crossbuild-essential-armhf \
libreadline-dev:armhf \
ncurses-dev:armhf \
crossbuild-essential-ppc64el \
libreadline-dev:ppc64el \
ncurses-dev:ppc64el \
crossbuild-essential-riscv64 \
libreadline-dev:riscv64 \
ncurses-dev:riscv64 \
crossbuild-essential-s390x \
libreadline-dev:s390x \
ncurses-dev:s390x \
qemu-user \
qemu-user-binfmt \
binfmt-support \
linuxdoc-tools-latex \
texlive-latex-extra \
opensp \
docbook-xsl \
xsltproc \
adduser
RUN apt-get -y --no-install-recommends install \
git \
dpkg-dev \
debhelper \
lsb-release \
apt-utils \
quilt \
python3 \
python3-pip \
python3-setuptools \
python3-venv
RUN apt-get -y clean
bird2-2.17.5/gitlab/pipeline.py 0000775 0000000 0000000 00000001655 15211753245 0016250 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python3
import importlib
import jinja2
import pathlib
import subprocess
import sys
import yaml
# Find where we are
_, template_file, data_file, *more = sys.argv
hm = { k: v for k,v in [ x.split("=", 1) for x in more ] }
# Crash helper
def fail(msg):
raise Exception(msg)
# Prepare Jinja2 environment
env = jinja2.Environment(loader=jinja2.FileSystemLoader("."))
env.globals['fail'] = fail
env.filters.update({ "to_yaml": lambda x: "" if type(x) is jinja2.runtime.Undefined else yaml.dump(x).rstrip() })
# Load and process input data
try:
data = yaml.safe_load(rendered := env.get_template(data_file).render({}))
except yaml.parser.ParserError as e:
print("Failed to render input data, generated output here:")
print(rendered)
raise e
# Load the actual template
template = env.get_template(template_file)
# Render the template
final = template.render({ **data, **hm })
# Produce output
print(final)
bird2-2.17.5/gitlab/template.yml.j2 0000664 0000000 0000000 00000050412 15211753245 0016731 0 ustar 00root root 0000000 0000000 ###########################################################
##### #####
##### DO NOT EDIT THIS FILE BY HAND #####
##### #####
###########################################################
##### #####
##### This file is autogenerated from gitlab/. #####
##### Edit those files and run `make gitlab` instead. #####
##### #####
###########################################################
spec:
inputs:
netlab:
description: "Manually run netlab tests"
type: boolean
default: false
build:
description: "Manually run build tests"
type: boolean
default: false
packages:
description: "Manually run packaging (will run also build tests anyway)"
type: boolean
default: false
release-fixup:
description: "Suffix for package build (if other than 1, this is a rebuild of a release)"
type: number
default: 1
release-desc:
description: "Package build description (change this for release rebuild)"
type: string
default: "upstream package"
docker-all:
description: "Rebuild all dockers"
type: boolean
default: false
docker-regex:
description: "Rebuild dockers matching this regex"
type: string
default: 'NOTHING' # this is another hack because of gitlab syntax quirks
docker-one:
description: "Rebuild this one docker (keep empty for none)"
type: string
default: ''
options:
- ''
{%- for docker in [ { "name": "docbuilder" } ] + distros %}
- {{ docker["name"] }}
{%- endfor %}
---
variables:
DEBIAN_FRONTEND: noninteractive
LC_ALL: C.UTF-8
GIT_STRATEGY: fetch
DOCKER_CMD: docker --config="$HOME/.docker/$CI_JOB_ID/"
IMG_BASE: registry.nic.cz/labs/bird
TOOLS_DIR: /home/gitlab-runner/bird-tools
STAYRTR_BINARY: /usr/local/bin/stayrtr
GITLAB_API_URL: ${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/
stages:
- consistency
- image
- build
- pkg
- install
- test
## Common rule snippets
{%- set is_push = '($CI_PIPELINE_SOURCE == "push")' %}
{%- set is_mreq = '($CI_PIPELINE_SOURCE == "merge_request_event")' %}
{%- set is_manual = '($CI_PIPELINE_SOURCE == "web")' %}
{%- set is_api = '($CI_PIPELINE_SOURCE == "api")' %}
{%- set is_sched = '($CI_PIPELINE_SOURCE == "schedule")' %}
{%- set is_stable = '($CI_COMMIT_BRANCH =~ /' ~ stable_branch_regex ~ '/)' %}
{%- set not_stable = '($CI_COMMIT_BRANCH !~ /' ~ stable_branch_regex ~ '/)' %}
{%- set is_release_commit = '($CI_COMMIT_MESSAGE =~ /^NEWS and version update/)' %}
{%- set is_wip = '($CI_COMMIT_MESSAGE =~ /^(fixup! )*WIP/)' %}
{%- set is_tag = '$CI_COMMIT_TAG' %}
{%- set inputs_packages = '"$[[ inputs.packages ]]" == "true"' %}
{%- set inputs_build = '"$[[ inputs.build ]]" == "true"' %}
{%- set inputs_netlab = '"$[[ inputs.netlab ]]" == "true"' %}
{%- set inputs_docker_all = '"$[[ inputs.docker-all ]]" == "true"' %}
workflow:
rules:
- if: '{{ is_manual }}'
variables:
wf_kind: manual
wf_prefix: '[MAN] '
wf_desc: '$CI_COMMIT_TITLE'
PKG_RELINFO: '$[[ inputs.release-desc ]]'
PKG_FIXUP: '$[[ inputs.release-fixup ]]'
- if: '{{ is_sched }}'
variables:
wf_kind: scheduled
wf_prefix: '[SCD] '
wf_desc: '$CI_COMMIT_TITLE'
- if: '{{ is_tag }}'
variables:
wf_kind: tag
wf_prefix: '[TAG] '
wf_desc: '$CI_COMMIT_TAG'
- if: '{{ is_push }}'
variables:
wf_kind: regular
wf_prefix: ''
wf_desc: '$CI_COMMIT_TITLE'
- if: '{{ is_stable }} && {{ is_release_commit }}'
variables:
wf_kind: release
wf_prefix: '[RELEASE] '
wf_desc: '$CI_COMMIT_BRANCH'
- if: '{{ is_release_commit }}'
variables:
wf_kind: release-candidate
wf_prefix: '[RC] '
wf_desc: '$CI_COMMIT_BRANCH'
- when: always
variables:
wf_kind: unknown
wf_prefix: '[$CI_PIPELINE_SOURCE] '
wf_desc: '$CI_COMMIT_TITLE'
name: '$wf_prefix$wf_desc'
# Note: We would love to just write "if: $[[ inputs.packages ]]"
# but that's impossible because the value is expected to be a string.
#
# Should be fixable by several lines in
# lib/gitlab/ci/pipeline/expression/statement.rb
# but I don't have time to do that contribution to gitlab now.
{%- macro rule(when, yesno) -%}
- if: '{{ when }}'
when: {% if yesno %}on_success{% else %}never{% endif %}
{%- endmacro -%}
{%- macro rdef(yesno) -%}
- when: {% if yesno %}on_success{% else %}never{% endif %}
{%- endmacro -%}
## Default rules for regular jobs
.default-rules:
# Manual, API and Scheduled jobs have an explicit input setting.
# Do not run anything unless explicitly requested for these.
{{ rule(is_manual, False) }}
{{ rule(is_api, False) }}
{{ rule(is_sched, False) }}
# Do not run anything for WIP commits
{{ rule(is_wip, False) }}
# Tags only happen on releases, don't run full automation
{{ rule(is_tag, False) }}
{{ rdef(True) }}
## Pipeline information dump
pipeline-infodump:
stage: consistency
image: registry.nic.cz/labs/bird:docbuilder
script:
- |
echo "### Variables ###"
{%- for VAR in [
"CI_JOB_ID",
"CI_COMMIT_SHA",
"CI_COMMIT_BRANCH",
"CI_COMMIT_TAG",
"CI_COMMIT_TITLE",
"CI_COMMIT_MESSAGE",
"CI_PIPELINE_SOURCE",
"CI_MERGE_REQUEST_IID",
"GITLAB_API_URL",
"wf_kind",
] %}
echo "\${{ VAR }} = ${{ VAR }}"
{%- endfor %}
echo
echo "### Inputs ###"
echo "Netlab: $[[ inputs.netlab ]]"
echo "Build: $[[ inputs.build ]]"
echo "Packages: $[[ inputs.packages ]]"
echo "Docker all: $[[ inputs.docker-all ]]"
echo "Docker regex: $[[ inputs.docker-regex ]]"
echo "Docker one: $[[ inputs.docker-one ]]"
## Pipeline consistency check
pipeline-uptodate:
stage: consistency
image: registry.nic.cz/labs/bird:docbuilder
script:
- autoreconf -i
- ./configure
- touch gitlab/template.yml.j2
- make gitlab-venv
- git status --porcelain
- git diff --exit-code
rules:
- !reference [ .default-rules ]
## Build Docker consistency check
docker-uptodate:
stage: consistency
image: registry.nic.cz/labs/bird:docbuilder
script:
- autoreconf -i
- ./configure
- touch gitlab/data.yml.j2
- make gitlab-docker VENV=1
- touch gitlab/docker/docbuilder/Dockerfile # Docbuilder is a static image, not rebuilt by the templates
- find gitlab/docker/ -type f -not -newer gitlab/data.yml.j2
- '[ "`find gitlab/docker/ -type f -not -newer gitlab/data.yml.j2 | wc -l`" == "0" ]'
- git status --porcelain
- git diff --exit-code
rules:
- !reference [ .default-rules ]
## Consistency checks for stable branches
commit-messages:
stage: consistency
image: registry.nic.cz/labs/bird:docbuilder
script:
- tools/git-check-commits
rules:
{{ rule(is_stable, True) }}
{{ rule(is_release_commit, True) }}
{{ rdef(False) }}
## Tag check
tag-collect:
stage: consistency
image: registry.nic.cz/labs/bird:docbuilder
script:
- python3 -m venv venv
- . venv/bin/activate
- pip3 install requests
- tools/git-check-tag-local $CI_COMMIT_TAG
- tools/git-check-tag-ci $CI_COMMIT_SHA
artifacts:
paths:
- obj/doc/bird-singlepage.html
- obj/doc/prog-singlepage.html
- bird-*.tar.gz
- pkg/pkgs/*
- pkg/srcpkgs/*
rules:
{{ rule(is_tag, True) }}
{{ rdef(False) }}
############################
## Docker builder rebuild ##
############################
# We are running all the build / packaging tests in Dockers (unless otherwise)
# and these are rules to build these docker images. These are expensive to run
# and should run only if needed.
#
# Modify the appropriate dockerfile to rebuild these images
.docker: &docker-build
stage: image
needs: [] # docker-uptodate maybe?
script:
- $DOCKER_CMD login -u gitlab-ci-token -p $CI_JOB_TOKEN registry.nic.cz
# Make sure we refresh the base image if it updates (eg. security updates, etc)
# If we do just the build, cache is always reused and the freshness of the
# base image is never checked. However, pull always asks and updates the
# image only if it changed ‒ therefore, the cache is used unless there's a
# change.
- $DOCKER_CMD pull `sed -ne 's/^FROM //p' "gitlab/docker/$IMG_NAME/Dockerfile"`
- $DOCKER_CMD build -t "bird:$IMG_NAME" "gitlab/docker/$IMG_NAME"
- $DOCKER_CMD tag "bird:$IMG_NAME" "$IMG_BASE:$IMG_NAME"
- $DOCKER_CMD push "$IMG_BASE:$IMG_NAME"
after_script:
- rm -rf "$HOME/.docker/$CI_JOB_ID/" # cleanup the credentials
tags:
# That's Docker in Docker
- dind
{% for docker in [ { "name": "docbuilder" } ] + distros %}
docker-{{ docker["name"] }}:
variables:
IMG_NAME: "{{ docker["name"] }}"
rules:
# Only rebuild if explicitly requested
- if: '{{ inputs_docker_all }}'
- if: '"{{ docker["name"] }}" =~ /$[[ inputs.docker-regex ]]/'
- if: '"{{ docker["name"] }}" == "$[[ inputs.docker-one ]]"'
{{ rdef(False) }}
<<: *docker-build
{% endfor %}
#####################################################
## Linux distro build tests inside Docker builders ##
#####################################################
## Build stage
#
# Now we compile and run unit tests ... in every single distribution.
# Every task needs its docker, see above.
.build-base-rules:
- if: '{{ inputs_build }}'
- if: '{{ inputs_packages }}'
- !reference [ .default-rules ]
.build: &build-base
stage: build
rules:
- !reference [ .build-base-rules ]
script:
- if [ "$CI_PIPELINE_SOURCE" == "merge_request_event" ]; then export BRANCH=mergerequest-$CI_MERGE_REQUEST_IID; else export BRANCH=$CI_COMMIT_BRANCH; fi
- tools/version && ( echo -n "BIRD version "; tools/version ) > version-expected
- |
STABLE_VERSION="`cat VERSION`"
if [ "$CI_COMMIT_MESSAGE" == "NEWS and version update
" ] || [ "$[[ inputs.release-fixup ]]" -gt "1" ]; then
if [ "${STABLE_VERSION}" == "`tools/version`" ]; then
echo "Stable version precheck OK"
else
echo "Stable version discrepancy: $STABLE_VERSION vs. $(tools/version)"
exit 1
fi
else
if grep -qF "BIRD version ${STABLE_VERSION}+branch" version-expected; then
true
else
echo -n "Commit $CI_COMMIT_SHA message $CI_COMMIT_MESSAGE expects version "
cat version-expected
exit 1
fi
fi
- |
if [ -n "$CROSSBUILD_ARCH" ]; then
dpkg-architecture -A $CROSSBUILD_ARCH > crossbuild.sh
. crossbuild.sh
export CONFIGURE_OPTIONS="--host=${DEB_TARGET_GNU_TYPE} ${CONFIGURE_OPTIONS}"
export CROSS_RUN=qemu-${CROSSBUILD_ARCH}
fi
- autoreconf
- ./configure CPPFLAGS="$CPPFLAGS" LDFLAGS="$LDFLAGS" ${CONFIGURE_OPTIONS}
# Detect which make is available
- MAKE=make
- which gmake 2>/dev/null >/dev/null && MAKE=gmake
- $MAKE VERBOSE=1
- $MAKE VERBOSE=1 TEST_RETRY_VERBOSE=1 check
# Build docs when tools are available
- if which linuxdoc pdflatex sgmlsasp >/dev/null ; then $MAKE docs ; fi
# Check that the reported version is the right one
- ${CROSS_RUN} ./bird --version |& grep -v 'Cannot disable transparent huge pages' | tee obj/version-built
- diff obj/version-built version-expected
.build-docker-linux-amd64: &build-docker-linux-amd64
<<: *build-base
tags:
- docker
- linux
- amd64
{% for dist in distros %}
build-{{dist["name"]}}:
<<: *build-docker-linux-amd64
needs:
- job: docker-{{ dist["name"] }}
optional: true
image: registry.nic.cz/labs/bird:{{ dist["name"] }}
{%- if 'variables' in dist %}
variables:
{{ dist["variables"] | to_yaml | indent(4, true) }}
{%- endif %}
{%- if "crossarch" in dist %}
{% for ca in dist.crossarch %}
crossbuild-{{ ca }}-{{ dist["name"] }}:
<<: *build-docker-linux-amd64
needs:
- job: docker-{{ dist["name"] }}
optional: true
image: registry.nic.cz/labs/bird:{{ dist["name"] }}
variables:
CROSSBUILD_ARCH: {{ ca }}
{%- if 'variables' in dist %}
{{ dist["variables"] | to_yaml | indent(4, true) }}
{%- endif %}
{% endfor %}
{%- endif %}
{% endfor %}
#######################################################
## A special task for preparing the release archives ##
#######################################################
build-release:
image: registry.nic.cz/labs/bird:docbuilder
needs:
- job: docker-docbuilder
optional: true
stage: build
tags:
- docker
- linux
script:
- if [ "$CI_PIPELINE_SOURCE" == "merge_request_event" ]; then export BRANCH=mergerequest-$CI_MERGE_REQUEST_IID; else export BRANCH=$CI_COMMIT_BRANCH; fi
- autoreconf
- ./configure --with-protocols= --disable-client
- make obj/doc/bird-singlepage.html obj/doc/prog-singlepage.html
- if grep 'PARSER FAILED ' obj/doc/bird-singlepage.html obj/doc/prog-singlepage.html; then echo "Documentation build is broken!"; false; fi
- tools/make-archive
artifacts:
paths:
- obj/doc/bird-singlepage.html
- obj/doc/prog-singlepage.html
- bird-*.tar.gz
expire_in: 1 day
rules: !reference [ .build-base-rules ]
# Packaging rules
# As we support some ancient versions of different distributions,
# we need to keep several different machineries. It's not so bad
# but it's bad nevertheless.
#
# We do NOT build separate documentation packages in these rules.
.pkg-base: &pkg-base
rules:
- if: '{{ inputs_packages }}'
{{ rule(is_tag, False) }}
{{ rule(is_release_commit, True) }}
{{ rule(not_stable, False) }}
- !reference [ .default-rules ]
.pkg-deb: &pkg-deb
<<: *pkg-base
stage: pkg
script:
- if [ "$CI_PIPELINE_SOURCE" == "merge_request_event" ]; then export BRANCH=mergerequest-$CI_MERGE_REQUEST_IID; else export BRANCH=$CI_COMMIT_BRANCH; fi
- tools/make-deb
artifacts:
paths:
- pkg/pkgs/*
- pkg/srcpkgs/*
.pkg-rpm: &pkg-rpm
<<: *pkg-base
stage: pkg
script:
- if [ "$CI_PIPELINE_SOURCE" == "merge_request_event" ]; then export BRANCH=mergerequest-$CI_MERGE_REQUEST_IID; else export BRANCH=$CI_COMMIT_BRANCH; fi
- STABLE_BUILDDIR=true tools/make-rpm
artifacts:
paths:
- pkg/pkgs/*
- pkg/srcpkgs/*
{% for dist in distros %}
pkg-{{ dist["name"] }}:
<<: *pkg-{{ dist["type"] }}
needs:
- job: build-{{ dist["name"] }}
artifacts: false
- job: build-release
image: registry.nic.cz/labs/bird:{{ dist["name"] }}
{%- if 'variables' in dist %}
variables:
{{ dist["variables"] | to_yaml | indent(4, true) }}
{%- endif %}
{%- if "crossarch" in dist %}
{% for ca in dist.crossarch %}
crosspkg-{{ ca }}-{{ dist["name"] }}:
<<: *pkg-{{ dist["type"] }}
needs:
- job: crossbuild-{{ ca }}-{{ dist["name"] }}
artifacts: false
- job: build-release
image: registry.nic.cz/labs/bird:{{ dist["name"] }}
variables:
CROSSBUILD_ARCH: {{ ca }}
{%- if 'variables' in dist %}
{{ dist["variables"] | to_yaml | indent(4, true) }}
{%- endif %}
{% endfor %}
{%- endif %}
{% endfor %}
## Package installability checks
.install-deb: &install-deb
<<: *pkg-base
stage: install
script:
# setup crossbuild architecture
- |
if [ -n "$CROSSBUILD_ARCH" ]; then
dpkg-architecture -A $CROSSBUILD_ARCH > crossbuild.sh
. crossbuild.sh
export CROSS_RUN=qemu-${CROSSBUILD_ARCH}
fi
# check that bird is _not_ installed now and no user or group bird exists
- |
if bird --version >/dev/null 2>&1; then
echo "Error: BIRD unexpectedly installed"
exit 1
fi
if id -g bird >/dev/null 2>&1; then
echo "Error: User group 'bird' unexpectedly exist before installation"
exit 1
fi
if id -u bird >/dev/null 2>&1; then
echo "Error: User 'bird' unexpectedly exist before installation"
exit 1
fi
# install packages
- find pkg/pkgs/ -type f -name '*.deb' '(' -ls -exec dpkg -i '{}' ';' ')'
# test that installation is successful
- ./tools/test-install "$CI_COMMIT_MESSAGE"
.install-rpm: &install-rpm
<<: *pkg-base
stage: install
script:
# check that bird is _not_ installed now and no user or group bird exists
- |
if bird --version >/dev/null 2>&1; then
echo "Error: BIRD unexpectedly installed"
exit 1
fi
if id -g bird >/dev/null 2>&1; then
echo "Error: User group 'bird' exist before installation"
exit 1
fi
if id -u bird >/dev/null 2>&1; then
echo "Error: User 'bird' exist before installation"
exit 1
fi
# install packages
- find pkg/pkgs/ -type f -name '*.rpm' '(' -ls -exec $RPM_INSTALL_CMD '{}' ';' ')'
# test that installation is successful
- ./tools/test-install "$CI_COMMIT_MESSAGE"
{% for dist in distros %}
install-{{ dist["name"] }}:
<<: *install-{{ dist["type"] }}
needs:
- job: pkg-{{ dist["name"] }}
image: registry.nic.cz/labs/bird:{{ dist["name"] }}
variables:
{%- if dist["name"][:12] == "opensuse-16." %}
RPM_INSTALL_CMD: zypper --non-interactive --no-gpg-checks in
{%- elif dist["type"] == "rpm" %}
RPM_INSTALL_CMD: rpm -i
{%- endif %}
{%- for ca in dist.crossarch %}
crossinstall-{{ ca }}-{{ dist["name"] }}:
<<: *install-{{ dist["type"] }}
needs:
- job: crosspkg-{{ ca }}-{{ dist["name"] }}
image: registry.nic.cz/labs/bird:{{ dist["name"] }}
variables:
{%- if dist["name"][:12] == "opensuse-16." %}
RPM_INSTALL_CMD: zypper --non-interactive --no-gpg-checks in
{%- elif dist["type"] == "rpm" %}
RPM_INSTALL_CMD: rpm -i
{%- endif %}
CROSSBUILD_ARCH: {{ ca }}
{%- endfor %}
{% endfor %}
###################################
## Non-linux build tests in QEMU ##
###################################
.build-birdlab-base: &build-birdlab-base
<<: *build-base
stage: build
needs: []
# script:
# - export BRANCH=$CI_COMMIT_BRANCH
# - autoreconf
# - ./configure $CONFIGURE_OPTIONS
# - gmake
# - gmake check
{% for test in birdlab %}
build-birdlab-{{ test['name'] }}:
<<: *build-birdlab-base
{%- if 'variables' in test %}
variables:
{{ test['variables'] | to_yaml | indent(4, true) }}{%- endif %}
tags:
- birdlab-{{ test['dist'] if 'dist' in test else test['name'] }}
- amd64
{% endfor %}
#########################
## Partial build tests ##
#########################
.build-only: &build-only
<<: *build-docker-linux-amd64
image: registry.nic.cz/labs/bird:{{ partial_build_image["name"] }}
needs:
- job: docker-{{ partial_build_image["name"] }}
optional: true
{% for test in partial_build %}
partial-build-linux-{{ test["protocols"] }}:
<<: *build-only
variables:
CONFIGURE_OPTIONS: --with-protocols={{ test["protocols"] }}
{% endfor %}
################################
## Netlab functionality tests ##
################################
.netlab-rules: &netlab-rules
rules:
- if: '{{ inputs_netlab }}'
- !reference [ .default-rules ]
build-netlab:
<<: *netlab-rules
stage: build
needs: []
variables:
BDIR: build-netlab
tags:
- netlab
- amd64
script:
- if [ "$CI_PIPELINE_SOURCE" == "merge_request_event" ]; then export BRANCH=mergerequest-$CI_MERGE_REQUEST_IID; else export BRANCH=$CI_COMMIT_BRANCH; fi
- autoreconf
- mkdir $BDIR
- cd $BDIR
- ../configure
- make
artifacts:
paths:
- $BDIR/bird
- $BDIR/birdc
expire_in: 2 hours
.netlab-test: &test-base
<<: *netlab-rules
stage: test
needs: [build-netlab]
tags:
- netlab
- amd64
script:
- sudo rm -rf netlab-failure
- DIR=$(pwd)
- cd $TOOLS_DIR
- sudo git clean -fx
- sudo git checkout -f master
- git pull --ff-only
- "mv $DIR/build-netlab/* netlab/common/"
- ln -s $STAYRTR_BINARY netlab/common/stayrtr
- cd netlab
- sudo ./stop
- ulimit -f 1048576 # Protect the filesystem from overflowing by log bloat
- sudo ./runtest -s v2 -m check $TEST_NAME
after_script:
- DIR=$(pwd)
- cd $TOOLS_DIR/netlab
- sudo ./stop || echo "Stop failed"
- "mkdir -p $DIR/netlab-failure"
- git status --porcelain > $DIR/netlab-failure.log
- for f in $(git status --porcelain | sed -rn 's#^.[^DRT] netlab/##p'); do mkdir -p $DIR/netlab-failure/$(dirname $f); sudo chmod a+rw $f; sudo mv $f $DIR/netlab-failure/$(dirname $f); done
artifacts:
when: on_failure
untracked: true
{% for test in netlab %}
test-{{ test["name"] }}:
<<: *test-base
variables:
TEST_NAME: cf-{{ test["name"] }}
{% endfor %}
bird2-2.17.5/lib/ 0000775 0000000 0000000 00000000000 15211753245 0013363 5 ustar 00root root 0000000 0000000 bird2-2.17.5/lib/Doc 0000664 0000000 0000000 00000000306 15211753245 0014012 0 ustar 00root root 0000000 0000000 H Library functions
S ip.c
S lists.c
S checksum.c bitops.c patmatch.c printf.c xmalloc.c tbf.c
S mac.c
S flowspec.c
D resource.sgml
S resource.c
S mempool.c
S slab.c
S event.c
S ../sysdep/unix/io.c
bird2-2.17.5/lib/Makefile 0000664 0000000 0000000 00000001123 15211753245 0015020 0 ustar 00root root 0000000 0000000 src := bitmap.c bitops.c blake2s.c blake2b.c checksum.c event.c flowspec.c idm.c ip.c lists.c mac.c md5.c mempool.c net.c patmatch.c printf.c resource.c sha1.c sha256.c sha512.c slab.c slists.c strtoul.c tbf.c timer.c xmalloc.c
obj := $(src-o-files)
$(all-daemon)
tests_src := bitmap_test.c heap_test.c buffer_test.c event_test.c flowspec_test.c bitops_test.c patmatch_test.c fletcher16_test.c slist_test.c checksum_test.c lists_test.c mac_test.c ip_test.c hash_test.c printf_test.c slab_test.c
tests_targets := $(tests_targets) $(tests-target-files)
tests_objs := $(tests_objs) $(src-o-files)
bird2-2.17.5/lib/alloca.h 0000664 0000000 0000000 00000000674 15211753245 0014776 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Alloca.h
*
* (c) 2004 Ondrej Filip
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_ALLOCA_H_
#define _BIRD_ALLOCA_H_
#ifdef HAVE_ALLOCA_H
#include
#else
#include
#endif
#define allocz(len) ({ void *_x = alloca(len); memset(_x, 0, len); _x; })
#define alloca_copy(src,len) ({ void *_x = alloca(len); memcpy(_x, src, len); })
#endif
bird2-2.17.5/lib/birdlib.h 0000664 0000000 0000000 00000015375 15211753245 0015156 0 ustar 00root root 0000000 0000000 /*
* BIRD Library
*
* (c) 1998--2004 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_BIRDLIB_H_
#define _BIRD_BIRDLIB_H_
#include "lib/alloca.h"
#include
#include
#include
/* Ugly structure offset handling macros */
#define OFFSETOF(s, i) ((size_t) &((s *)0)->i)
#define SKIP_BACK(s, i, p) ((s *)((char *)p - OFFSETOF(s, i)))
#define BIRD_ALIGN(s, a) (((s)+a-1)&~(a-1))
#define CPU_STRUCT_ALIGN (alignof(max_align_t))
/* Utility macros */
#define MIN_(a,b) (((a)<(b))?(a):(b))
#define MAX_(a,b) (((a)>(b))?(a):(b))
#define CLAMP(a,l,h) (((a)<(l)) ? (l) : (((a)>(h)) ? (h) : (a)))
#ifndef PARSER
#undef MIN
#undef MAX
#define MIN(a,b) MIN_(a,b)
#define MAX(a,b) MAX_(a,b)
#endif
#define ROUND_DOWN_POW2(a,b) ((a) & ~((b)-1))
#define ROUND_UP_POW2(a,b) (((a)+((b)-1)) & ~((b)-1))
#define U64(c) UINT64_C(c)
#define ABS(a) ((a)>=0 ? (a) : -(a))
#define DELTA(a,b) (((a)>=(b))?(a)-(b):(b)-(a))
#define ARRAY_SIZE(a) (sizeof(a)/sizeof(*(a)))
#define BYTES(n) ((((uint) (n)) + 7) / 8)
#define CALL(fn, args...) ({ if (fn) fn(args); })
#define ADVANCE(w, r, l) ({ r -= (l); w += (l); })
static inline int uint_cmp(uint i1, uint i2)
{ return (int)(i1 > i2) - (int)(i1 < i2); }
static inline int u64_cmp(u64 i1, u64 i2)
{ return (int)(i1 > i2) - (int)(i1 < i2); }
/* Bitfield macros */
/* b is u32 array (or ptr), l is size of it in bits (multiple of 32), p is 0..(l-1) */
#define BIT32_VAL(p) (((u32) 1) << ((p) % 32))
#define BIT32_TEST(b,p) ((b)[(p)/32] & BIT32_VAL(p))
#define BIT32_SET(b,p) ((b)[(p)/32] |= BIT32_VAL(p))
#define BIT32_CLR(b,p) ((b)[(p)/32] &= ~BIT32_VAL(p))
#define BIT32_ZERO(b,l) memset((b), 0, (l)/8)
/* The same, but counting bits from MSB */
#define BIT32R_VAL(p) ((((u32) 1) << 31) >> ((p) % 32))
#define BIT32R_TEST(b,p) ((b)[(p)/32] & BIT32R_VAL(p))
#define BIT32R_SET(b,p) ((b)[(p)/32] |= BIT32R_VAL(p))
#define BIT32R_CLR(b,p) ((b)[(p)/32] &= ~BIT32R_VAL(p))
#define BIT32R_ZERO(b,l) memset((b), 0, (l)/8)
#ifndef NULL
#define NULL ((void *) 0)
#endif
/* Macros for gcc attributes */
#define NORET __attribute__((noreturn))
#define UNUSED __attribute__((unused))
#define PACKED __attribute__((packed))
#define NONNULL(...) __attribute__((nonnull(__VA_ARGS__)))
#define ALLOC_SIZE(...) __attribute__((alloc_size(__VA_ARGS__)))
#if __GNUC__ >= 10
#define ACCESS_READ(...) __attribute__((access(read_only, __VA_ARGS__)))
#define ACCESS_WRITE(...) __attribute__((access(write_only, __VA_ARGS__)))
#define ACCESS_RW(...) __attribute__((access(read_write, __VA_ARGS__)))
#else
#define ACCESS_READ(...)
#define ACCESS_WRITE(...)
#define ACCESS_RW(...)
#endif
#define STATIC_ASSERT(EXP) _Static_assert(EXP, #EXP)
#define STATIC_ASSERT_MSG(EXP,MSG) _Static_assert(EXP, MSG)
#ifndef HAVE_THREAD_LOCAL
#define _Thread_local
#endif
/* Microsecond time */
typedef s64 btime;
//typedef s64 bird_clock_t;
#define S_ * (btime) 1000000
#define MS_ * (btime) 1000
#define US_ * (btime) 1
#define TO_S /1000000
#define TO_MS /1000
#define TO_US /1
#ifndef PARSER
#define S S_
#define MS MS_
#define US US_
#define NS /1000
#endif
#define TIME_INFINITY ((s64) 0x7fffffffffffffff)
/* Rate limiting */
struct tbf {
btime timestamp; /* Last update */
u64 count; /* Available micro-tokens */
u16 burst; /* Max number of tokens */
u16 rate; /* Rate of replenishment (tokens / sec) */
u32 drop; /* Number of failed request since last successful */
};
/* Default TBF values for rate limiting log messages */
#define TBF_DEFAULT_LOG_LIMITS { .rate = 1, .burst = 5 }
int tbf_limit(struct tbf *f);
/* Logging and dying */
typedef struct buffer {
byte *start;
byte *pos;
byte *end;
} buffer;
#define STACK_BUFFER_INIT(buf,size) \
do { \
buf.start = alloca(size); \
buf.pos = buf.start; \
buf.end = buf.start + size; \
} while(0)
#define LOG_BUFFER_INIT(buf) \
STACK_BUFFER_INIT(buf, LOG_BUFFER_SIZE)
#define LOG_BUFFER_SIZE 1024
#define log log_msg
void log_commit(int class, buffer *buf);
void log_msg(const char *msg, ...);
void log_rl(struct tbf *rl, const char *msg, ...);
void die(const char *msg, ...) NORET;
void bug(const char *msg, ...) NORET;
void vlog(int class, const char *msg, va_list args);
#define L_DEBUG "\001" /* Debugging messages */
#define L_TRACE "\002" /* Protocol tracing */
#define L_INFO "\003" /* Informational messages */
#define L_REMOTE "\004" /* Remote protocol errors */
#define L_WARN "\005" /* Local warnings */
#define L_ERR "\006" /* Local errors */
#define L_AUTH "\007" /* Authorization failed etc. */
#define L_FATAL "\010" /* Fatal errors */
#define L_BUG "\011" /* BIRD bugs */
#define L_MAX 10
void debug(const char *msg, ...); /* Printf to debug output */
void debug_safe(const char *msg); /* Printf to debug output, async-safe */
/* Debugging */
#if defined(LOCAL_DEBUG) || defined(GLOBAL_DEBUG)
#define DBG(x, y...) debug(x, ##y)
#else
#define DBG(x, y...) do { } while(0)
#endif
#define ASSERT_DIE(x) do { if (!(x)) bug("Assertion '%s' failed at %s:%d", #x, __FILE__, __LINE__); } while(0)
#define EXPENSIVE_CHECK(x) /* intentionally left blank */
#ifdef DEBUGGING
#define ASSERT(x) ASSERT_DIE(x)
#define ASSUME(x) ASSERT_DIE(x)
#ifdef ENABLE_EXPENSIVE_CHECKS
#undef EXPENSIVE_CHECK
#define EXPENSIVE_CHECK(x) ASSERT_DIE(x)
#endif
#else
#define ASSERT(x) do { if (!(x)) log(L_BUG "Assertion '%s' failed at %s:%d", #x, __FILE__, __LINE__); } while(0)
#define ASSUME(x) /* intentionally left blank */
#endif
#ifdef DEBUGGING
asm(
".pushsection \".debug_gdb_scripts\", \"MS\",@progbits,1\n"
".byte 1\n" /* Python */
".asciz \"bird-gdb.py\"\n"
".popsection\n"
);
#endif
/* Pseudorandom numbers */
u32 random_u32(void);
void random_init(void);
void random_bytes(void *buf, size_t size);
/* Hashing */
/* Constant parameter for non-parametrized hashes */
#define HASH_PARAM 2902958171u
/* Precomputed powers of HASH_PARAM */
#define HASH_PARAM1 ((u64) HASH_PARAM)
#define HASH_PARAM2 (HASH_PARAM1 * HASH_PARAM)
#define HASH_PARAM3 (HASH_PARAM2 * HASH_PARAM)
#define HASH_PARAM4 (HASH_PARAM3 * HASH_PARAM)
/* Reduce intermediate 64-bit value to final 32-bit value */
static inline u32 hash_value(u64 a)
{ return ((u32) a) ^ ((u32) (a >> 32)); }
static inline u64 u32_hash0(u32 v, u32 p, u64 acc)
{ return (acc + v) * p; }
static inline u64 u64_hash0(u64 v, u32 p, u64 acc)
{ return u32_hash0(v >> 32, p, u32_hash0(v, p, acc)); }
static inline u32 u64_hash(u64 v)
{ return hash_value(u64_hash0(v, HASH_PARAM, 0)); }
/* Dumping */
struct dump_request {
u64 size;
btime begin;
uint indent, offset;
void (*write)(struct dump_request *, const char *fmt, ...);
void (*report)(struct dump_request *, int state, const char *fmt, ...);
};
#define RDUMP(...) dreq->write(dreq, __VA_ARGS__)
#endif
bird2-2.17.5/lib/bitmap.c 0000664 0000000 0000000 00000017517 15211753245 0015016 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Bitmaps
*
* (c) 2019 Ondrej Zajicek
* (c) 2019 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include
#include "nest/bird.h"
#include "lib/bitmap.h"
#include "lib/bitops.h"
#include "lib/resource.h"
/*
* Basic bitmap
*/
void
bmap_init(struct bmap *b, pool *p, uint size)
{
b->size = BIRD_ALIGN(size, 4);
b->data = mb_allocz(p, b->size);
}
void
bmap_reset(struct bmap *b, uint size)
{
b->size = BIRD_ALIGN(size, 4);
memset(b->data, 0, b->size);
}
void
bmap_grow(struct bmap *b, uint need)
{
uint size = b->size * 2;
while (size < need)
size *= 2;
uint old_size = b->size;
b->size = size;
b->data = mb_realloc(b->data, b->size);
ASSERT(size >= old_size);
memset(b->data + (old_size / 4), 0, size - old_size);
}
void
bmap_free(struct bmap *b)
{
mb_free(b->data);
b->size = 0;
b->data = NULL;
}
/*
* Hierarchical bitmap
*/
#define B256_SIZE(b) BIRD_ALIGN(b, 32)
#define B256_STEP(b) (BIRD_ALIGN(b, 8192) >> 8)
void
hmap_init(struct hmap *b, pool *p, uint size)
{
b->size[0] = B256_SIZE(size);
b->size[1] = B256_STEP(b->size[0]);
b->size[2] = B256_STEP(b->size[1]);
b->size[3] = sizeof(b->root);
b->data[0] = mb_allocz(p, b->size[0]);
b->data[1] = mb_allocz(p, b->size[1]);
b->data[2] = mb_allocz(p, b->size[2]);
b->data[3] = b->root;
memset(b->root, 0, sizeof(b->root));
}
static void
hmap_grow(struct hmap *b, uint need)
{
uint size = b->size[0] * 2;
while (size < need)
size *= 2;
for (uint i = 0; i < 3; i++)
{
uint old_size = b->size[i];
b->size[i] = size;
b->data[i] = mb_realloc(b->data[i], b->size[i]);
ASSERT(size >= old_size);
memset(b->data[i] + (old_size / 4), 0, size - old_size);
size = B256_STEP(size);
}
}
void
hmap_free(struct hmap *b)
{
mb_free(b->data[0]);
mb_free(b->data[1]);
mb_free(b->data[2]);
memset(b, 0, sizeof(struct hmap));
}
static inline int
b256_and(u32 *p)
{
for (int i = 0; i < 8; i++)
if (~p[i])
return 0;
return 1;
}
void
hmap_set(struct hmap *b, uint n)
{
if (n >= hmap_max(b))
hmap_grow(b, n/8 + 1);
for (int i = 0; i < 4; i++)
{
BIT32_SET(b->data[i], n);
n = n >> 8;
/* Continue if all bits in 256-bit block are set */
if (! b256_and(b->data[i] + 8*n))
break;
}
}
void
hmap_clear(struct hmap *b, uint n)
{
if (n >= hmap_max(b))
return;
for (int i = 0; i < 4; i++)
{
BIT32_CLR(b->data[i], n);
n = n >> 8;
}
}
static inline int
b256_first_zero(u32 *p)
{
for (int i = 0; i < 8; i++)
if (~p[i])
return 32*i + u32_ctz(~p[i]);
return 256;
}
u32
hmap_first_zero(struct hmap *b)
{
u32 n = 0;
for (int i = 3; i >= 0; i--)
{
if (32*n >= b->size[i])
return hmap_max(b);
u32 *p = b->data[i] + 8*n;
n = (n << 8) + b256_first_zero(p);
}
return n;
}
void
hmap_check(struct hmap *b)
{
for (int i = 0; i < 2; i++)
{
int max = b->size[i] / 32;
for (int j = 0; j < max; j++)
{
int x = b256_and(b->data[i] + 8*j);
int y = !!BIT32_TEST(b->data[i+1], j);
if (x != y)
bug("Inconsistent data on %d:%d (%d vs %d)", i, j, x, y);
}
}
}
/*
* Indirect bitmap for MPLS labels (20 bit range)
*/
void
lmap_init(struct lmap *b, pool *p)
{
b->slab = sl_new(p, 128);
b->size = 8;
b->data = mb_allocz(p, b->size * sizeof(u32 *));
b->root = sl_allocz(b->slab);
}
static void
lmap_grow(struct lmap *b, uint need)
{
uint old_size = b->size;
while (b->size < need)
b->size *= 2;
b->data = mb_realloc(b->data, b->size * sizeof(u32 *));
memset(b->data + old_size, 0, (b->size - old_size) * sizeof(u32 *));
}
void
lmap_free(struct lmap *b)
{
rfree(b->slab);
mb_free(b->data);
memset(b, 0, sizeof(struct lmap));
}
static inline int
b1024_and(u32 *p)
{
for (int i = 0; i < 32; i++)
if (~p[i])
return 0;
return 1;
}
static inline int
b1024_or(u32 *p)
{
for (int i = 0; i < 32; i++)
if (p[i])
return 1;
return 0;
}
int
lmap_test(struct lmap *b, uint n)
{
uint n0 = n >> 10;
uint n1 = n & 0x3ff;
return (n0 < b->size) && b->data[n0] && BIT32_TEST(b->data[n0], n1);
}
void
lmap_set(struct lmap *b, uint n)
{
uint n0 = n >> 10;
uint n1 = n & 0x3ff;
if (n0 >= b->size)
lmap_grow(b, n0 + 1);
if (! b->data[n0])
b->data[n0] = sl_allocz(b->slab);
BIT32_SET(b->data[n0], n1);
if (b1024_and(b->data[n0]))
BIT32_SET(b->root, n0);
}
void
lmap_clear(struct lmap *b, uint n)
{
uint n0 = n >> 10;
uint n1 = n & 0x3ff;
if (n0 >= b->size)
return;
if (! b->data[n0])
return;
BIT32_CLR(b->data[n0], n1);
BIT32_CLR(b->root, n0);
if (!b1024_or(b->data[n0]))
{
sl_free(b->data[n0]);
b->data[n0] = NULL;
}
}
static inline int
b1024_first_zero(u32 *p)
{
for (int i = 0; i < 32; i++)
if (~p[i])
return 32*i + u32_ctz(~p[i]);
return 1024;
}
uint
lmap_first_zero(struct lmap *b)
{
uint n0 = b1024_first_zero(b->root);
uint n1 = ((n0 < b->size) && b->data[n0]) ?
b1024_first_zero(b->data[n0]) : 0;
return (n0 << 10) + n1;
}
static uint
b1024_first_zero_in_range(u32 *p, uint lo, uint hi)
{
uint lo0 = lo >> 5;
uint lo1 = lo & 0x1f;
uint hi0 = hi >> 5;
uint hi1 = hi & 0x1f;
u32 mask = (1 << lo1) - 1;
u32 val;
for (uint i = lo0; i < hi0; i++)
{
val = p[i] | mask;
mask = 0;
if (~val)
return 32*i + u32_ctz(~val);
}
if (hi1)
{
mask |= ~((1u << hi1) - 1);
val = p[hi0] | mask;
if (~val)
return 32*hi0 + u32_ctz(~val);
}
return hi;
}
uint
lmap_first_zero_in_range(struct lmap *b, uint lo, uint hi)
{
uint lo0 = lo >> 10;
uint lo1 = lo & 0x3ff;
uint hi0 = hi >> 10;
uint hi1 = hi & 0x3ff;
if (lo1)
{
uint max = (lo0 == hi0) ? hi1 : 1024;
uint n0 = lo0;
uint n1 = ((n0 < b->size) && b->data[n0]) ?
b1024_first_zero_in_range(b->data[n0], lo1, max) : lo1;
if (n1 < 1024)
return (n0 << 10) + n1;
lo0++;
lo1 = 0;
}
if (lo0 < hi0)
{
uint n0 = b1024_first_zero_in_range(b->root, lo0, hi0);
if (n0 < hi0)
{
uint n1 = ((n0 < b->size) && b->data[n0]) ?
b1024_first_zero(b->data[n0]) : 0;
return (n0 << 10) + n1;
}
}
if (hi1)
{
uint n0 = hi0;
uint n1 = ((n0 < b->size) && b->data[n0]) ?
b1024_first_zero_in_range(b->data[n0], 0, hi1) : 0;
return (n0 << 10) + n1;
}
return hi;
}
static inline int
b1024_last_one(u32 *p)
{
for (int i = 31; i >= 0; i--)
if (p[i])
return 32*i + (31 - u32_clz(p[i]));
return 1024;
}
static uint
b1024_last_one_in_range(u32 *p, uint lo, uint hi)
{
uint lo0 = lo >> 5;
uint lo1 = lo & 0x1f;
uint hi0 = hi >> 5;
uint hi1 = hi & 0x1f;
u32 mask = (1u << hi1) - 1;
u32 val;
for (int i = hi0; i > (int) lo0; i--)
{
val = p[i] & mask;
mask = ~0;
if (val)
return 32*i + (31 - u32_clz(val));
}
{
mask &= ~((1u << lo1) - 1);
val = p[lo0] & mask;
if (val)
return 32*lo0 + (31 - u32_clz(val));
}
return hi;
}
uint
lmap_last_one_in_range(struct lmap *b, uint lo, uint hi)
{
uint lo0 = lo >> 10;
uint lo1 = lo & 0x3ff;
uint hi0 = hi >> 10;
uint hi1 = hi & 0x3ff;
if (hi1 && (hi0 < b->size) && b->data[hi0])
{
uint min = (lo0 == hi0) ? lo1 : 0;
uint n0 = hi0;
uint n1 = b1024_last_one_in_range(b->data[n0], min, hi1);
if (n1 < hi1)
return (n0 << 10) + n1;
}
for (int i = (int)MIN(hi0, b->size) - 1; i >= (int) lo0; i--)
{
if (! b->data[i])
continue;
uint n0 = i;
uint n1 = b1024_last_one(b->data[n0]);
if ((n0 == lo0) && (n1 < lo1))
return hi;
return (n0 << 10) + n1;
}
return hi;
}
void
lmap_check(struct lmap *b)
{
for (int i = 0; i < (int) b->size; i++)
{
int x = b->data[i] && b1024_and(b->data[i]);
int y = !!BIT32_TEST(b->root, i);
if (x != y)
bug("Inconsistent data on %d (%d vs %d)", i, x, y);
}
}
bird2-2.17.5/lib/bitmap.h 0000664 0000000 0000000 00000003561 15211753245 0015015 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Bitmaps
*
* (c) 2019 Ondrej Zajicek
* (c) 2019 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_BITMAP_H_
#define _BIRD_BITMAP_H_
struct bmap
{
u32 size;
u32 *data;
};
void bmap_init(struct bmap *b, pool *p, uint size);
void bmap_reset(struct bmap *b, uint size);
void bmap_grow(struct bmap *b, uint need);
void bmap_free(struct bmap *b);
static inline uint bmap_max(struct bmap *b)
{ return 8 * b->size; }
static inline int bmap_test(struct bmap *b, uint n)
{ return (n < bmap_max(b)) && BIT32_TEST(b->data, n); }
static inline void bmap_set(struct bmap *b, uint n)
{
if (n >= bmap_max(b)) bmap_grow(b, n/8 + 1);
BIT32_SET(b->data, n);
}
static inline void bmap_clear(struct bmap *b, uint n)
{
if (n >= bmap_max(b)) return;
BIT32_CLR(b->data, n);
}
struct hmap
{
u32 size[4];
u32 *data[4];
u32 root[8];
};
static inline uint hmap_max(struct hmap *b)
{ return 8 * b->size[0]; }
static inline int hmap_test(struct hmap *b, uint n)
{ return (n < hmap_max(b)) && BIT32_TEST(b->data[0], n); }
void hmap_init(struct hmap *b, pool *p, uint size);
void hmap_free(struct hmap *b);
void hmap_set(struct hmap *b, uint n);
void hmap_clear(struct hmap *b, uint n);
u32 hmap_first_zero(struct hmap *b);
void hmap_check(struct hmap *b);
struct lmap
{
slab *slab;
uint size;
u32 **data;
u32 *root;
};
static inline uint lmap_max(struct lmap *b)
{ return b->size << 10; }
void lmap_init(struct lmap *b, pool *p);
void lmap_free(struct lmap *b);
int lmap_test(struct lmap *b, uint n);
void lmap_set(struct lmap *b, uint n);
void lmap_clear(struct lmap *b, uint n);
uint lmap_first_zero(struct lmap *b);
uint lmap_first_zero_in_range(struct lmap *b, uint lo, uint hi);
uint lmap_last_one_in_range(struct lmap *b, uint lo, uint hi);
void lmap_check(struct lmap *b);
#endif
bird2-2.17.5/lib/bitmap_test.c 0000664 0000000 0000000 00000011342 15211753245 0016043 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Bitmap Tests
*
* (c) 2019 Ondrej Zajicek
* (c) 2019 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "sysdep/config.h"
#include "lib/bitmap.h"
#define MAX_NUM (1 << 20)
#define MAX_SET (1 << 19)
#define MAX_CLR (1 << 17)
#define STEP_NUM 1000
#define STEP_SET 1000
#define STEP_CLR 500
static int
t_bmap_set_clear_random(void)
{
struct bmap b;
bmap_init(&b, &root_pool, 1024);
char expected[MAX_NUM] = {};
uint i, n;
for (i = 0; i < MAX_SET; i++)
{
do n = bt_random() % MAX_NUM;
while (expected[n]);
bmap_set(&b, n);
expected[n] = 1;
}
for (i = 0; i < MAX_CLR; i++)
{
do n = bt_random() % MAX_NUM;
while (!expected[n]);
bmap_clear(&b, n);
expected[n] = 0;
}
for (i = 0; i < MAX_NUM; i++)
if (bmap_test(&b, i) != expected[i])
bt_abort_msg("Bitmap mismatch on %d (should be %d %d)", i, bmap_test(&b, i), expected[i]);
return 1;
}
static int
t_hmap_set_clear_random(void)
{
struct hmap b;
hmap_init(&b, &root_pool, 1024);
char expected[MAX_NUM] = {};
uint i, n;
for (i = 0; i < MAX_SET; i++)
{
do n = bt_random() % MAX_NUM;
while (expected[n]);
hmap_set(&b, n);
expected[n] = 1;
}
hmap_check(&b);
for (i = 0; i < MAX_CLR; i++)
{
do n = bt_random() % MAX_NUM;
while (!expected[n]);
hmap_clear(&b, n);
expected[n] = 0;
}
hmap_check(&b);
for (i = 0; i < MAX_NUM; i++)
if (hmap_test(&b, i) != expected[i])
bt_abort_msg("Bitmap mismatch on %d (should be %d %d)", i, hmap_test(&b, i), expected[i]);
for (i = 0; 1; i++)
{
n = hmap_first_zero(&b);
bt_assert(n >= i);
bt_assert(n <= MAX_NUM);
for (; i < n; i++)
bt_assert(expected[i]);
if (n == MAX_NUM)
break;
bt_assert(!expected[i]);
hmap_set(&b, n);
}
hmap_check(&b);
return 1;
}
static int
t_hmap_set_clear_fill(void)
{
struct hmap b;
hmap_init(&b, &root_pool, 1024);
char expected[MAX_NUM] = {};
uint i, j, n, max = 0;
for (i = 0; i < STEP_NUM; i++)
{
uint last = 0;
uint step_set = bt_random() % STEP_SET;
uint step_clr = bt_random() % STEP_CLR;
for (j = 0; j < step_set; j++)
{
n = hmap_first_zero(&b);
bt_assert(n > last || !last);
bt_assert(n < MAX_NUM);
if (!last)
last = n;
for (; last < n; last++)
bt_assert(expected[last]);
bt_assert(!expected[n]);
hmap_set(&b, n);
expected[n] = 1;
max = MAX(max, n);
}
for (j = 0; j < step_clr; j++)
{
uint k = 0;
do n = bt_random() % max;
while (!expected[n] && (k++ < 8));
if (!expected[n])
continue;
hmap_clear(&b, n);
expected[n] = 0;
}
}
for (i = 0; i < MAX_NUM; i++)
if (hmap_test(&b, i) != expected[i])
bt_abort_msg("Bitmap mismatch on %d (should be %d %d)", i, hmap_test(&b, i), expected[i]);
hmap_check(&b);
return 1;
}
static int
t_lmap_set_clear_fill(void)
{
struct lmap b;
lmap_init(&b, &root_pool);
char expected[MAX_NUM] = {};
uint i, j, n;
for (i = 0; i < STEP_NUM; i++)
{
uint last = 0;
uint lo = bt_random() % (1 << 19);
uint hi = lo + 2 * STEP_SET;
uint step_set = bt_random() % STEP_SET;
uint step_clr = bt_random() % STEP_CLR;
for (j = 0; j < step_set; j++)
{
n = lmap_first_zero_in_range(&b, lo, hi);
bt_assert(n >= lo);
bt_assert(n <= hi);
for (last = lo; last < n; last++)
bt_assert(expected[last]);
if (n >= hi)
break;
bt_assert(!expected[n]);
lmap_set(&b, n);
expected[n] = 1;
}
for (j = 0; j < step_clr; j++)
{
n = lo + bt_random() % (step_set + 1);
if (!expected[n])
continue;
lmap_clear(&b, n);
expected[n] = 0;
}
{
n = lmap_last_one_in_range(&b, lo, hi);
bt_assert(n >= lo);
bt_assert(n <= hi);
for (last = n + 1; last < hi; last++)
bt_assert(!expected[last]);
if (n < hi)
bt_assert(expected[n]);
}
}
uint cnt = 0;
for (i = 0; i < MAX_NUM; i++)
{
if (lmap_test(&b, i) != expected[i])
bt_abort_msg("Bitmap mismatch on %d (should be %d %d)", i, lmap_test(&b, i), expected[i]);
if (expected[i])
cnt++;
}
// bt_log("Total %u", cnt);
lmap_check(&b);
return 1;
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_bmap_set_clear_random, "BMap - random sequence of sets / clears");
bt_test_suite(t_hmap_set_clear_random, "HMap - random sequence of sets / clears");
bt_test_suite(t_hmap_set_clear_fill, "HMap - linear sets and random clears");
bt_test_suite(t_lmap_set_clear_fill, "LMap - linear sets and random clears");
return bt_exit_value();
}
bird2-2.17.5/lib/bitops.c 0000664 0000000 0000000 00000003252 15211753245 0015031 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Generic Bit Operations
*
* (c) 1998 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "nest/bird.h"
#include "bitops.h"
/**
* u32_mkmask - create a bit mask
* @n: number of bits
*
* u32_mkmask() returns an unsigned 32-bit integer which binary
* representation consists of @n ones followed by zeroes.
*/
u32
u32_mkmask(uint n)
{
return n ? ~((1 << (32 - n)) - 1) : 0;
}
/**
* u32_masklen - calculate length of a bit mask
* @x: bit mask
*
* This function checks whether the given integer @x represents
* a valid bit mask (binary representation contains first ones, then
* zeroes) and returns the number of ones or 255 if the mask is invalid.
*/
uint
u32_masklen(u32 x)
{
int l = 0;
u32 n = ~x;
if (n & (n+1)) return 255;
if (x & 0x0000ffff) { x &= 0x0000ffff; l += 16; }
if (x & 0x00ff00ff) { x &= 0x00ff00ff; l += 8; }
if (x & 0x0f0f0f0f) { x &= 0x0f0f0f0f; l += 4; }
if (x & 0x33333333) { x &= 0x33333333; l += 2; }
if (x & 0x55555555) l++;
if (x & 0xaaaaaaaa) l++;
return l;
}
/**
* u32_log2 - compute a binary logarithm.
* @v: number
*
* This function computes a integral part of binary logarithm of given
* integer @v and returns it. The computed value is also an index of the
* most significant non-zero bit position.
*/
u32
u32_log2(u32 v)
{
/* The code from http://www-graphics.stanford.edu/~seander/bithacks.html */
u32 r, shift;
r = (v > 0xFFFF) << 4; v >>= r;
shift = (v > 0xFF ) << 3; v >>= shift; r |= shift;
shift = (v > 0xF ) << 2; v >>= shift; r |= shift;
shift = (v > 0x3 ) << 1; v >>= shift; r |= shift;
r |= (v >> 1);
return r;
}
bird2-2.17.5/lib/bitops.h 0000664 0000000 0000000 00000001726 15211753245 0015042 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Generic Bit Operations
*
* (c) 1998 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_BITOPTS_H_
#define _BIRD_BITOPTS_H_
#include "sysdep/config.h"
/*
* Bit mask operations:
*
* u32_mkmask Make bit mask consisting of consecutive ones
* from the left and the rest filled with zeroes.
* E.g., u32_mkmask(5) = 0xf8000000.
* u32_masklen Inverse operation to u32_mkmask, -1 if not a bitmask.
*/
u32 u32_mkmask(uint n);
uint u32_masklen(u32 x);
u32 u32_log2(u32 v);
static inline u32 u32_hash(u32 v) { return v * 2902958171u; }
static inline u8 u32_popcount(u32 v) { return __builtin_popcount(v); }
static inline u8 u64_popcount(u64 v) { return __builtin_popcountll(v); }
static inline int u32_clz(u32 v) { return __builtin_clz(v); }
static inline int u32_ctz(u32 v) { return __builtin_ctz(v); }
static inline int uint_is_pow2(uint n) { return n && !(n & (n-1)); }
#endif
bird2-2.17.5/lib/bitops_test.c 0000664 0000000 0000000 00000004577 15211753245 0016103 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Generic Bit Operations Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "test/bt-utils.h" /* naive_pow() */
#include "lib/bitops.h"
#define MAX_NUM 1000
#define CHECK_BIT(var,pos) ((var) & (u32)(1<<(pos)))
static int
t_mkmask(void)
{
int i;
u32 compute, expect;
bt_assert(u32_mkmask(0) == 0x00000000);
for (i = 1; i <= 32; i++)
{
compute = u32_mkmask(i);
expect = (u32) (0xffffffff << (32-i));
bt_assert_msg(compute == expect, "u32_mkmask(%d) = 0x%08X, expected 0x%08X", i, compute, expect);
}
return 1;
}
static int
u32_masklen_expected(u32 mask)
{
int j, expect = 0;
int valid = 0;
for (j = 0; j <= 32; j++)
if (mask == (j ? (0xffffffff << (32-j)) : 0)) /* Shifting 32-bit value by 32 bits is undefined behavior */
valid = 1;
if (!valid && mask != 0)
expect = 255;
else
for (j = 0; j <= 31; j++)
if (CHECK_BIT(mask, (31-j)))
expect = j+1;
else
break;
return expect;
}
static void
check_mask(u32 mask)
{
int expected, masklen;
expected = u32_masklen_expected(mask);
masklen = u32_masklen(mask);
int ok = (expected == masklen);
bt_debug("u32_masklen(Ox%08x) = %d, expected %d %s\n", mask, masklen, expected, ok ? "OK" : "FAIL!");
bt_assert(ok);
}
static int
t_masklen(void)
{
u32 i;
check_mask(0x82828282);
check_mask(0x00000000);
for (i = 0; i <= 32; i++)
check_mask(((u32) (i ? (0xffffffff << (32-i)) : 0)) & 0xffffffff); /* Shifting 32-bit value by 32 bits is undefined behavior */
for (i = 0; i <= MAX_NUM; i++)
check_mask(bt_random());
return 1;
}
static void
check_log2(u32 n)
{
u32 log = u32_log2(n);
u32 low = bt_naive_pow(2, log);
u32 high = bt_naive_pow(2, log+1);
bt_assert_msg(n >= low && n < high,
"u32_log2(%u) = %u, %u should be in the range <%u, %u)",
n, log, n, low, high);
}
static int
t_log2(void)
{
u32 i;
for (i = 0; i < 31; i++)
bt_assert(u32_log2(bt_naive_pow(2, i+1)) == i+1);
for (i = 1; i < MAX_NUM; i++)
check_log2(i);
for (i = 1; i < MAX_NUM; i++)
check_log2(((u32) bt_random()) % 0x0fffffff);
return 1;
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_mkmask, "u32_mkmask()");
bt_test_suite(t_masklen, "u32_masklen()");
bt_test_suite(t_log2, "u32_log2()");
return bt_exit_value();
}
bird2-2.17.5/lib/blake2-impl.h 0000664 0000000 0000000 00000006500 15211753245 0015634 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- BLAKE2 Support Code
*
* Based on the code from BLAKE2 reference source code package
*
* Copyright 2012, Samuel Neves
*
* You may use this under the terms of the CC0, the OpenSSL License, or the
* Apache Public License 2.0, at your option. The terms of these licenses
* can be found at:
*
* - CC0 1.0 Universal : https://creativecommons.org/publicdomain/zero/1.0
* - OpenSSL license : https://www.openssl.org/source/license.html
* - Apache 2.0 : https://www.apache.org/licenses/LICENSE-2.0
*
* More information about the BLAKE2 hash function can be found at
* https://blake2.net/ web.
*/
#ifndef _BIRD_BLAKE2_IMPL_H_
#define _BIRD_BLAKE2_IMPL_H_
#include "nest/bird.h"
static inline u32 load32(const void *src)
{
#if !defined(CPU_BIG_ENDIAN)
u32 w;
memcpy(&w, src, sizeof w);
return w;
#else
const u8 *p = (const u8 *) src;
return ((u32) (p[0]) << 0) |
((u32) (p[1]) << 8) |
((u32) (p[2]) << 16) |
((u32) (p[3]) << 24) ;
#endif
}
static inline u64 load64(const void *src)
{
#if !defined(CPU_BIG_ENDIAN)
u64 w;
memcpy(&w, src, sizeof w);
return w;
#else
const u8 *p = (const u8 *) src;
return ((u64) (p[0]) << 0) |
((u64) (p[1]) << 8) |
((u64) (p[2]) << 16) |
((u64) (p[3]) << 24) |
((u64) (p[4]) << 32) |
((u64) (p[5]) << 40) |
((u64) (p[6]) << 48) |
((u64) (p[7]) << 56) ;
#endif
}
static inline u16 load16(const void *src)
{
#if !defined(CPU_BIG_ENDIAN)
u16 w;
memcpy(&w, src, sizeof w);
return w;
#else
const u8 *p = (const u8 *) src;
return (u16) (((u32) (p[0]) << 0) |
((u32) (p[1]) << 8));
#endif
}
static inline void store16(void *dst, u16 w)
{
#if !defined(CPU_BIG_ENDIAN)
memcpy(dst, &w, sizeof w);
#else
u8 *p = (u8 *) dst;
*p++ = (u8)w; w >>= 8;
*p++ = (u8)w;
#endif
}
static inline void store32(void *dst, u32 w)
{
#if !defined(CPU_BIG_ENDIAN)
memcpy(dst, &w, sizeof w);
#else
u8 *p = (u8 *)dst;
p[0] = (u8) (w >> 0);
p[1] = (u8) (w >> 8);
p[2] = (u8) (w >> 16);
p[3] = (u8) (w >> 24);
#endif
}
static inline void store64(void *dst, u64 w)
{
#if !defined(CPU_BIG_ENDIAN)
memcpy(dst, &w, sizeof w);
#else
u8 *p = (u8 *) dst;
p[0] = (u8) (w >> 0);
p[1] = (u8) (w >> 8);
p[2] = (u8) (w >> 16);
p[3] = (u8) (w >> 24);
p[4] = (u8) (w >> 32);
p[5] = (u8) (w >> 40);
p[6] = (u8) (w >> 48);
p[7] = (u8) (w >> 56);
#endif
}
static inline u64 load48(const void *src)
{
const u8 *p = (const u8 *) src;
return ((u64) (p[0]) << 0) |
((u64) (p[1]) << 8) |
((u64) (p[2]) << 16) |
((u64) (p[3]) << 24) |
((u64) (p[4]) << 32) |
((u64) (p[5]) << 40) ;
}
static inline void store48(void *dst, u64 w)
{
u8 *p = (u8 *) dst;
p[0] = (u8) (w >> 0);
p[1] = (u8) (w >> 8);
p[2] = (u8) (w >> 16);
p[3] = (u8) (w >> 24);
p[4] = (u8) (w >> 32);
p[5] = (u8) (w >> 40);
}
static inline u32 rotr32(const u32 w, const uint c)
{
return (w >> c) | (w << (32 - c));
}
static inline u64 rotr64(const u64 w, const uint c)
{
return (w >> c) | (w << (64 - c));
}
/* prevents compiler optimizing out memset() */
static inline void secure_zero_memory(void *v, size_t n)
{
static void *(*const volatile memset_v)(void *, int, size_t) = &memset;
memset_v(v, 0, n);
}
#endif
bird2-2.17.5/lib/blake2-kat.h 0000664 0000000 0000000 00000501655 15211753245 0015465 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- BLAKE2 Test Vectors
*
* Based on the code from BLAKE2 reference source code package
*
* Copyright 2012, Samuel Neves
*
* You may use this under the terms of the CC0, the OpenSSL License, or the
* Apache Public License 2.0, at your option. The terms of these licenses
* can be found at:
*
* - CC0 1.0 Universal : https://creativecommons.org/publicdomain/zero/1.0
* - OpenSSL license : https://www.openssl.org/source/license.html
* - Apache 2.0 : https://www.apache.org/licenses/LICENSE-2.0
*
* More information about the BLAKE2 hash function can be found at
* https://blake2.net/ web.
*/
#ifndef _BIRD_BLAKE2_KAT_H_
#define _BIRD_BLAKE2_KAT_H_
#include
#define BLAKE2_KAT_LENGTH 256
static const uint8_t blake2s_keyed_kat[BLAKE2_KAT_LENGTH][BLAKE2S_256_SIZE] = {
{
0x48, 0xA8, 0x99, 0x7D, 0xA4, 0x07, 0x87, 0x6B,
0x3D, 0x79, 0xC0, 0xD9, 0x23, 0x25, 0xAD, 0x3B,
0x89, 0xCB, 0xB7, 0x54, 0xD8, 0x6A, 0xB7, 0x1A,
0xEE, 0x04, 0x7A, 0xD3, 0x45, 0xFD, 0x2C, 0x49
},
{
0x40, 0xD1, 0x5F, 0xEE, 0x7C, 0x32, 0x88, 0x30,
0x16, 0x6A, 0xC3, 0xF9, 0x18, 0x65, 0x0F, 0x80,
0x7E, 0x7E, 0x01, 0xE1, 0x77, 0x25, 0x8C, 0xDC,
0x0A, 0x39, 0xB1, 0x1F, 0x59, 0x80, 0x66, 0xF1
},
{
0x6B, 0xB7, 0x13, 0x00, 0x64, 0x4C, 0xD3, 0x99,
0x1B, 0x26, 0xCC, 0xD4, 0xD2, 0x74, 0xAC, 0xD1,
0xAD, 0xEA, 0xB8, 0xB1, 0xD7, 0x91, 0x45, 0x46,
0xC1, 0x19, 0x8B, 0xBE, 0x9F, 0xC9, 0xD8, 0x03
},
{
0x1D, 0x22, 0x0D, 0xBE, 0x2E, 0xE1, 0x34, 0x66,
0x1F, 0xDF, 0x6D, 0x9E, 0x74, 0xB4, 0x17, 0x04,
0x71, 0x05, 0x56, 0xF2, 0xF6, 0xE5, 0xA0, 0x91,
0xB2, 0x27, 0x69, 0x74, 0x45, 0xDB, 0xEA, 0x6B
},
{
0xF6, 0xC3, 0xFB, 0xAD, 0xB4, 0xCC, 0x68, 0x7A,
0x00, 0x64, 0xA5, 0xBE, 0x6E, 0x79, 0x1B, 0xEC,
0x63, 0xB8, 0x68, 0xAD, 0x62, 0xFB, 0xA6, 0x1B,
0x37, 0x57, 0xEF, 0x9C, 0xA5, 0x2E, 0x05, 0xB2
},
{
0x49, 0xC1, 0xF2, 0x11, 0x88, 0xDF, 0xD7, 0x69,
0xAE, 0xA0, 0xE9, 0x11, 0xDD, 0x6B, 0x41, 0xF1,
0x4D, 0xAB, 0x10, 0x9D, 0x2B, 0x85, 0x97, 0x7A,
0xA3, 0x08, 0x8B, 0x5C, 0x70, 0x7E, 0x85, 0x98
},
{
0xFD, 0xD8, 0x99, 0x3D, 0xCD, 0x43, 0xF6, 0x96,
0xD4, 0x4F, 0x3C, 0xEA, 0x0F, 0xF3, 0x53, 0x45,
0x23, 0x4E, 0xC8, 0xEE, 0x08, 0x3E, 0xB3, 0xCA,
0xDA, 0x01, 0x7C, 0x7F, 0x78, 0xC1, 0x71, 0x43
},
{
0xE6, 0xC8, 0x12, 0x56, 0x37, 0x43, 0x8D, 0x09,
0x05, 0xB7, 0x49, 0xF4, 0x65, 0x60, 0xAC, 0x89,
0xFD, 0x47, 0x1C, 0xF8, 0x69, 0x2E, 0x28, 0xFA,
0xB9, 0x82, 0xF7, 0x3F, 0x01, 0x9B, 0x83, 0xA9
},
{
0x19, 0xFC, 0x8C, 0xA6, 0x97, 0x9D, 0x60, 0xE6,
0xED, 0xD3, 0xB4, 0x54, 0x1E, 0x2F, 0x96, 0x7C,
0xED, 0x74, 0x0D, 0xF6, 0xEC, 0x1E, 0xAE, 0xBB,
0xFE, 0x81, 0x38, 0x32, 0xE9, 0x6B, 0x29, 0x74
},
{
0xA6, 0xAD, 0x77, 0x7C, 0xE8, 0x81, 0xB5, 0x2B,
0xB5, 0xA4, 0x42, 0x1A, 0xB6, 0xCD, 0xD2, 0xDF,
0xBA, 0x13, 0xE9, 0x63, 0x65, 0x2D, 0x4D, 0x6D,
0x12, 0x2A, 0xEE, 0x46, 0x54, 0x8C, 0x14, 0xA7
},
{
0xF5, 0xC4, 0xB2, 0xBA, 0x1A, 0x00, 0x78, 0x1B,
0x13, 0xAB, 0xA0, 0x42, 0x52, 0x42, 0xC6, 0x9C,
0xB1, 0x55, 0x2F, 0x3F, 0x71, 0xA9, 0xA3, 0xBB,
0x22, 0xB4, 0xA6, 0xB4, 0x27, 0x7B, 0x46, 0xDD
},
{
0xE3, 0x3C, 0x4C, 0x9B, 0xD0, 0xCC, 0x7E, 0x45,
0xC8, 0x0E, 0x65, 0xC7, 0x7F, 0xA5, 0x99, 0x7F,
0xEC, 0x70, 0x02, 0x73, 0x85, 0x41, 0x50, 0x9E,
0x68, 0xA9, 0x42, 0x38, 0x91, 0xE8, 0x22, 0xA3
},
{
0xFB, 0xA1, 0x61, 0x69, 0xB2, 0xC3, 0xEE, 0x10,
0x5B, 0xE6, 0xE1, 0xE6, 0x50, 0xE5, 0xCB, 0xF4,
0x07, 0x46, 0xB6, 0x75, 0x3D, 0x03, 0x6A, 0xB5,
0x51, 0x79, 0x01, 0x4A, 0xD7, 0xEF, 0x66, 0x51
},
{
0xF5, 0xC4, 0xBE, 0xC6, 0xD6, 0x2F, 0xC6, 0x08,
0xBF, 0x41, 0xCC, 0x11, 0x5F, 0x16, 0xD6, 0x1C,
0x7E, 0xFD, 0x3F, 0xF6, 0xC6, 0x56, 0x92, 0xBB,
0xE0, 0xAF, 0xFF, 0xB1, 0xFE, 0xDE, 0x74, 0x75
},
{
0xA4, 0x86, 0x2E, 0x76, 0xDB, 0x84, 0x7F, 0x05,
0xBA, 0x17, 0xED, 0xE5, 0xDA, 0x4E, 0x7F, 0x91,
0xB5, 0x92, 0x5C, 0xF1, 0xAD, 0x4B, 0xA1, 0x27,
0x32, 0xC3, 0x99, 0x57, 0x42, 0xA5, 0xCD, 0x6E
},
{
0x65, 0xF4, 0xB8, 0x60, 0xCD, 0x15, 0xB3, 0x8E,
0xF8, 0x14, 0xA1, 0xA8, 0x04, 0x31, 0x4A, 0x55,
0xBE, 0x95, 0x3C, 0xAA, 0x65, 0xFD, 0x75, 0x8A,
0xD9, 0x89, 0xFF, 0x34, 0xA4, 0x1C, 0x1E, 0xEA
},
{
0x19, 0xBA, 0x23, 0x4F, 0x0A, 0x4F, 0x38, 0x63,
0x7D, 0x18, 0x39, 0xF9, 0xD9, 0xF7, 0x6A, 0xD9,
0x1C, 0x85, 0x22, 0x30, 0x71, 0x43, 0xC9, 0x7D,
0x5F, 0x93, 0xF6, 0x92, 0x74, 0xCE, 0xC9, 0xA7
},
{
0x1A, 0x67, 0x18, 0x6C, 0xA4, 0xA5, 0xCB, 0x8E,
0x65, 0xFC, 0xA0, 0xE2, 0xEC, 0xBC, 0x5D, 0xDC,
0x14, 0xAE, 0x38, 0x1B, 0xB8, 0xBF, 0xFE, 0xB9,
0xE0, 0xA1, 0x03, 0x44, 0x9E, 0x3E, 0xF0, 0x3C
},
{
0xAF, 0xBE, 0xA3, 0x17, 0xB5, 0xA2, 0xE8, 0x9C,
0x0B, 0xD9, 0x0C, 0xCF, 0x5D, 0x7F, 0xD0, 0xED,
0x57, 0xFE, 0x58, 0x5E, 0x4B, 0xE3, 0x27, 0x1B,
0x0A, 0x6B, 0xF0, 0xF5, 0x78, 0x6B, 0x0F, 0x26
},
{
0xF1, 0xB0, 0x15, 0x58, 0xCE, 0x54, 0x12, 0x62,
0xF5, 0xEC, 0x34, 0x29, 0x9D, 0x6F, 0xB4, 0x09,
0x00, 0x09, 0xE3, 0x43, 0x4B, 0xE2, 0xF4, 0x91,
0x05, 0xCF, 0x46, 0xAF, 0x4D, 0x2D, 0x41, 0x24
},
{
0x13, 0xA0, 0xA0, 0xC8, 0x63, 0x35, 0x63, 0x5E,
0xAA, 0x74, 0xCA, 0x2D, 0x5D, 0x48, 0x8C, 0x79,
0x7B, 0xBB, 0x4F, 0x47, 0xDC, 0x07, 0x10, 0x50,
0x15, 0xED, 0x6A, 0x1F, 0x33, 0x09, 0xEF, 0xCE
},
{
0x15, 0x80, 0xAF, 0xEE, 0xBE, 0xBB, 0x34, 0x6F,
0x94, 0xD5, 0x9F, 0xE6, 0x2D, 0xA0, 0xB7, 0x92,
0x37, 0xEA, 0xD7, 0xB1, 0x49, 0x1F, 0x56, 0x67,
0xA9, 0x0E, 0x45, 0xED, 0xF6, 0xCA, 0x8B, 0x03
},
{
0x20, 0xBE, 0x1A, 0x87, 0x5B, 0x38, 0xC5, 0x73,
0xDD, 0x7F, 0xAA, 0xA0, 0xDE, 0x48, 0x9D, 0x65,
0x5C, 0x11, 0xEF, 0xB6, 0xA5, 0x52, 0x69, 0x8E,
0x07, 0xA2, 0xD3, 0x31, 0xB5, 0xF6, 0x55, 0xC3
},
{
0xBE, 0x1F, 0xE3, 0xC4, 0xC0, 0x40, 0x18, 0xC5,
0x4C, 0x4A, 0x0F, 0x6B, 0x9A, 0x2E, 0xD3, 0xC5,
0x3A, 0xBE, 0x3A, 0x9F, 0x76, 0xB4, 0xD2, 0x6D,
0xE5, 0x6F, 0xC9, 0xAE, 0x95, 0x05, 0x9A, 0x99
},
{
0xE3, 0xE3, 0xAC, 0xE5, 0x37, 0xEB, 0x3E, 0xDD,
0x84, 0x63, 0xD9, 0xAD, 0x35, 0x82, 0xE1, 0x3C,
0xF8, 0x65, 0x33, 0xFF, 0xDE, 0x43, 0xD6, 0x68,
0xDD, 0x2E, 0x93, 0xBB, 0xDB, 0xD7, 0x19, 0x5A
},
{
0x11, 0x0C, 0x50, 0xC0, 0xBF, 0x2C, 0x6E, 0x7A,
0xEB, 0x7E, 0x43, 0x5D, 0x92, 0xD1, 0x32, 0xAB,
0x66, 0x55, 0x16, 0x8E, 0x78, 0xA2, 0xDE, 0xCD,
0xEC, 0x33, 0x30, 0x77, 0x76, 0x84, 0xD9, 0xC1
},
{
0xE9, 0xBA, 0x8F, 0x50, 0x5C, 0x9C, 0x80, 0xC0,
0x86, 0x66, 0xA7, 0x01, 0xF3, 0x36, 0x7E, 0x6C,
0xC6, 0x65, 0xF3, 0x4B, 0x22, 0xE7, 0x3C, 0x3C,
0x04, 0x17, 0xEB, 0x1C, 0x22, 0x06, 0x08, 0x2F
},
{
0x26, 0xCD, 0x66, 0xFC, 0xA0, 0x23, 0x79, 0xC7,
0x6D, 0xF1, 0x23, 0x17, 0x05, 0x2B, 0xCA, 0xFD,
0x6C, 0xD8, 0xC3, 0xA7, 0xB8, 0x90, 0xD8, 0x05,
0xF3, 0x6C, 0x49, 0x98, 0x97, 0x82, 0x43, 0x3A
},
{
0x21, 0x3F, 0x35, 0x96, 0xD6, 0xE3, 0xA5, 0xD0,
0xE9, 0x93, 0x2C, 0xD2, 0x15, 0x91, 0x46, 0x01,
0x5E, 0x2A, 0xBC, 0x94, 0x9F, 0x47, 0x29, 0xEE,
0x26, 0x32, 0xFE, 0x1E, 0xDB, 0x78, 0xD3, 0x37
},
{
0x10, 0x15, 0xD7, 0x01, 0x08, 0xE0, 0x3B, 0xE1,
0xC7, 0x02, 0xFE, 0x97, 0x25, 0x36, 0x07, 0xD1,
0x4A, 0xEE, 0x59, 0x1F, 0x24, 0x13, 0xEA, 0x67,
0x87, 0x42, 0x7B, 0x64, 0x59, 0xFF, 0x21, 0x9A
},
{
0x3C, 0xA9, 0x89, 0xDE, 0x10, 0xCF, 0xE6, 0x09,
0x90, 0x94, 0x72, 0xC8, 0xD3, 0x56, 0x10, 0x80,
0x5B, 0x2F, 0x97, 0x77, 0x34, 0xCF, 0x65, 0x2C,
0xC6, 0x4B, 0x3B, 0xFC, 0x88, 0x2D, 0x5D, 0x89
},
{
0xB6, 0x15, 0x6F, 0x72, 0xD3, 0x80, 0xEE, 0x9E,
0xA6, 0xAC, 0xD1, 0x90, 0x46, 0x4F, 0x23, 0x07,
0xA5, 0xC1, 0x79, 0xEF, 0x01, 0xFD, 0x71, 0xF9,
0x9F, 0x2D, 0x0F, 0x7A, 0x57, 0x36, 0x0A, 0xEA
},
{
0xC0, 0x3B, 0xC6, 0x42, 0xB2, 0x09, 0x59, 0xCB,
0xE1, 0x33, 0xA0, 0x30, 0x3E, 0x0C, 0x1A, 0xBF,
0xF3, 0xE3, 0x1E, 0xC8, 0xE1, 0xA3, 0x28, 0xEC,
0x85, 0x65, 0xC3, 0x6D, 0xEC, 0xFF, 0x52, 0x65
},
{
0x2C, 0x3E, 0x08, 0x17, 0x6F, 0x76, 0x0C, 0x62,
0x64, 0xC3, 0xA2, 0xCD, 0x66, 0xFE, 0xC6, 0xC3,
0xD7, 0x8D, 0xE4, 0x3F, 0xC1, 0x92, 0x45, 0x7B,
0x2A, 0x4A, 0x66, 0x0A, 0x1E, 0x0E, 0xB2, 0x2B
},
{
0xF7, 0x38, 0xC0, 0x2F, 0x3C, 0x1B, 0x19, 0x0C,
0x51, 0x2B, 0x1A, 0x32, 0xDE, 0xAB, 0xF3, 0x53,
0x72, 0x8E, 0x0E, 0x9A, 0xB0, 0x34, 0x49, 0x0E,
0x3C, 0x34, 0x09, 0x94, 0x6A, 0x97, 0xAE, 0xEC
},
{
0x8B, 0x18, 0x80, 0xDF, 0x30, 0x1C, 0xC9, 0x63,
0x41, 0x88, 0x11, 0x08, 0x89, 0x64, 0x83, 0x92,
0x87, 0xFF, 0x7F, 0xE3, 0x1C, 0x49, 0xEA, 0x6E,
0xBD, 0x9E, 0x48, 0xBD, 0xEE, 0xE4, 0x97, 0xC5
},
{
0x1E, 0x75, 0xCB, 0x21, 0xC6, 0x09, 0x89, 0x02,
0x03, 0x75, 0xF1, 0xA7, 0xA2, 0x42, 0x83, 0x9F,
0x0B, 0x0B, 0x68, 0x97, 0x3A, 0x4C, 0x2A, 0x05,
0xCF, 0x75, 0x55, 0xED, 0x5A, 0xAE, 0xC4, 0xC1
},
{
0x62, 0xBF, 0x8A, 0x9C, 0x32, 0xA5, 0xBC, 0xCF,
0x29, 0x0B, 0x6C, 0x47, 0x4D, 0x75, 0xB2, 0xA2,
0xA4, 0x09, 0x3F, 0x1A, 0x9E, 0x27, 0x13, 0x94,
0x33, 0xA8, 0xF2, 0xB3, 0xBC, 0xE7, 0xB8, 0xD7
},
{
0x16, 0x6C, 0x83, 0x50, 0xD3, 0x17, 0x3B, 0x5E,
0x70, 0x2B, 0x78, 0x3D, 0xFD, 0x33, 0xC6, 0x6E,
0xE0, 0x43, 0x27, 0x42, 0xE9, 0xB9, 0x2B, 0x99,
0x7F, 0xD2, 0x3C, 0x60, 0xDC, 0x67, 0x56, 0xCA
},
{
0x04, 0x4A, 0x14, 0xD8, 0x22, 0xA9, 0x0C, 0xAC,
0xF2, 0xF5, 0xA1, 0x01, 0x42, 0x8A, 0xDC, 0x8F,
0x41, 0x09, 0x38, 0x6C, 0xCB, 0x15, 0x8B, 0xF9,
0x05, 0xC8, 0x61, 0x8B, 0x8E, 0xE2, 0x4E, 0xC3
},
{
0x38, 0x7D, 0x39, 0x7E, 0xA4, 0x3A, 0x99, 0x4B,
0xE8, 0x4D, 0x2D, 0x54, 0x4A, 0xFB, 0xE4, 0x81,
0xA2, 0x00, 0x0F, 0x55, 0x25, 0x26, 0x96, 0xBB,
0xA2, 0xC5, 0x0C, 0x8E, 0xBD, 0x10, 0x13, 0x47
},
{
0x56, 0xF8, 0xCC, 0xF1, 0xF8, 0x64, 0x09, 0xB4,
0x6C, 0xE3, 0x61, 0x66, 0xAE, 0x91, 0x65, 0x13,
0x84, 0x41, 0x57, 0x75, 0x89, 0xDB, 0x08, 0xCB,
0xC5, 0xF6, 0x6C, 0xA2, 0x97, 0x43, 0xB9, 0xFD
},
{
0x97, 0x06, 0xC0, 0x92, 0xB0, 0x4D, 0x91, 0xF5,
0x3D, 0xFF, 0x91, 0xFA, 0x37, 0xB7, 0x49, 0x3D,
0x28, 0xB5, 0x76, 0xB5, 0xD7, 0x10, 0x46, 0x9D,
0xF7, 0x94, 0x01, 0x66, 0x22, 0x36, 0xFC, 0x03
},
{
0x87, 0x79, 0x68, 0x68, 0x6C, 0x06, 0x8C, 0xE2,
0xF7, 0xE2, 0xAD, 0xCF, 0xF6, 0x8B, 0xF8, 0x74,
0x8E, 0xDF, 0x3C, 0xF8, 0x62, 0xCF, 0xB4, 0xD3,
0x94, 0x7A, 0x31, 0x06, 0x95, 0x80, 0x54, 0xE3
},
{
0x88, 0x17, 0xE5, 0x71, 0x98, 0x79, 0xAC, 0xF7,
0x02, 0x47, 0x87, 0xEC, 0xCD, 0xB2, 0x71, 0x03,
0x55, 0x66, 0xCF, 0xA3, 0x33, 0xE0, 0x49, 0x40,
0x7C, 0x01, 0x78, 0xCC, 0xC5, 0x7A, 0x5B, 0x9F
},
{
0x89, 0x38, 0x24, 0x9E, 0x4B, 0x50, 0xCA, 0xDA,
0xCC, 0xDF, 0x5B, 0x18, 0x62, 0x13, 0x26, 0xCB,
0xB1, 0x52, 0x53, 0xE3, 0x3A, 0x20, 0xF5, 0x63,
0x6E, 0x99, 0x5D, 0x72, 0x47, 0x8D, 0xE4, 0x72
},
{
0xF1, 0x64, 0xAB, 0xBA, 0x49, 0x63, 0xA4, 0x4D,
0x10, 0x72, 0x57, 0xE3, 0x23, 0x2D, 0x90, 0xAC,
0xA5, 0xE6, 0x6A, 0x14, 0x08, 0x24, 0x8C, 0x51,
0x74, 0x1E, 0x99, 0x1D, 0xB5, 0x22, 0x77, 0x56
},
{
0xD0, 0x55, 0x63, 0xE2, 0xB1, 0xCB, 0xA0, 0xC4,
0xA2, 0xA1, 0xE8, 0xBD, 0xE3, 0xA1, 0xA0, 0xD9,
0xF5, 0xB4, 0x0C, 0x85, 0xA0, 0x70, 0xD6, 0xF5,
0xFB, 0x21, 0x06, 0x6E, 0xAD, 0x5D, 0x06, 0x01
},
{
0x03, 0xFB, 0xB1, 0x63, 0x84, 0xF0, 0xA3, 0x86,
0x6F, 0x4C, 0x31, 0x17, 0x87, 0x76, 0x66, 0xEF,
0xBF, 0x12, 0x45, 0x97, 0x56, 0x4B, 0x29, 0x3D,
0x4A, 0xAB, 0x0D, 0x26, 0x9F, 0xAB, 0xDD, 0xFA
},
{
0x5F, 0xA8, 0x48, 0x6A, 0xC0, 0xE5, 0x29, 0x64,
0xD1, 0x88, 0x1B, 0xBE, 0x33, 0x8E, 0xB5, 0x4B,
0xE2, 0xF7, 0x19, 0x54, 0x92, 0x24, 0x89, 0x20,
0x57, 0xB4, 0xDA, 0x04, 0xBA, 0x8B, 0x34, 0x75
},
{
0xCD, 0xFA, 0xBC, 0xEE, 0x46, 0x91, 0x11, 0x11,
0x23, 0x6A, 0x31, 0x70, 0x8B, 0x25, 0x39, 0xD7,
0x1F, 0xC2, 0x11, 0xD9, 0xB0, 0x9C, 0x0D, 0x85,
0x30, 0xA1, 0x1E, 0x1D, 0xBF, 0x6E, 0xED, 0x01
},
{
0x4F, 0x82, 0xDE, 0x03, 0xB9, 0x50, 0x47, 0x93,
0xB8, 0x2A, 0x07, 0xA0, 0xBD, 0xCD, 0xFF, 0x31,
0x4D, 0x75, 0x9E, 0x7B, 0x62, 0xD2, 0x6B, 0x78,
0x49, 0x46, 0xB0, 0xD3, 0x6F, 0x91, 0x6F, 0x52
},
{
0x25, 0x9E, 0xC7, 0xF1, 0x73, 0xBC, 0xC7, 0x6A,
0x09, 0x94, 0xC9, 0x67, 0xB4, 0xF5, 0xF0, 0x24,
0xC5, 0x60, 0x57, 0xFB, 0x79, 0xC9, 0x65, 0xC4,
0xFA, 0xE4, 0x18, 0x75, 0xF0, 0x6A, 0x0E, 0x4C
},
{
0x19, 0x3C, 0xC8, 0xE7, 0xC3, 0xE0, 0x8B, 0xB3,
0x0F, 0x54, 0x37, 0xAA, 0x27, 0xAD, 0xE1, 0xF1,
0x42, 0x36, 0x9B, 0x24, 0x6A, 0x67, 0x5B, 0x23,
0x83, 0xE6, 0xDA, 0x9B, 0x49, 0xA9, 0x80, 0x9E
},
{
0x5C, 0x10, 0x89, 0x6F, 0x0E, 0x28, 0x56, 0xB2,
0xA2, 0xEE, 0xE0, 0xFE, 0x4A, 0x2C, 0x16, 0x33,
0x56, 0x5D, 0x18, 0xF0, 0xE9, 0x3E, 0x1F, 0xAB,
0x26, 0xC3, 0x73, 0xE8, 0xF8, 0x29, 0x65, 0x4D
},
{
0xF1, 0x60, 0x12, 0xD9, 0x3F, 0x28, 0x85, 0x1A,
0x1E, 0xB9, 0x89, 0xF5, 0xD0, 0xB4, 0x3F, 0x3F,
0x39, 0xCA, 0x73, 0xC9, 0xA6, 0x2D, 0x51, 0x81,
0xBF, 0xF2, 0x37, 0x53, 0x6B, 0xD3, 0x48, 0xC3
},
{
0x29, 0x66, 0xB3, 0xCF, 0xAE, 0x1E, 0x44, 0xEA,
0x99, 0x6D, 0xC5, 0xD6, 0x86, 0xCF, 0x25, 0xFA,
0x05, 0x3F, 0xB6, 0xF6, 0x72, 0x01, 0xB9, 0xE4,
0x6E, 0xAD, 0xE8, 0x5D, 0x0A, 0xD6, 0xB8, 0x06
},
{
0xDD, 0xB8, 0x78, 0x24, 0x85, 0xE9, 0x00, 0xBC,
0x60, 0xBC, 0xF4, 0xC3, 0x3A, 0x6F, 0xD5, 0x85,
0x68, 0x0C, 0xC6, 0x83, 0xD5, 0x16, 0xEF, 0xA0,
0x3E, 0xB9, 0x98, 0x5F, 0xAD, 0x87, 0x15, 0xFB
},
{
0x4C, 0x4D, 0x6E, 0x71, 0xAE, 0xA0, 0x57, 0x86,
0x41, 0x31, 0x48, 0xFC, 0x7A, 0x78, 0x6B, 0x0E,
0xCA, 0xF5, 0x82, 0xCF, 0xF1, 0x20, 0x9F, 0x5A,
0x80, 0x9F, 0xBA, 0x85, 0x04, 0xCE, 0x66, 0x2C
},
{
0xFB, 0x4C, 0x5E, 0x86, 0xD7, 0xB2, 0x22, 0x9B,
0x99, 0xB8, 0xBA, 0x6D, 0x94, 0xC2, 0x47, 0xEF,
0x96, 0x4A, 0xA3, 0xA2, 0xBA, 0xE8, 0xED, 0xC7,
0x75, 0x69, 0xF2, 0x8D, 0xBB, 0xFF, 0x2D, 0x4E
},
{
0xE9, 0x4F, 0x52, 0x6D, 0xE9, 0x01, 0x96, 0x33,
0xEC, 0xD5, 0x4A, 0xC6, 0x12, 0x0F, 0x23, 0x95,
0x8D, 0x77, 0x18, 0xF1, 0xE7, 0x71, 0x7B, 0xF3,
0x29, 0x21, 0x1A, 0x4F, 0xAE, 0xED, 0x4E, 0x6D
},
{
0xCB, 0xD6, 0x66, 0x0A, 0x10, 0xDB, 0x3F, 0x23,
0xF7, 0xA0, 0x3D, 0x4B, 0x9D, 0x40, 0x44, 0xC7,
0x93, 0x2B, 0x28, 0x01, 0xAC, 0x89, 0xD6, 0x0B,
0xC9, 0xEB, 0x92, 0xD6, 0x5A, 0x46, 0xC2, 0xA0
},
{
0x88, 0x18, 0xBB, 0xD3, 0xDB, 0x4D, 0xC1, 0x23,
0xB2, 0x5C, 0xBB, 0xA5, 0xF5, 0x4C, 0x2B, 0xC4,
0xB3, 0xFC, 0xF9, 0xBF, 0x7D, 0x7A, 0x77, 0x09,
0xF4, 0xAE, 0x58, 0x8B, 0x26, 0x7C, 0x4E, 0xCE
},
{
0xC6, 0x53, 0x82, 0x51, 0x3F, 0x07, 0x46, 0x0D,
0xA3, 0x98, 0x33, 0xCB, 0x66, 0x6C, 0x5E, 0xD8,
0x2E, 0x61, 0xB9, 0xE9, 0x98, 0xF4, 0xB0, 0xC4,
0x28, 0x7C, 0xEE, 0x56, 0xC3, 0xCC, 0x9B, 0xCD
},
{
0x89, 0x75, 0xB0, 0x57, 0x7F, 0xD3, 0x55, 0x66,
0xD7, 0x50, 0xB3, 0x62, 0xB0, 0x89, 0x7A, 0x26,
0xC3, 0x99, 0x13, 0x6D, 0xF0, 0x7B, 0xAB, 0xAB,
0xBD, 0xE6, 0x20, 0x3F, 0xF2, 0x95, 0x4E, 0xD4
},
{
0x21, 0xFE, 0x0C, 0xEB, 0x00, 0x52, 0xBE, 0x7F,
0xB0, 0xF0, 0x04, 0x18, 0x7C, 0xAC, 0xD7, 0xDE,
0x67, 0xFA, 0x6E, 0xB0, 0x93, 0x8D, 0x92, 0x76,
0x77, 0xF2, 0x39, 0x8C, 0x13, 0x23, 0x17, 0xA8
},
{
0x2E, 0xF7, 0x3F, 0x3C, 0x26, 0xF1, 0x2D, 0x93,
0x88, 0x9F, 0x3C, 0x78, 0xB6, 0xA6, 0x6C, 0x1D,
0x52, 0xB6, 0x49, 0xDC, 0x9E, 0x85, 0x6E, 0x2C,
0x17, 0x2E, 0xA7, 0xC5, 0x8A, 0xC2, 0xB5, 0xE3
},
{
0x38, 0x8A, 0x3C, 0xD5, 0x6D, 0x73, 0x86, 0x7A,
0xBB, 0x5F, 0x84, 0x01, 0x49, 0x2B, 0x6E, 0x26,
0x81, 0xEB, 0x69, 0x85, 0x1E, 0x76, 0x7F, 0xD8,
0x42, 0x10, 0xA5, 0x60, 0x76, 0xFB, 0x3D, 0xD3
},
{
0xAF, 0x53, 0x3E, 0x02, 0x2F, 0xC9, 0x43, 0x9E,
0x4E, 0x3C, 0xB8, 0x38, 0xEC, 0xD1, 0x86, 0x92,
0x23, 0x2A, 0xDF, 0x6F, 0xE9, 0x83, 0x95, 0x26,
0xD3, 0xC3, 0xDD, 0x1B, 0x71, 0x91, 0x0B, 0x1A
},
{
0x75, 0x1C, 0x09, 0xD4, 0x1A, 0x93, 0x43, 0x88,
0x2A, 0x81, 0xCD, 0x13, 0xEE, 0x40, 0x81, 0x8D,
0x12, 0xEB, 0x44, 0xC6, 0xC7, 0xF4, 0x0D, 0xF1,
0x6E, 0x4A, 0xEA, 0x8F, 0xAB, 0x91, 0x97, 0x2A
},
{
0x5B, 0x73, 0xDD, 0xB6, 0x8D, 0x9D, 0x2B, 0x0A,
0xA2, 0x65, 0xA0, 0x79, 0x88, 0xD6, 0xB8, 0x8A,
0xE9, 0xAA, 0xC5, 0x82, 0xAF, 0x83, 0x03, 0x2F,
0x8A, 0x9B, 0x21, 0xA2, 0xE1, 0xB7, 0xBF, 0x18
},
{
0x3D, 0xA2, 0x91, 0x26, 0xC7, 0xC5, 0xD7, 0xF4,
0x3E, 0x64, 0x24, 0x2A, 0x79, 0xFE, 0xAA, 0x4E,
0xF3, 0x45, 0x9C, 0xDE, 0xCC, 0xC8, 0x98, 0xED,
0x59, 0xA9, 0x7F, 0x6E, 0xC9, 0x3B, 0x9D, 0xAB
},
{
0x56, 0x6D, 0xC9, 0x20, 0x29, 0x3D, 0xA5, 0xCB,
0x4F, 0xE0, 0xAA, 0x8A, 0xBD, 0xA8, 0xBB, 0xF5,
0x6F, 0x55, 0x23, 0x13, 0xBF, 0xF1, 0x90, 0x46,
0x64, 0x1E, 0x36, 0x15, 0xC1, 0xE3, 0xED, 0x3F
},
{
0x41, 0x15, 0xBE, 0xA0, 0x2F, 0x73, 0xF9, 0x7F,
0x62, 0x9E, 0x5C, 0x55, 0x90, 0x72, 0x0C, 0x01,
0xE7, 0xE4, 0x49, 0xAE, 0x2A, 0x66, 0x97, 0xD4,
0xD2, 0x78, 0x33, 0x21, 0x30, 0x36, 0x92, 0xF9
},
{
0x4C, 0xE0, 0x8F, 0x47, 0x62, 0x46, 0x8A, 0x76,
0x70, 0x01, 0x21, 0x64, 0x87, 0x8D, 0x68, 0x34,
0x0C, 0x52, 0xA3, 0x5E, 0x66, 0xC1, 0x88, 0x4D,
0x5C, 0x86, 0x48, 0x89, 0xAB, 0xC9, 0x66, 0x77
},
{
0x81, 0xEA, 0x0B, 0x78, 0x04, 0x12, 0x4E, 0x0C,
0x22, 0xEA, 0x5F, 0xC7, 0x11, 0x04, 0xA2, 0xAF,
0xCB, 0x52, 0xA1, 0xFA, 0x81, 0x6F, 0x3E, 0xCB,
0x7D, 0xCB, 0x5D, 0x9D, 0xEA, 0x17, 0x86, 0xD0
},
{
0xFE, 0x36, 0x27, 0x33, 0xB0, 0x5F, 0x6B, 0xED,
0xAF, 0x93, 0x79, 0xD7, 0xF7, 0x93, 0x6E, 0xDE,
0x20, 0x9B, 0x1F, 0x83, 0x23, 0xC3, 0x92, 0x25,
0x49, 0xD9, 0xE7, 0x36, 0x81, 0xB5, 0xDB, 0x7B
},
{
0xEF, 0xF3, 0x7D, 0x30, 0xDF, 0xD2, 0x03, 0x59,
0xBE, 0x4E, 0x73, 0xFD, 0xF4, 0x0D, 0x27, 0x73,
0x4B, 0x3D, 0xF9, 0x0A, 0x97, 0xA5, 0x5E, 0xD7,
0x45, 0x29, 0x72, 0x94, 0xCA, 0x85, 0xD0, 0x9F
},
{
0x17, 0x2F, 0xFC, 0x67, 0x15, 0x3D, 0x12, 0xE0,
0xCA, 0x76, 0xA8, 0xB6, 0xCD, 0x5D, 0x47, 0x31,
0x88, 0x5B, 0x39, 0xCE, 0x0C, 0xAC, 0x93, 0xA8,
0x97, 0x2A, 0x18, 0x00, 0x6C, 0x8B, 0x8B, 0xAF
},
{
0xC4, 0x79, 0x57, 0xF1, 0xCC, 0x88, 0xE8, 0x3E,
0xF9, 0x44, 0x58, 0x39, 0x70, 0x9A, 0x48, 0x0A,
0x03, 0x6B, 0xED, 0x5F, 0x88, 0xAC, 0x0F, 0xCC,
0x8E, 0x1E, 0x70, 0x3F, 0xFA, 0xAC, 0x13, 0x2C
},
{
0x30, 0xF3, 0x54, 0x83, 0x70, 0xCF, 0xDC, 0xED,
0xA5, 0xC3, 0x7B, 0x56, 0x9B, 0x61, 0x75, 0xE7,
0x99, 0xEE, 0xF1, 0xA6, 0x2A, 0xAA, 0x94, 0x32,
0x45, 0xAE, 0x76, 0x69, 0xC2, 0x27, 0xA7, 0xB5
},
{
0xC9, 0x5D, 0xCB, 0x3C, 0xF1, 0xF2, 0x7D, 0x0E,
0xEF, 0x2F, 0x25, 0xD2, 0x41, 0x38, 0x70, 0x90,
0x4A, 0x87, 0x7C, 0x4A, 0x56, 0xC2, 0xDE, 0x1E,
0x83, 0xE2, 0xBC, 0x2A, 0xE2, 0xE4, 0x68, 0x21
},
{
0xD5, 0xD0, 0xB5, 0xD7, 0x05, 0x43, 0x4C, 0xD4,
0x6B, 0x18, 0x57, 0x49, 0xF6, 0x6B, 0xFB, 0x58,
0x36, 0xDC, 0xDF, 0x6E, 0xE5, 0x49, 0xA2, 0xB7,
0xA4, 0xAE, 0xE7, 0xF5, 0x80, 0x07, 0xCA, 0xAF
},
{
0xBB, 0xC1, 0x24, 0xA7, 0x12, 0xF1, 0x5D, 0x07,
0xC3, 0x00, 0xE0, 0x5B, 0x66, 0x83, 0x89, 0xA4,
0x39, 0xC9, 0x17, 0x77, 0xF7, 0x21, 0xF8, 0x32,
0x0C, 0x1C, 0x90, 0x78, 0x06, 0x6D, 0x2C, 0x7E
},
{
0xA4, 0x51, 0xB4, 0x8C, 0x35, 0xA6, 0xC7, 0x85,
0x4C, 0xFA, 0xAE, 0x60, 0x26, 0x2E, 0x76, 0x99,
0x08, 0x16, 0x38, 0x2A, 0xC0, 0x66, 0x7E, 0x5A,
0x5C, 0x9E, 0x1B, 0x46, 0xC4, 0x34, 0x2D, 0xDF
},
{
0xB0, 0xD1, 0x50, 0xFB, 0x55, 0xE7, 0x78, 0xD0,
0x11, 0x47, 0xF0, 0xB5, 0xD8, 0x9D, 0x99, 0xEC,
0xB2, 0x0F, 0xF0, 0x7E, 0x5E, 0x67, 0x60, 0xD6,
0xB6, 0x45, 0xEB, 0x5B, 0x65, 0x4C, 0x62, 0x2B
},
{
0x34, 0xF7, 0x37, 0xC0, 0xAB, 0x21, 0x99, 0x51,
0xEE, 0xE8, 0x9A, 0x9F, 0x8D, 0xAC, 0x29, 0x9C,
0x9D, 0x4C, 0x38, 0xF3, 0x3F, 0xA4, 0x94, 0xC5,
0xC6, 0xEE, 0xFC, 0x92, 0xB6, 0xDB, 0x08, 0xBC
},
{
0x1A, 0x62, 0xCC, 0x3A, 0x00, 0x80, 0x0D, 0xCB,
0xD9, 0x98, 0x91, 0x08, 0x0C, 0x1E, 0x09, 0x84,
0x58, 0x19, 0x3A, 0x8C, 0xC9, 0xF9, 0x70, 0xEA,
0x99, 0xFB, 0xEF, 0xF0, 0x03, 0x18, 0xC2, 0x89
},
{
0xCF, 0xCE, 0x55, 0xEB, 0xAF, 0xC8, 0x40, 0xD7,
0xAE, 0x48, 0x28, 0x1C, 0x7F, 0xD5, 0x7E, 0xC8,
0xB4, 0x82, 0xD4, 0xB7, 0x04, 0x43, 0x74, 0x95,
0x49, 0x5A, 0xC4, 0x14, 0xCF, 0x4A, 0x37, 0x4B
},
{
0x67, 0x46, 0xFA, 0xCF, 0x71, 0x14, 0x6D, 0x99,
0x9D, 0xAB, 0xD0, 0x5D, 0x09, 0x3A, 0xE5, 0x86,
0x64, 0x8D, 0x1E, 0xE2, 0x8E, 0x72, 0x61, 0x7B,
0x99, 0xD0, 0xF0, 0x08, 0x6E, 0x1E, 0x45, 0xBF
},
{
0x57, 0x1C, 0xED, 0x28, 0x3B, 0x3F, 0x23, 0xB4,
0xE7, 0x50, 0xBF, 0x12, 0xA2, 0xCA, 0xF1, 0x78,
0x18, 0x47, 0xBD, 0x89, 0x0E, 0x43, 0x60, 0x3C,
0xDC, 0x59, 0x76, 0x10, 0x2B, 0x7B, 0xB1, 0x1B
},
{
0xCF, 0xCB, 0x76, 0x5B, 0x04, 0x8E, 0x35, 0x02,
0x2C, 0x5D, 0x08, 0x9D, 0x26, 0xE8, 0x5A, 0x36,
0xB0, 0x05, 0xA2, 0xB8, 0x04, 0x93, 0xD0, 0x3A,
0x14, 0x4E, 0x09, 0xF4, 0x09, 0xB6, 0xAF, 0xD1
},
{
0x40, 0x50, 0xC7, 0xA2, 0x77, 0x05, 0xBB, 0x27,
0xF4, 0x20, 0x89, 0xB2, 0x99, 0xF3, 0xCB, 0xE5,
0x05, 0x4E, 0xAD, 0x68, 0x72, 0x7E, 0x8E, 0xF9,
0x31, 0x8C, 0xE6, 0xF2, 0x5C, 0xD6, 0xF3, 0x1D
},
{
0x18, 0x40, 0x70, 0xBD, 0x5D, 0x26, 0x5F, 0xBD,
0xC1, 0x42, 0xCD, 0x1C, 0x5C, 0xD0, 0xD7, 0xE4,
0x14, 0xE7, 0x03, 0x69, 0xA2, 0x66, 0xD6, 0x27,
0xC8, 0xFB, 0xA8, 0x4F, 0xA5, 0xE8, 0x4C, 0x34
},
{
0x9E, 0xDD, 0xA9, 0xA4, 0x44, 0x39, 0x02, 0xA9,
0x58, 0x8C, 0x0D, 0x0C, 0xCC, 0x62, 0xB9, 0x30,
0x21, 0x84, 0x79, 0xA6, 0x84, 0x1E, 0x6F, 0xE7,
0xD4, 0x30, 0x03, 0xF0, 0x4B, 0x1F, 0xD6, 0x43
},
{
0xE4, 0x12, 0xFE, 0xEF, 0x79, 0x08, 0x32, 0x4A,
0x6D, 0xA1, 0x84, 0x16, 0x29, 0xF3, 0x5D, 0x3D,
0x35, 0x86, 0x42, 0x01, 0x93, 0x10, 0xEC, 0x57,
0xC6, 0x14, 0x83, 0x6B, 0x63, 0xD3, 0x07, 0x63
},
{
0x1A, 0x2B, 0x8E, 0xDF, 0xF3, 0xF9, 0xAC, 0xC1,
0x55, 0x4F, 0xCB, 0xAE, 0x3C, 0xF1, 0xD6, 0x29,
0x8C, 0x64, 0x62, 0xE2, 0x2E, 0x5E, 0xB0, 0x25,
0x96, 0x84, 0xF8, 0x35, 0x01, 0x2B, 0xD1, 0x3F
},
{
0x28, 0x8C, 0x4A, 0xD9, 0xB9, 0x40, 0x97, 0x62,
0xEA, 0x07, 0xC2, 0x4A, 0x41, 0xF0, 0x4F, 0x69,
0xA7, 0xD7, 0x4B, 0xEE, 0x2D, 0x95, 0x43, 0x53,
0x74, 0xBD, 0xE9, 0x46, 0xD7, 0x24, 0x1C, 0x7B
},
{
0x80, 0x56, 0x91, 0xBB, 0x28, 0x67, 0x48, 0xCF,
0xB5, 0x91, 0xD3, 0xAE, 0xBE, 0x7E, 0x6F, 0x4E,
0x4D, 0xC6, 0xE2, 0x80, 0x8C, 0x65, 0x14, 0x3C,
0xC0, 0x04, 0xE4, 0xEB, 0x6F, 0xD0, 0x9D, 0x43
},
{
0xD4, 0xAC, 0x8D, 0x3A, 0x0A, 0xFC, 0x6C, 0xFA,
0x7B, 0x46, 0x0A, 0xE3, 0x00, 0x1B, 0xAE, 0xB3,
0x6D, 0xAD, 0xB3, 0x7D, 0xA0, 0x7D, 0x2E, 0x8A,
0xC9, 0x18, 0x22, 0xDF, 0x34, 0x8A, 0xED, 0x3D
},
{
0xC3, 0x76, 0x61, 0x70, 0x14, 0xD2, 0x01, 0x58,
0xBC, 0xED, 0x3D, 0x3B, 0xA5, 0x52, 0xB6, 0xEC,
0xCF, 0x84, 0xE6, 0x2A, 0xA3, 0xEB, 0x65, 0x0E,
0x90, 0x02, 0x9C, 0x84, 0xD1, 0x3E, 0xEA, 0x69
},
{
0xC4, 0x1F, 0x09, 0xF4, 0x3C, 0xEC, 0xAE, 0x72,
0x93, 0xD6, 0x00, 0x7C, 0xA0, 0xA3, 0x57, 0x08,
0x7D, 0x5A, 0xE5, 0x9B, 0xE5, 0x00, 0xC1, 0xCD,
0x5B, 0x28, 0x9E, 0xE8, 0x10, 0xC7, 0xB0, 0x82
},
{
0x03, 0xD1, 0xCE, 0xD1, 0xFB, 0xA5, 0xC3, 0x91,
0x55, 0xC4, 0x4B, 0x77, 0x65, 0xCB, 0x76, 0x0C,
0x78, 0x70, 0x8D, 0xCF, 0xC8, 0x0B, 0x0B, 0xD8,
0xAD, 0xE3, 0xA5, 0x6D, 0xA8, 0x83, 0x0B, 0x29
},
{
0x09, 0xBD, 0xE6, 0xF1, 0x52, 0x21, 0x8D, 0xC9,
0x2C, 0x41, 0xD7, 0xF4, 0x53, 0x87, 0xE6, 0x3E,
0x58, 0x69, 0xD8, 0x07, 0xEC, 0x70, 0xB8, 0x21,
0x40, 0x5D, 0xBD, 0x88, 0x4B, 0x7F, 0xCF, 0x4B
},
{
0x71, 0xC9, 0x03, 0x6E, 0x18, 0x17, 0x9B, 0x90,
0xB3, 0x7D, 0x39, 0xE9, 0xF0, 0x5E, 0xB8, 0x9C,
0xC5, 0xFC, 0x34, 0x1F, 0xD7, 0xC4, 0x77, 0xD0,
0xD7, 0x49, 0x32, 0x85, 0xFA, 0xCA, 0x08, 0xA4
},
{
0x59, 0x16, 0x83, 0x3E, 0xBB, 0x05, 0xCD, 0x91,
0x9C, 0xA7, 0xFE, 0x83, 0xB6, 0x92, 0xD3, 0x20,
0x5B, 0xEF, 0x72, 0x39, 0x2B, 0x2C, 0xF6, 0xBB,
0x0A, 0x6D, 0x43, 0xF9, 0x94, 0xF9, 0x5F, 0x11
},
{
0xF6, 0x3A, 0xAB, 0x3E, 0xC6, 0x41, 0xB3, 0xB0,
0x24, 0x96, 0x4C, 0x2B, 0x43, 0x7C, 0x04, 0xF6,
0x04, 0x3C, 0x4C, 0x7E, 0x02, 0x79, 0x23, 0x99,
0x95, 0x40, 0x19, 0x58, 0xF8, 0x6B, 0xBE, 0x54
},
{
0xF1, 0x72, 0xB1, 0x80, 0xBF, 0xB0, 0x97, 0x40,
0x49, 0x31, 0x20, 0xB6, 0x32, 0x6C, 0xBD, 0xC5,
0x61, 0xE4, 0x77, 0xDE, 0xF9, 0xBB, 0xCF, 0xD2,
0x8C, 0xC8, 0xC1, 0xC5, 0xE3, 0x37, 0x9A, 0x31
},
{
0xCB, 0x9B, 0x89, 0xCC, 0x18, 0x38, 0x1D, 0xD9,
0x14, 0x1A, 0xDE, 0x58, 0x86, 0x54, 0xD4, 0xE6,
0xA2, 0x31, 0xD5, 0xBF, 0x49, 0xD4, 0xD5, 0x9A,
0xC2, 0x7D, 0x86, 0x9C, 0xBE, 0x10, 0x0C, 0xF3
},
{
0x7B, 0xD8, 0x81, 0x50, 0x46, 0xFD, 0xD8, 0x10,
0xA9, 0x23, 0xE1, 0x98, 0x4A, 0xAE, 0xBD, 0xCD,
0xF8, 0x4D, 0x87, 0xC8, 0x99, 0x2D, 0x68, 0xB5,
0xEE, 0xB4, 0x60, 0xF9, 0x3E, 0xB3, 0xC8, 0xD7
},
{
0x60, 0x7B, 0xE6, 0x68, 0x62, 0xFD, 0x08, 0xEE,
0x5B, 0x19, 0xFA, 0xCA, 0xC0, 0x9D, 0xFD, 0xBC,
0xD4, 0x0C, 0x31, 0x21, 0x01, 0xD6, 0x6E, 0x6E,
0xBD, 0x2B, 0x84, 0x1F, 0x1B, 0x9A, 0x93, 0x25
},
{
0x9F, 0xE0, 0x3B, 0xBE, 0x69, 0xAB, 0x18, 0x34,
0xF5, 0x21, 0x9B, 0x0D, 0xA8, 0x8A, 0x08, 0xB3,
0x0A, 0x66, 0xC5, 0x91, 0x3F, 0x01, 0x51, 0x96,
0x3C, 0x36, 0x05, 0x60, 0xDB, 0x03, 0x87, 0xB3
},
{
0x90, 0xA8, 0x35, 0x85, 0x71, 0x7B, 0x75, 0xF0,
0xE9, 0xB7, 0x25, 0xE0, 0x55, 0xEE, 0xEE, 0xB9,
0xE7, 0xA0, 0x28, 0xEA, 0x7E, 0x6C, 0xBC, 0x07,
0xB2, 0x09, 0x17, 0xEC, 0x03, 0x63, 0xE3, 0x8C
},
{
0x33, 0x6E, 0xA0, 0x53, 0x0F, 0x4A, 0x74, 0x69,
0x12, 0x6E, 0x02, 0x18, 0x58, 0x7E, 0xBB, 0xDE,
0x33, 0x58, 0xA0, 0xB3, 0x1C, 0x29, 0xD2, 0x00,
0xF7, 0xDC, 0x7E, 0xB1, 0x5C, 0x6A, 0xAD, 0xD8
},
{
0xA7, 0x9E, 0x76, 0xDC, 0x0A, 0xBC, 0xA4, 0x39,
0x6F, 0x07, 0x47, 0xCD, 0x7B, 0x74, 0x8D, 0xF9,
0x13, 0x00, 0x76, 0x26, 0xB1, 0xD6, 0x59, 0xDA,
0x0C, 0x1F, 0x78, 0xB9, 0x30, 0x3D, 0x01, 0xA3
},
{
0x44, 0xE7, 0x8A, 0x77, 0x37, 0x56, 0xE0, 0x95,
0x15, 0x19, 0x50, 0x4D, 0x70, 0x38, 0xD2, 0x8D,
0x02, 0x13, 0xA3, 0x7E, 0x0C, 0xE3, 0x75, 0x37,
0x17, 0x57, 0xBC, 0x99, 0x63, 0x11, 0xE3, 0xB8
},
{
0x77, 0xAC, 0x01, 0x2A, 0x3F, 0x75, 0x4D, 0xCF,
0xEA, 0xB5, 0xEB, 0x99, 0x6B, 0xE9, 0xCD, 0x2D,
0x1F, 0x96, 0x11, 0x1B, 0x6E, 0x49, 0xF3, 0x99,
0x4D, 0xF1, 0x81, 0xF2, 0x85, 0x69, 0xD8, 0x25
},
{
0xCE, 0x5A, 0x10, 0xDB, 0x6F, 0xCC, 0xDA, 0xF1,
0x40, 0xAA, 0xA4, 0xDE, 0xD6, 0x25, 0x0A, 0x9C,
0x06, 0xE9, 0x22, 0x2B, 0xC9, 0xF9, 0xF3, 0x65,
0x8A, 0x4A, 0xFF, 0x93, 0x5F, 0x2B, 0x9F, 0x3A
},
{
0xEC, 0xC2, 0x03, 0xA7, 0xFE, 0x2B, 0xE4, 0xAB,
0xD5, 0x5B, 0xB5, 0x3E, 0x6E, 0x67, 0x35, 0x72,
0xE0, 0x07, 0x8D, 0xA8, 0xCD, 0x37, 0x5E, 0xF4,
0x30, 0xCC, 0x97, 0xF9, 0xF8, 0x00, 0x83, 0xAF
},
{
0x14, 0xA5, 0x18, 0x6D, 0xE9, 0xD7, 0xA1, 0x8B,
0x04, 0x12, 0xB8, 0x56, 0x3E, 0x51, 0xCC, 0x54,
0x33, 0x84, 0x0B, 0x4A, 0x12, 0x9A, 0x8F, 0xF9,
0x63, 0xB3, 0x3A, 0x3C, 0x4A, 0xFE, 0x8E, 0xBB
},
{
0x13, 0xF8, 0xEF, 0x95, 0xCB, 0x86, 0xE6, 0xA6,
0x38, 0x93, 0x1C, 0x8E, 0x10, 0x76, 0x73, 0xEB,
0x76, 0xBA, 0x10, 0xD7, 0xC2, 0xCD, 0x70, 0xB9,
0xD9, 0x92, 0x0B, 0xBE, 0xED, 0x92, 0x94, 0x09
},
{
0x0B, 0x33, 0x8F, 0x4E, 0xE1, 0x2F, 0x2D, 0xFC,
0xB7, 0x87, 0x13, 0x37, 0x79, 0x41, 0xE0, 0xB0,
0x63, 0x21, 0x52, 0x58, 0x1D, 0x13, 0x32, 0x51,
0x6E, 0x4A, 0x2C, 0xAB, 0x19, 0x42, 0xCC, 0xA4
},
{
0xEA, 0xAB, 0x0E, 0xC3, 0x7B, 0x3B, 0x8A, 0xB7,
0x96, 0xE9, 0xF5, 0x72, 0x38, 0xDE, 0x14, 0xA2,
0x64, 0xA0, 0x76, 0xF3, 0x88, 0x7D, 0x86, 0xE2,
0x9B, 0xB5, 0x90, 0x6D, 0xB5, 0xA0, 0x0E, 0x02
},
{
0x23, 0xCB, 0x68, 0xB8, 0xC0, 0xE6, 0xDC, 0x26,
0xDC, 0x27, 0x76, 0x6D, 0xDC, 0x0A, 0x13, 0xA9,
0x94, 0x38, 0xFD, 0x55, 0x61, 0x7A, 0xA4, 0x09,
0x5D, 0x8F, 0x96, 0x97, 0x20, 0xC8, 0x72, 0xDF
},
{
0x09, 0x1D, 0x8E, 0xE3, 0x0D, 0x6F, 0x29, 0x68,
0xD4, 0x6B, 0x68, 0x7D, 0xD6, 0x52, 0x92, 0x66,
0x57, 0x42, 0xDE, 0x0B, 0xB8, 0x3D, 0xCC, 0x00,
0x04, 0xC7, 0x2C, 0xE1, 0x00, 0x07, 0xA5, 0x49
},
{
0x7F, 0x50, 0x7A, 0xBC, 0x6D, 0x19, 0xBA, 0x00,
0xC0, 0x65, 0xA8, 0x76, 0xEC, 0x56, 0x57, 0x86,
0x88, 0x82, 0xD1, 0x8A, 0x22, 0x1B, 0xC4, 0x6C,
0x7A, 0x69, 0x12, 0x54, 0x1F, 0x5B, 0xC7, 0xBA
},
{
0xA0, 0x60, 0x7C, 0x24, 0xE1, 0x4E, 0x8C, 0x22,
0x3D, 0xB0, 0xD7, 0x0B, 0x4D, 0x30, 0xEE, 0x88,
0x01, 0x4D, 0x60, 0x3F, 0x43, 0x7E, 0x9E, 0x02,
0xAA, 0x7D, 0xAF, 0xA3, 0xCD, 0xFB, 0xAD, 0x94
},
{
0xDD, 0xBF, 0xEA, 0x75, 0xCC, 0x46, 0x78, 0x82,
0xEB, 0x34, 0x83, 0xCE, 0x5E, 0x2E, 0x75, 0x6A,
0x4F, 0x47, 0x01, 0xB7, 0x6B, 0x44, 0x55, 0x19,
0xE8, 0x9F, 0x22, 0xD6, 0x0F, 0xA8, 0x6E, 0x06
},
{
0x0C, 0x31, 0x1F, 0x38, 0xC3, 0x5A, 0x4F, 0xB9,
0x0D, 0x65, 0x1C, 0x28, 0x9D, 0x48, 0x68, 0x56,
0xCD, 0x14, 0x13, 0xDF, 0x9B, 0x06, 0x77, 0xF5,
0x3E, 0xCE, 0x2C, 0xD9, 0xE4, 0x77, 0xC6, 0x0A
},
{
0x46, 0xA7, 0x3A, 0x8D, 0xD3, 0xE7, 0x0F, 0x59,
0xD3, 0x94, 0x2C, 0x01, 0xDF, 0x59, 0x9D, 0xEF,
0x78, 0x3C, 0x9D, 0xA8, 0x2F, 0xD8, 0x32, 0x22,
0xCD, 0x66, 0x2B, 0x53, 0xDC, 0xE7, 0xDB, 0xDF
},
{
0xAD, 0x03, 0x8F, 0xF9, 0xB1, 0x4D, 0xE8, 0x4A,
0x80, 0x1E, 0x4E, 0x62, 0x1C, 0xE5, 0xDF, 0x02,
0x9D, 0xD9, 0x35, 0x20, 0xD0, 0xC2, 0xFA, 0x38,
0xBF, 0xF1, 0x76, 0xA8, 0xB1, 0xD1, 0x69, 0x8C
},
{
0xAB, 0x70, 0xC5, 0xDF, 0xBD, 0x1E, 0xA8, 0x17,
0xFE, 0xD0, 0xCD, 0x06, 0x72, 0x93, 0xAB, 0xF3,
0x19, 0xE5, 0xD7, 0x90, 0x1C, 0x21, 0x41, 0xD5,
0xD9, 0x9B, 0x23, 0xF0, 0x3A, 0x38, 0xE7, 0x48
},
{
0x1F, 0xFF, 0xDA, 0x67, 0x93, 0x2B, 0x73, 0xC8,
0xEC, 0xAF, 0x00, 0x9A, 0x34, 0x91, 0xA0, 0x26,
0x95, 0x3B, 0xAB, 0xFE, 0x1F, 0x66, 0x3B, 0x06,
0x97, 0xC3, 0xC4, 0xAE, 0x8B, 0x2E, 0x7D, 0xCB
},
{
0xB0, 0xD2, 0xCC, 0x19, 0x47, 0x2D, 0xD5, 0x7F,
0x2B, 0x17, 0xEF, 0xC0, 0x3C, 0x8D, 0x58, 0xC2,
0x28, 0x3D, 0xBB, 0x19, 0xDA, 0x57, 0x2F, 0x77,
0x55, 0x85, 0x5A, 0xA9, 0x79, 0x43, 0x17, 0xA0
},
{
0xA0, 0xD1, 0x9A, 0x6E, 0xE3, 0x39, 0x79, 0xC3,
0x25, 0x51, 0x0E, 0x27, 0x66, 0x22, 0xDF, 0x41,
0xF7, 0x15, 0x83, 0xD0, 0x75, 0x01, 0xB8, 0x70,
0x71, 0x12, 0x9A, 0x0A, 0xD9, 0x47, 0x32, 0xA5
},
{
0x72, 0x46, 0x42, 0xA7, 0x03, 0x2D, 0x10, 0x62,
0xB8, 0x9E, 0x52, 0xBE, 0xA3, 0x4B, 0x75, 0xDF,
0x7D, 0x8F, 0xE7, 0x72, 0xD9, 0xFE, 0x3C, 0x93,
0xDD, 0xF3, 0xC4, 0x54, 0x5A, 0xB5, 0xA9, 0x9B
},
{
0xAD, 0xE5, 0xEA, 0xA7, 0xE6, 0x1F, 0x67, 0x2D,
0x58, 0x7E, 0xA0, 0x3D, 0xAE, 0x7D, 0x7B, 0x55,
0x22, 0x9C, 0x01, 0xD0, 0x6B, 0xC0, 0xA5, 0x70,
0x14, 0x36, 0xCB, 0xD1, 0x83, 0x66, 0xA6, 0x26
},
{
0x01, 0x3B, 0x31, 0xEB, 0xD2, 0x28, 0xFC, 0xDD,
0xA5, 0x1F, 0xAB, 0xB0, 0x3B, 0xB0, 0x2D, 0x60,
0xAC, 0x20, 0xCA, 0x21, 0x5A, 0xAF, 0xA8, 0x3B,
0xDD, 0x85, 0x5E, 0x37, 0x55, 0xA3, 0x5F, 0x0B
},
{
0x33, 0x2E, 0xD4, 0x0B, 0xB1, 0x0D, 0xDE, 0x3C,
0x95, 0x4A, 0x75, 0xD7, 0xB8, 0x99, 0x9D, 0x4B,
0x26, 0xA1, 0xC0, 0x63, 0xC1, 0xDC, 0x6E, 0x32,
0xC1, 0xD9, 0x1B, 0xAB, 0x7B, 0xBB, 0x7D, 0x16
},
{
0xC7, 0xA1, 0x97, 0xB3, 0xA0, 0x5B, 0x56, 0x6B,
0xCC, 0x9F, 0xAC, 0xD2, 0x0E, 0x44, 0x1D, 0x6F,
0x6C, 0x28, 0x60, 0xAC, 0x96, 0x51, 0xCD, 0x51,
0xD6, 0xB9, 0xD2, 0xCD, 0xEE, 0xEA, 0x03, 0x90
},
{
0xBD, 0x9C, 0xF6, 0x4E, 0xA8, 0x95, 0x3C, 0x03,
0x71, 0x08, 0xE6, 0xF6, 0x54, 0x91, 0x4F, 0x39,
0x58, 0xB6, 0x8E, 0x29, 0xC1, 0x67, 0x00, 0xDC,
0x18, 0x4D, 0x94, 0xA2, 0x17, 0x08, 0xFF, 0x60
},
{
0x88, 0x35, 0xB0, 0xAC, 0x02, 0x11, 0x51, 0xDF,
0x71, 0x64, 0x74, 0xCE, 0x27, 0xCE, 0x4D, 0x3C,
0x15, 0xF0, 0xB2, 0xDA, 0xB4, 0x80, 0x03, 0xCF,
0x3F, 0x3E, 0xFD, 0x09, 0x45, 0x10, 0x6B, 0x9A
},
{
0x3B, 0xFE, 0xFA, 0x33, 0x01, 0xAA, 0x55, 0xC0,
0x80, 0x19, 0x0C, 0xFF, 0xDA, 0x8E, 0xAE, 0x51,
0xD9, 0xAF, 0x48, 0x8B, 0x4C, 0x1F, 0x24, 0xC3,
0xD9, 0xA7, 0x52, 0x42, 0xFD, 0x8E, 0xA0, 0x1D
},
{
0x08, 0x28, 0x4D, 0x14, 0x99, 0x3C, 0xD4, 0x7D,
0x53, 0xEB, 0xAE, 0xCF, 0x0D, 0xF0, 0x47, 0x8C,
0xC1, 0x82, 0xC8, 0x9C, 0x00, 0xE1, 0x85, 0x9C,
0x84, 0x85, 0x16, 0x86, 0xDD, 0xF2, 0xC1, 0xB7
},
{
0x1E, 0xD7, 0xEF, 0x9F, 0x04, 0xC2, 0xAC, 0x8D,
0xB6, 0xA8, 0x64, 0xDB, 0x13, 0x10, 0x87, 0xF2,
0x70, 0x65, 0x09, 0x8E, 0x69, 0xC3, 0xFE, 0x78,
0x71, 0x8D, 0x9B, 0x94, 0x7F, 0x4A, 0x39, 0xD0
},
{
0xC1, 0x61, 0xF2, 0xDC, 0xD5, 0x7E, 0x9C, 0x14,
0x39, 0xB3, 0x1A, 0x9D, 0xD4, 0x3D, 0x8F, 0x3D,
0x7D, 0xD8, 0xF0, 0xEB, 0x7C, 0xFA, 0xC6, 0xFB,
0x25, 0xA0, 0xF2, 0x8E, 0x30, 0x6F, 0x06, 0x61
},
{
0xC0, 0x19, 0x69, 0xAD, 0x34, 0xC5, 0x2C, 0xAF,
0x3D, 0xC4, 0xD8, 0x0D, 0x19, 0x73, 0x5C, 0x29,
0x73, 0x1A, 0xC6, 0xE7, 0xA9, 0x20, 0x85, 0xAB,
0x92, 0x50, 0xC4, 0x8D, 0xEA, 0x48, 0xA3, 0xFC
},
{
0x17, 0x20, 0xB3, 0x65, 0x56, 0x19, 0xD2, 0xA5,
0x2B, 0x35, 0x21, 0xAE, 0x0E, 0x49, 0xE3, 0x45,
0xCB, 0x33, 0x89, 0xEB, 0xD6, 0x20, 0x8A, 0xCA,
0xF9, 0xF1, 0x3F, 0xDA, 0xCC, 0xA8, 0xBE, 0x49
},
{
0x75, 0x62, 0x88, 0x36, 0x1C, 0x83, 0xE2, 0x4C,
0x61, 0x7C, 0xF9, 0x5C, 0x90, 0x5B, 0x22, 0xD0,
0x17, 0xCD, 0xC8, 0x6F, 0x0B, 0xF1, 0xD6, 0x58,
0xF4, 0x75, 0x6C, 0x73, 0x79, 0x87, 0x3B, 0x7F
},
{
0xE7, 0xD0, 0xED, 0xA3, 0x45, 0x26, 0x93, 0xB7,
0x52, 0xAB, 0xCD, 0xA1, 0xB5, 0x5E, 0x27, 0x6F,
0x82, 0x69, 0x8F, 0x5F, 0x16, 0x05, 0x40, 0x3E,
0xFF, 0x83, 0x0B, 0xEA, 0x00, 0x71, 0xA3, 0x94
},
{
0x2C, 0x82, 0xEC, 0xAA, 0x6B, 0x84, 0x80, 0x3E,
0x04, 0x4A, 0xF6, 0x31, 0x18, 0xAF, 0xE5, 0x44,
0x68, 0x7C, 0xB6, 0xE6, 0xC7, 0xDF, 0x49, 0xED,
0x76, 0x2D, 0xFD, 0x7C, 0x86, 0x93, 0xA1, 0xBC
},
{
0x61, 0x36, 0xCB, 0xF4, 0xB4, 0x41, 0x05, 0x6F,
0xA1, 0xE2, 0x72, 0x24, 0x98, 0x12, 0x5D, 0x6D,
0xED, 0x45, 0xE1, 0x7B, 0x52, 0x14, 0x39, 0x59,
0xC7, 0xF4, 0xD4, 0xE3, 0x95, 0x21, 0x8A, 0xC2
},
{
0x72, 0x1D, 0x32, 0x45, 0xAA, 0xFE, 0xF2, 0x7F,
0x6A, 0x62, 0x4F, 0x47, 0x95, 0x4B, 0x6C, 0x25,
0x50, 0x79, 0x52, 0x6F, 0xFA, 0x25, 0xE9, 0xFF,
0x77, 0xE5, 0xDC, 0xFF, 0x47, 0x3B, 0x15, 0x97
},
{
0x9D, 0xD2, 0xFB, 0xD8, 0xCE, 0xF1, 0x6C, 0x35,
0x3C, 0x0A, 0xC2, 0x11, 0x91, 0xD5, 0x09, 0xEB,
0x28, 0xDD, 0x9E, 0x3E, 0x0D, 0x8C, 0xEA, 0x5D,
0x26, 0xCA, 0x83, 0x93, 0x93, 0x85, 0x1C, 0x3A
},
{
0xB2, 0x39, 0x4C, 0xEA, 0xCD, 0xEB, 0xF2, 0x1B,
0xF9, 0xDF, 0x2C, 0xED, 0x98, 0xE5, 0x8F, 0x1C,
0x3A, 0x4B, 0xBB, 0xFF, 0x66, 0x0D, 0xD9, 0x00,
0xF6, 0x22, 0x02, 0xD6, 0x78, 0x5C, 0xC4, 0x6E
},
{
0x57, 0x08, 0x9F, 0x22, 0x27, 0x49, 0xAD, 0x78,
0x71, 0x76, 0x5F, 0x06, 0x2B, 0x11, 0x4F, 0x43,
0xBA, 0x20, 0xEC, 0x56, 0x42, 0x2A, 0x8B, 0x1E,
0x3F, 0x87, 0x19, 0x2C, 0x0E, 0xA7, 0x18, 0xC6
},
{
0xE4, 0x9A, 0x94, 0x59, 0x96, 0x1C, 0xD3, 0x3C,
0xDF, 0x4A, 0xAE, 0x1B, 0x10, 0x78, 0xA5, 0xDE,
0xA7, 0xC0, 0x40, 0xE0, 0xFE, 0xA3, 0x40, 0xC9,
0x3A, 0x72, 0x48, 0x72, 0xFC, 0x4A, 0xF8, 0x06
},
{
0xED, 0xE6, 0x7F, 0x72, 0x0E, 0xFF, 0xD2, 0xCA,
0x9C, 0x88, 0x99, 0x41, 0x52, 0xD0, 0x20, 0x1D,
0xEE, 0x6B, 0x0A, 0x2D, 0x2C, 0x07, 0x7A, 0xCA,
0x6D, 0xAE, 0x29, 0xF7, 0x3F, 0x8B, 0x63, 0x09
},
{
0xE0, 0xF4, 0x34, 0xBF, 0x22, 0xE3, 0x08, 0x80,
0x39, 0xC2, 0x1F, 0x71, 0x9F, 0xFC, 0x67, 0xF0,
0xF2, 0xCB, 0x5E, 0x98, 0xA7, 0xA0, 0x19, 0x4C,
0x76, 0xE9, 0x6B, 0xF4, 0xE8, 0xE1, 0x7E, 0x61
},
{
0x27, 0x7C, 0x04, 0xE2, 0x85, 0x34, 0x84, 0xA4,
0xEB, 0xA9, 0x10, 0xAD, 0x33, 0x6D, 0x01, 0xB4,
0x77, 0xB6, 0x7C, 0xC2, 0x00, 0xC5, 0x9F, 0x3C,
0x8D, 0x77, 0xEE, 0xF8, 0x49, 0x4F, 0x29, 0xCD
},
{
0x15, 0x6D, 0x57, 0x47, 0xD0, 0xC9, 0x9C, 0x7F,
0x27, 0x09, 0x7D, 0x7B, 0x7E, 0x00, 0x2B, 0x2E,
0x18, 0x5C, 0xB7, 0x2D, 0x8D, 0xD7, 0xEB, 0x42,
0x4A, 0x03, 0x21, 0x52, 0x81, 0x61, 0x21, 0x9F
},
{
0x20, 0xDD, 0xD1, 0xED, 0x9B, 0x1C, 0xA8, 0x03,
0x94, 0x6D, 0x64, 0xA8, 0x3A, 0xE4, 0x65, 0x9D,
0xA6, 0x7F, 0xBA, 0x7A, 0x1A, 0x3E, 0xDD, 0xB1,
0xE1, 0x03, 0xC0, 0xF5, 0xE0, 0x3E, 0x3A, 0x2C
},
{
0xF0, 0xAF, 0x60, 0x4D, 0x3D, 0xAB, 0xBF, 0x9A,
0x0F, 0x2A, 0x7D, 0x3D, 0xDA, 0x6B, 0xD3, 0x8B,
0xBA, 0x72, 0xC6, 0xD0, 0x9B, 0xE4, 0x94, 0xFC,
0xEF, 0x71, 0x3F, 0xF1, 0x01, 0x89, 0xB6, 0xE6
},
{
0x98, 0x02, 0xBB, 0x87, 0xDE, 0xF4, 0xCC, 0x10,
0xC4, 0xA5, 0xFD, 0x49, 0xAA, 0x58, 0xDF, 0xE2,
0xF3, 0xFD, 0xDB, 0x46, 0xB4, 0x70, 0x88, 0x14,
0xEA, 0xD8, 0x1D, 0x23, 0xBA, 0x95, 0x13, 0x9B
},
{
0x4F, 0x8C, 0xE1, 0xE5, 0x1D, 0x2F, 0xE7, 0xF2,
0x40, 0x43, 0xA9, 0x04, 0xD8, 0x98, 0xEB, 0xFC,
0x91, 0x97, 0x54, 0x18, 0x75, 0x34, 0x13, 0xAA,
0x09, 0x9B, 0x79, 0x5E, 0xCB, 0x35, 0xCE, 0xDB
},
{
0xBD, 0xDC, 0x65, 0x14, 0xD7, 0xEE, 0x6A, 0xCE,
0x0A, 0x4A, 0xC1, 0xD0, 0xE0, 0x68, 0x11, 0x22,
0x88, 0xCB, 0xCF, 0x56, 0x04, 0x54, 0x64, 0x27,
0x05, 0x63, 0x01, 0x77, 0xCB, 0xA6, 0x08, 0xBD
},
{
0xD6, 0x35, 0x99, 0x4F, 0x62, 0x91, 0x51, 0x7B,
0x02, 0x81, 0xFF, 0xDD, 0x49, 0x6A, 0xFA, 0x86,
0x27, 0x12, 0xE5, 0xB3, 0xC4, 0xE5, 0x2E, 0x4C,
0xD5, 0xFD, 0xAE, 0x8C, 0x0E, 0x72, 0xFB, 0x08
},
{
0x87, 0x8D, 0x9C, 0xA6, 0x00, 0xCF, 0x87, 0xE7,
0x69, 0xCC, 0x30, 0x5C, 0x1B, 0x35, 0x25, 0x51,
0x86, 0x61, 0x5A, 0x73, 0xA0, 0xDA, 0x61, 0x3B,
0x5F, 0x1C, 0x98, 0xDB, 0xF8, 0x12, 0x83, 0xEA
},
{
0xA6, 0x4E, 0xBE, 0x5D, 0xC1, 0x85, 0xDE, 0x9F,
0xDD, 0xE7, 0x60, 0x7B, 0x69, 0x98, 0x70, 0x2E,
0xB2, 0x34, 0x56, 0x18, 0x49, 0x57, 0x30, 0x7D,
0x2F, 0xA7, 0x2E, 0x87, 0xA4, 0x77, 0x02, 0xD6
},
{
0xCE, 0x50, 0xEA, 0xB7, 0xB5, 0xEB, 0x52, 0xBD,
0xC9, 0xAD, 0x8E, 0x5A, 0x48, 0x0A, 0xB7, 0x80,
0xCA, 0x93, 0x20, 0xE4, 0x43, 0x60, 0xB1, 0xFE,
0x37, 0xE0, 0x3F, 0x2F, 0x7A, 0xD7, 0xDE, 0x01
},
{
0xEE, 0xDD, 0xB7, 0xC0, 0xDB, 0x6E, 0x30, 0xAB,
0xE6, 0x6D, 0x79, 0xE3, 0x27, 0x51, 0x1E, 0x61,
0xFC, 0xEB, 0xBC, 0x29, 0xF1, 0x59, 0xB4, 0x0A,
0x86, 0xB0, 0x46, 0xEC, 0xF0, 0x51, 0x38, 0x23
},
{
0x78, 0x7F, 0xC9, 0x34, 0x40, 0xC1, 0xEC, 0x96,
0xB5, 0xAD, 0x01, 0xC1, 0x6C, 0xF7, 0x79, 0x16,
0xA1, 0x40, 0x5F, 0x94, 0x26, 0x35, 0x6E, 0xC9,
0x21, 0xD8, 0xDF, 0xF3, 0xEA, 0x63, 0xB7, 0xE0
},
{
0x7F, 0x0D, 0x5E, 0xAB, 0x47, 0xEE, 0xFD, 0xA6,
0x96, 0xC0, 0xBF, 0x0F, 0xBF, 0x86, 0xAB, 0x21,
0x6F, 0xCE, 0x46, 0x1E, 0x93, 0x03, 0xAB, 0xA6,
0xAC, 0x37, 0x41, 0x20, 0xE8, 0x90, 0xE8, 0xDF
},
{
0xB6, 0x80, 0x04, 0xB4, 0x2F, 0x14, 0xAD, 0x02,
0x9F, 0x4C, 0x2E, 0x03, 0xB1, 0xD5, 0xEB, 0x76,
0xD5, 0x71, 0x60, 0xE2, 0x64, 0x76, 0xD2, 0x11,
0x31, 0xBE, 0xF2, 0x0A, 0xDA, 0x7D, 0x27, 0xF4
},
{
0xB0, 0xC4, 0xEB, 0x18, 0xAE, 0x25, 0x0B, 0x51,
0xA4, 0x13, 0x82, 0xEA, 0xD9, 0x2D, 0x0D, 0xC7,
0x45, 0x5F, 0x93, 0x79, 0xFC, 0x98, 0x84, 0x42,
0x8E, 0x47, 0x70, 0x60, 0x8D, 0xB0, 0xFA, 0xEC
},
{
0xF9, 0x2B, 0x7A, 0x87, 0x0C, 0x05, 0x9F, 0x4D,
0x46, 0x46, 0x4C, 0x82, 0x4E, 0xC9, 0x63, 0x55,
0x14, 0x0B, 0xDC, 0xE6, 0x81, 0x32, 0x2C, 0xC3,
0xA9, 0x92, 0xFF, 0x10, 0x3E, 0x3F, 0xEA, 0x52
},
{
0x53, 0x64, 0x31, 0x26, 0x14, 0x81, 0x33, 0x98,
0xCC, 0x52, 0x5D, 0x4C, 0x4E, 0x14, 0x6E, 0xDE,
0xB3, 0x71, 0x26, 0x5F, 0xBA, 0x19, 0x13, 0x3A,
0x2C, 0x3D, 0x21, 0x59, 0x29, 0x8A, 0x17, 0x42
},
{
0xF6, 0x62, 0x0E, 0x68, 0xD3, 0x7F, 0xB2, 0xAF,
0x50, 0x00, 0xFC, 0x28, 0xE2, 0x3B, 0x83, 0x22,
0x97, 0xEC, 0xD8, 0xBC, 0xE9, 0x9E, 0x8B, 0xE4,
0xD0, 0x4E, 0x85, 0x30, 0x9E, 0x3D, 0x33, 0x74
},
{
0x53, 0x16, 0xA2, 0x79, 0x69, 0xD7, 0xFE, 0x04,
0xFF, 0x27, 0xB2, 0x83, 0x96, 0x1B, 0xFF, 0xC3,
0xBF, 0x5D, 0xFB, 0x32, 0xFB, 0x6A, 0x89, 0xD1,
0x01, 0xC6, 0xC3, 0xB1, 0x93, 0x7C, 0x28, 0x71
},
{
0x81, 0xD1, 0x66, 0x4F, 0xDF, 0x3C, 0xB3, 0x3C,
0x24, 0xEE, 0xBA, 0xC0, 0xBD, 0x64, 0x24, 0x4B,
0x77, 0xC4, 0xAB, 0xEA, 0x90, 0xBB, 0xE8, 0xB5,
0xEE, 0x0B, 0x2A, 0xAF, 0xCF, 0x2D, 0x6A, 0x53
},
{
0x34, 0x57, 0x82, 0xF2, 0x95, 0xB0, 0x88, 0x03,
0x52, 0xE9, 0x24, 0xA0, 0x46, 0x7B, 0x5F, 0xBC,
0x3E, 0x8F, 0x3B, 0xFB, 0xC3, 0xC7, 0xE4, 0x8B,
0x67, 0x09, 0x1F, 0xB5, 0xE8, 0x0A, 0x94, 0x42
},
{
0x79, 0x41, 0x11, 0xEA, 0x6C, 0xD6, 0x5E, 0x31,
0x1F, 0x74, 0xEE, 0x41, 0xD4, 0x76, 0xCB, 0x63,
0x2C, 0xE1, 0xE4, 0xB0, 0x51, 0xDC, 0x1D, 0x9E,
0x9D, 0x06, 0x1A, 0x19, 0xE1, 0xD0, 0xBB, 0x49
},
{
0x2A, 0x85, 0xDA, 0xF6, 0x13, 0x88, 0x16, 0xB9,
0x9B, 0xF8, 0xD0, 0x8B, 0xA2, 0x11, 0x4B, 0x7A,
0xB0, 0x79, 0x75, 0xA7, 0x84, 0x20, 0xC1, 0xA3,
0xB0, 0x6A, 0x77, 0x7C, 0x22, 0xDD, 0x8B, 0xCB
},
{
0x89, 0xB0, 0xD5, 0xF2, 0x89, 0xEC, 0x16, 0x40,
0x1A, 0x06, 0x9A, 0x96, 0x0D, 0x0B, 0x09, 0x3E,
0x62, 0x5D, 0xA3, 0xCF, 0x41, 0xEE, 0x29, 0xB5,
0x9B, 0x93, 0x0C, 0x58, 0x20, 0x14, 0x54, 0x55
},
{
0xD0, 0xFD, 0xCB, 0x54, 0x39, 0x43, 0xFC, 0x27,
0xD2, 0x08, 0x64, 0xF5, 0x21, 0x81, 0x47, 0x1B,
0x94, 0x2C, 0xC7, 0x7C, 0xA6, 0x75, 0xBC, 0xB3,
0x0D, 0xF3, 0x1D, 0x35, 0x8E, 0xF7, 0xB1, 0xEB
},
{
0xB1, 0x7E, 0xA8, 0xD7, 0x70, 0x63, 0xC7, 0x09,
0xD4, 0xDC, 0x6B, 0x87, 0x94, 0x13, 0xC3, 0x43,
0xE3, 0x79, 0x0E, 0x9E, 0x62, 0xCA, 0x85, 0xB7,
0x90, 0x0B, 0x08, 0x6F, 0x6B, 0x75, 0xC6, 0x72
},
{
0xE7, 0x1A, 0x3E, 0x2C, 0x27, 0x4D, 0xB8, 0x42,
0xD9, 0x21, 0x14, 0xF2, 0x17, 0xE2, 0xC0, 0xEA,
0xC8, 0xB4, 0x50, 0x93, 0xFD, 0xFD, 0x9D, 0xF4,
0xCA, 0x71, 0x62, 0x39, 0x48, 0x62, 0xD5, 0x01
},
{
0xC0, 0x47, 0x67, 0x59, 0xAB, 0x7A, 0xA3, 0x33,
0x23, 0x4F, 0x6B, 0x44, 0xF5, 0xFD, 0x85, 0x83,
0x90, 0xEC, 0x23, 0x69, 0x4C, 0x62, 0x2C, 0xB9,
0x86, 0xE7, 0x69, 0xC7, 0x8E, 0xDD, 0x73, 0x3E
},
{
0x9A, 0xB8, 0xEA, 0xBB, 0x14, 0x16, 0x43, 0x4D,
0x85, 0x39, 0x13, 0x41, 0xD5, 0x69, 0x93, 0xC5,
0x54, 0x58, 0x16, 0x7D, 0x44, 0x18, 0xB1, 0x9A,
0x0F, 0x2A, 0xD8, 0xB7, 0x9A, 0x83, 0xA7, 0x5B
},
{
0x79, 0x92, 0xD0, 0xBB, 0xB1, 0x5E, 0x23, 0x82,
0x6F, 0x44, 0x3E, 0x00, 0x50, 0x5D, 0x68, 0xD3,
0xED, 0x73, 0x72, 0x99, 0x5A, 0x5C, 0x3E, 0x49,
0x86, 0x54, 0x10, 0x2F, 0xBC, 0xD0, 0x96, 0x4E
},
{
0xC0, 0x21, 0xB3, 0x00, 0x85, 0x15, 0x14, 0x35,
0xDF, 0x33, 0xB0, 0x07, 0xCC, 0xEC, 0xC6, 0x9D,
0xF1, 0x26, 0x9F, 0x39, 0xBA, 0x25, 0x09, 0x2B,
0xED, 0x59, 0xD9, 0x32, 0xAC, 0x0F, 0xDC, 0x28
},
{
0x91, 0xA2, 0x5E, 0xC0, 0xEC, 0x0D, 0x9A, 0x56,
0x7F, 0x89, 0xC4, 0xBF, 0xE1, 0xA6, 0x5A, 0x0E,
0x43, 0x2D, 0x07, 0x06, 0x4B, 0x41, 0x90, 0xE2,
0x7D, 0xFB, 0x81, 0x90, 0x1F, 0xD3, 0x13, 0x9B
},
{
0x59, 0x50, 0xD3, 0x9A, 0x23, 0xE1, 0x54, 0x5F,
0x30, 0x12, 0x70, 0xAA, 0x1A, 0x12, 0xF2, 0xE6,
0xC4, 0x53, 0x77, 0x6E, 0x4D, 0x63, 0x55, 0xDE,
0x42, 0x5C, 0xC1, 0x53, 0xF9, 0x81, 0x88, 0x67
},
{
0xD7, 0x9F, 0x14, 0x72, 0x0C, 0x61, 0x0A, 0xF1,
0x79, 0xA3, 0x76, 0x5D, 0x4B, 0x7C, 0x09, 0x68,
0xF9, 0x77, 0x96, 0x2D, 0xBF, 0x65, 0x5B, 0x52,
0x12, 0x72, 0xB6, 0xF1, 0xE1, 0x94, 0x48, 0x8E
},
{
0xE9, 0x53, 0x1B, 0xFC, 0x8B, 0x02, 0x99, 0x5A,
0xEA, 0xA7, 0x5B, 0xA2, 0x70, 0x31, 0xFA, 0xDB,
0xCB, 0xF4, 0xA0, 0xDA, 0xB8, 0x96, 0x1D, 0x92,
0x96, 0xCD, 0x7E, 0x84, 0xD2, 0x5D, 0x60, 0x06
},
{
0x34, 0xE9, 0xC2, 0x6A, 0x01, 0xD7, 0xF1, 0x61,
0x81, 0xB4, 0x54, 0xA9, 0xD1, 0x62, 0x3C, 0x23,
0x3C, 0xB9, 0x9D, 0x31, 0xC6, 0x94, 0x65, 0x6E,
0x94, 0x13, 0xAC, 0xA3, 0xE9, 0x18, 0x69, 0x2F
},
{
0xD9, 0xD7, 0x42, 0x2F, 0x43, 0x7B, 0xD4, 0x39,
0xDD, 0xD4, 0xD8, 0x83, 0xDA, 0xE2, 0xA0, 0x83,
0x50, 0x17, 0x34, 0x14, 0xBE, 0x78, 0x15, 0x51,
0x33, 0xFF, 0xF1, 0x96, 0x4C, 0x3D, 0x79, 0x72
},
{
0x4A, 0xEE, 0x0C, 0x7A, 0xAF, 0x07, 0x54, 0x14,
0xFF, 0x17, 0x93, 0xEA, 0xD7, 0xEA, 0xCA, 0x60,
0x17, 0x75, 0xC6, 0x15, 0xDB, 0xD6, 0x0B, 0x64,
0x0B, 0x0A, 0x9F, 0x0C, 0xE5, 0x05, 0xD4, 0x35
},
{
0x6B, 0xFD, 0xD1, 0x54, 0x59, 0xC8, 0x3B, 0x99,
0xF0, 0x96, 0xBF, 0xB4, 0x9E, 0xE8, 0x7B, 0x06,
0x3D, 0x69, 0xC1, 0x97, 0x4C, 0x69, 0x28, 0xAC,
0xFC, 0xFB, 0x40, 0x99, 0xF8, 0xC4, 0xEF, 0x67
},
{
0x9F, 0xD1, 0xC4, 0x08, 0xFD, 0x75, 0xC3, 0x36,
0x19, 0x3A, 0x2A, 0x14, 0xD9, 0x4F, 0x6A, 0xF5,
0xAD, 0xF0, 0x50, 0xB8, 0x03, 0x87, 0xB4, 0xB0,
0x10, 0xFB, 0x29, 0xF4, 0xCC, 0x72, 0x70, 0x7C
},
{
0x13, 0xC8, 0x84, 0x80, 0xA5, 0xD0, 0x0D, 0x6C,
0x8C, 0x7A, 0xD2, 0x11, 0x0D, 0x76, 0xA8, 0x2D,
0x9B, 0x70, 0xF4, 0xFA, 0x66, 0x96, 0xD4, 0xE5,
0xDD, 0x42, 0xA0, 0x66, 0xDC, 0xAF, 0x99, 0x20
},
{
0x82, 0x0E, 0x72, 0x5E, 0xE2, 0x5F, 0xE8, 0xFD,
0x3A, 0x8D, 0x5A, 0xBE, 0x4C, 0x46, 0xC3, 0xBA,
0x88, 0x9D, 0xE6, 0xFA, 0x91, 0x91, 0xAA, 0x22,
0xBA, 0x67, 0xD5, 0x70, 0x54, 0x21, 0x54, 0x2B
},
{
0x32, 0xD9, 0x3A, 0x0E, 0xB0, 0x2F, 0x42, 0xFB,
0xBC, 0xAF, 0x2B, 0xAD, 0x00, 0x85, 0xB2, 0x82,
0xE4, 0x60, 0x46, 0xA4, 0xDF, 0x7A, 0xD1, 0x06,
0x57, 0xC9, 0xD6, 0x47, 0x63, 0x75, 0xB9, 0x3E
},
{
0xAD, 0xC5, 0x18, 0x79, 0x05, 0xB1, 0x66, 0x9C,
0xD8, 0xEC, 0x9C, 0x72, 0x1E, 0x19, 0x53, 0x78,
0x6B, 0x9D, 0x89, 0xA9, 0xBA, 0xE3, 0x07, 0x80,
0xF1, 0xE1, 0xEA, 0xB2, 0x4A, 0x00, 0x52, 0x3C
},
{
0xE9, 0x07, 0x56, 0xFF, 0x7F, 0x9A, 0xD8, 0x10,
0xB2, 0x39, 0xA1, 0x0C, 0xED, 0x2C, 0xF9, 0xB2,
0x28, 0x43, 0x54, 0xC1, 0xF8, 0xC7, 0xE0, 0xAC,
0xCC, 0x24, 0x61, 0xDC, 0x79, 0x6D, 0x6E, 0x89
},
{
0x12, 0x51, 0xF7, 0x6E, 0x56, 0x97, 0x84, 0x81,
0x87, 0x53, 0x59, 0x80, 0x1D, 0xB5, 0x89, 0xA0,
0xB2, 0x2F, 0x86, 0xD8, 0xD6, 0x34, 0xDC, 0x04,
0x50, 0x6F, 0x32, 0x2E, 0xD7, 0x8F, 0x17, 0xE8
},
{
0x3A, 0xFA, 0x89, 0x9F, 0xD9, 0x80, 0xE7, 0x3E,
0xCB, 0x7F, 0x4D, 0x8B, 0x8F, 0x29, 0x1D, 0xC9,
0xAF, 0x79, 0x6B, 0xC6, 0x5D, 0x27, 0xF9, 0x74,
0xC6, 0xF1, 0x93, 0xC9, 0x19, 0x1A, 0x09, 0xFD
},
{
0xAA, 0x30, 0x5B, 0xE2, 0x6E, 0x5D, 0xED, 0xDC,
0x3C, 0x10, 0x10, 0xCB, 0xC2, 0x13, 0xF9, 0x5F,
0x05, 0x1C, 0x78, 0x5C, 0x5B, 0x43, 0x1E, 0x6A,
0x7C, 0xD0, 0x48, 0xF1, 0x61, 0x78, 0x75, 0x28
},
{
0x8E, 0xA1, 0x88, 0x4F, 0xF3, 0x2E, 0x9D, 0x10,
0xF0, 0x39, 0xB4, 0x07, 0xD0, 0xD4, 0x4E, 0x7E,
0x67, 0x0A, 0xBD, 0x88, 0x4A, 0xEE, 0xE0, 0xFB,
0x75, 0x7A, 0xE9, 0x4E, 0xAA, 0x97, 0x37, 0x3D
},
{
0xD4, 0x82, 0xB2, 0x15, 0x5D, 0x4D, 0xEC, 0x6B,
0x47, 0x36, 0xA1, 0xF1, 0x61, 0x7B, 0x53, 0xAA,
0xA3, 0x73, 0x10, 0x27, 0x7D, 0x3F, 0xEF, 0x0C,
0x37, 0xAD, 0x41, 0x76, 0x8F, 0xC2, 0x35, 0xB4
},
{
0x4D, 0x41, 0x39, 0x71, 0x38, 0x7E, 0x7A, 0x88,
0x98, 0xA8, 0xDC, 0x2A, 0x27, 0x50, 0x07, 0x78,
0x53, 0x9E, 0xA2, 0x14, 0xA2, 0xDF, 0xE9, 0xB3,
0xD7, 0xE8, 0xEB, 0xDC, 0xE5, 0xCF, 0x3D, 0xB3
},
{
0x69, 0x6E, 0x5D, 0x46, 0xE6, 0xC5, 0x7E, 0x87,
0x96, 0xE4, 0x73, 0x5D, 0x08, 0x91, 0x6E, 0x0B,
0x79, 0x29, 0xB3, 0xCF, 0x29, 0x8C, 0x29, 0x6D,
0x22, 0xE9, 0xD3, 0x01, 0x96, 0x53, 0x37, 0x1C
},
{
0x1F, 0x56, 0x47, 0xC1, 0xD3, 0xB0, 0x88, 0x22,
0x88, 0x85, 0x86, 0x5C, 0x89, 0x40, 0x90, 0x8B,
0xF4, 0x0D, 0x1A, 0x82, 0x72, 0x82, 0x19, 0x73,
0xB1, 0x60, 0x00, 0x8E, 0x7A, 0x3C, 0xE2, 0xEB
},
{
0xB6, 0xE7, 0x6C, 0x33, 0x0F, 0x02, 0x1A, 0x5B,
0xDA, 0x65, 0x87, 0x50, 0x10, 0xB0, 0xED, 0xF0,
0x91, 0x26, 0xC0, 0xF5, 0x10, 0xEA, 0x84, 0x90,
0x48, 0x19, 0x20, 0x03, 0xAE, 0xF4, 0xC6, 0x1C
},
{
0x3C, 0xD9, 0x52, 0xA0, 0xBE, 0xAD, 0xA4, 0x1A,
0xBB, 0x42, 0x4C, 0xE4, 0x7F, 0x94, 0xB4, 0x2B,
0xE6, 0x4E, 0x1F, 0xFB, 0x0F, 0xD0, 0x78, 0x22,
0x76, 0x80, 0x79, 0x46, 0xD0, 0xD0, 0xBC, 0x55
},
{
0x98, 0xD9, 0x26, 0x77, 0x43, 0x9B, 0x41, 0xB7,
0xBB, 0x51, 0x33, 0x12, 0xAF, 0xB9, 0x2B, 0xCC,
0x8E, 0xE9, 0x68, 0xB2, 0xE3, 0xB2, 0x38, 0xCE,
0xCB, 0x9B, 0x0F, 0x34, 0xC9, 0xBB, 0x63, 0xD0
},
{
0xEC, 0xBC, 0xA2, 0xCF, 0x08, 0xAE, 0x57, 0xD5,
0x17, 0xAD, 0x16, 0x15, 0x8A, 0x32, 0xBF, 0xA7,
0xDC, 0x03, 0x82, 0xEA, 0xED, 0xA1, 0x28, 0xE9,
0x18, 0x86, 0x73, 0x4C, 0x24, 0xA0, 0xB2, 0x9D
},
{
0x94, 0x2C, 0xC7, 0xC0, 0xB5, 0x2E, 0x2B, 0x16,
0xA4, 0xB8, 0x9F, 0xA4, 0xFC, 0x7E, 0x0B, 0xF6,
0x09, 0xE2, 0x9A, 0x08, 0xC1, 0xA8, 0x54, 0x34,
0x52, 0xB7, 0x7C, 0x7B, 0xFD, 0x11, 0xBB, 0x28
},
{
0x8A, 0x06, 0x5D, 0x8B, 0x61, 0xA0, 0xDF, 0xFB,
0x17, 0x0D, 0x56, 0x27, 0x73, 0x5A, 0x76, 0xB0,
0xE9, 0x50, 0x60, 0x37, 0x80, 0x8C, 0xBA, 0x16,
0xC3, 0x45, 0x00, 0x7C, 0x9F, 0x79, 0xCF, 0x8F
},
{
0x1B, 0x9F, 0xA1, 0x97, 0x14, 0x65, 0x9C, 0x78,
0xFF, 0x41, 0x38, 0x71, 0x84, 0x92, 0x15, 0x36,
0x10, 0x29, 0xAC, 0x80, 0x2B, 0x1C, 0xBC, 0xD5,
0x4E, 0x40, 0x8B, 0xD8, 0x72, 0x87, 0xF8, 0x1F
},
{
0x8D, 0xAB, 0x07, 0x1B, 0xCD, 0x6C, 0x72, 0x92,
0xA9, 0xEF, 0x72, 0x7B, 0x4A, 0xE0, 0xD8, 0x67,
0x13, 0x30, 0x1D, 0xA8, 0x61, 0x8D, 0x9A, 0x48,
0xAD, 0xCE, 0x55, 0xF3, 0x03, 0xA8, 0x69, 0xA1
},
{
0x82, 0x53, 0xE3, 0xE7, 0xC7, 0xB6, 0x84, 0xB9,
0xCB, 0x2B, 0xEB, 0x01, 0x4C, 0xE3, 0x30, 0xFF,
0x3D, 0x99, 0xD1, 0x7A, 0xBB, 0xDB, 0xAB, 0xE4,
0xF4, 0xD6, 0x74, 0xDE, 0xD5, 0x3F, 0xFC, 0x6B
},
{
0xF1, 0x95, 0xF3, 0x21, 0xE9, 0xE3, 0xD6, 0xBD,
0x7D, 0x07, 0x45, 0x04, 0xDD, 0x2A, 0xB0, 0xE6,
0x24, 0x1F, 0x92, 0xE7, 0x84, 0xB1, 0xAA, 0x27,
0x1F, 0xF6, 0x48, 0xB1, 0xCA, 0xB6, 0xD7, 0xF6
},
{
0x27, 0xE4, 0xCC, 0x72, 0x09, 0x0F, 0x24, 0x12,
0x66, 0x47, 0x6A, 0x7C, 0x09, 0x49, 0x5F, 0x2D,
0xB1, 0x53, 0xD5, 0xBC, 0xBD, 0x76, 0x19, 0x03,
0xEF, 0x79, 0x27, 0x5E, 0xC5, 0x6B, 0x2E, 0xD8
},
{
0x89, 0x9C, 0x24, 0x05, 0x78, 0x8E, 0x25, 0xB9,
0x9A, 0x18, 0x46, 0x35, 0x5E, 0x64, 0x6D, 0x77,
0xCF, 0x40, 0x00, 0x83, 0x41, 0x5F, 0x7D, 0xC5,
0xAF, 0xE6, 0x9D, 0x6E, 0x17, 0xC0, 0x00, 0x23
},
{
0xA5, 0x9B, 0x78, 0xC4, 0x90, 0x57, 0x44, 0x07,
0x6B, 0xFE, 0xE8, 0x94, 0xDE, 0x70, 0x7D, 0x4F,
0x12, 0x0B, 0x5C, 0x68, 0x93, 0xEA, 0x04, 0x00,
0x29, 0x7D, 0x0B, 0xB8, 0x34, 0x72, 0x76, 0x32
},
{
0x59, 0xDC, 0x78, 0xB1, 0x05, 0x64, 0x97, 0x07,
0xA2, 0xBB, 0x44, 0x19, 0xC4, 0x8F, 0x00, 0x54,
0x00, 0xD3, 0x97, 0x3D, 0xE3, 0x73, 0x66, 0x10,
0x23, 0x04, 0x35, 0xB1, 0x04, 0x24, 0xB2, 0x4F
},
{
0xC0, 0x14, 0x9D, 0x1D, 0x7E, 0x7A, 0x63, 0x53,
0xA6, 0xD9, 0x06, 0xEF, 0xE7, 0x28, 0xF2, 0xF3,
0x29, 0xFE, 0x14, 0xA4, 0x14, 0x9A, 0x3E, 0xA7,
0x76, 0x09, 0xBC, 0x42, 0xB9, 0x75, 0xDD, 0xFA
},
{
0xA3, 0x2F, 0x24, 0x14, 0x74, 0xA6, 0xC1, 0x69,
0x32, 0xE9, 0x24, 0x3B, 0xE0, 0xCF, 0x09, 0xBC,
0xDC, 0x7E, 0x0C, 0xA0, 0xE7, 0xA6, 0xA1, 0xB9,
0xB1, 0xA0, 0xF0, 0x1E, 0x41, 0x50, 0x23, 0x77
},
{
0xB2, 0x39, 0xB2, 0xE4, 0xF8, 0x18, 0x41, 0x36,
0x1C, 0x13, 0x39, 0xF6, 0x8E, 0x2C, 0x35, 0x9F,
0x92, 0x9A, 0xF9, 0xAD, 0x9F, 0x34, 0xE0, 0x1A,
0xAB, 0x46, 0x31, 0xAD, 0x6D, 0x55, 0x00, 0xB0
},
{
0x85, 0xFB, 0x41, 0x9C, 0x70, 0x02, 0xA3, 0xE0,
0xB4, 0xB6, 0xEA, 0x09, 0x3B, 0x4C, 0x1A, 0xC6,
0x93, 0x66, 0x45, 0xB6, 0x5D, 0xAC, 0x5A, 0xC1,
0x5A, 0x85, 0x28, 0xB7, 0xB9, 0x4C, 0x17, 0x54
},
{
0x96, 0x19, 0x72, 0x06, 0x25, 0xF1, 0x90, 0xB9,
0x3A, 0x3F, 0xAD, 0x18, 0x6A, 0xB3, 0x14, 0x18,
0x96, 0x33, 0xC0, 0xD3, 0xA0, 0x1E, 0x6F, 0x9B,
0xC8, 0xC4, 0xA8, 0xF8, 0x2F, 0x38, 0x3D, 0xBF
},
{
0x7D, 0x62, 0x0D, 0x90, 0xFE, 0x69, 0xFA, 0x46,
0x9A, 0x65, 0x38, 0x38, 0x89, 0x70, 0xA1, 0xAA,
0x09, 0xBB, 0x48, 0xA2, 0xD5, 0x9B, 0x34, 0x7B,
0x97, 0xE8, 0xCE, 0x71, 0xF4, 0x8C, 0x7F, 0x46
},
{
0x29, 0x43, 0x83, 0x56, 0x85, 0x96, 0xFB, 0x37,
0xC7, 0x5B, 0xBA, 0xCD, 0x97, 0x9C, 0x5F, 0xF6,
0xF2, 0x0A, 0x55, 0x6B, 0xF8, 0x87, 0x9C, 0xC7,
0x29, 0x24, 0x85, 0x5D, 0xF9, 0xB8, 0x24, 0x0E
},
{
0x16, 0xB1, 0x8A, 0xB3, 0x14, 0x35, 0x9C, 0x2B,
0x83, 0x3C, 0x1C, 0x69, 0x86, 0xD4, 0x8C, 0x55,
0xA9, 0xFC, 0x97, 0xCD, 0xE9, 0xA3, 0xC1, 0xF1,
0x0A, 0x31, 0x77, 0x14, 0x0F, 0x73, 0xF7, 0x38
},
{
0x8C, 0xBB, 0xDD, 0x14, 0xBC, 0x33, 0xF0, 0x4C,
0xF4, 0x58, 0x13, 0xE4, 0xA1, 0x53, 0xA2, 0x73,
0xD3, 0x6A, 0xDA, 0xD5, 0xCE, 0x71, 0xF4, 0x99,
0xEE, 0xB8, 0x7F, 0xB8, 0xAC, 0x63, 0xB7, 0x29
},
{
0x69, 0xC9, 0xA4, 0x98, 0xDB, 0x17, 0x4E, 0xCA,
0xEF, 0xCC, 0x5A, 0x3A, 0xC9, 0xFD, 0xED, 0xF0,
0xF8, 0x13, 0xA5, 0xBE, 0xC7, 0x27, 0xF1, 0xE7,
0x75, 0xBA, 0xBD, 0xEC, 0x77, 0x18, 0x81, 0x6E
},
{
0xB4, 0x62, 0xC3, 0xBE, 0x40, 0x44, 0x8F, 0x1D,
0x4F, 0x80, 0x62, 0x62, 0x54, 0xE5, 0x35, 0xB0,
0x8B, 0xC9, 0xCD, 0xCF, 0xF5, 0x99, 0xA7, 0x68,
0x57, 0x8D, 0x4B, 0x28, 0x81, 0xA8, 0xE3, 0xF0
},
{
0x55, 0x3E, 0x9D, 0x9C, 0x5F, 0x36, 0x0A, 0xC0,
0xB7, 0x4A, 0x7D, 0x44, 0xE5, 0xA3, 0x91, 0xDA,
0xD4, 0xCE, 0xD0, 0x3E, 0x0C, 0x24, 0x18, 0x3B,
0x7E, 0x8E, 0xCA, 0xBD, 0xF1, 0x71, 0x5A, 0x64
},
{
0x7A, 0x7C, 0x55, 0xA5, 0x6F, 0xA9, 0xAE, 0x51,
0xE6, 0x55, 0xE0, 0x19, 0x75, 0xD8, 0xA6, 0xFF,
0x4A, 0xE9, 0xE4, 0xB4, 0x86, 0xFC, 0xBE, 0x4E,
0xAC, 0x04, 0x45, 0x88, 0xF2, 0x45, 0xEB, 0xEA
},
{
0x2A, 0xFD, 0xF3, 0xC8, 0x2A, 0xBC, 0x48, 0x67,
0xF5, 0xDE, 0x11, 0x12, 0x86, 0xC2, 0xB3, 0xBE,
0x7D, 0x6E, 0x48, 0x65, 0x7B, 0xA9, 0x23, 0xCF,
0xBF, 0x10, 0x1A, 0x6D, 0xFC, 0xF9, 0xDB, 0x9A
},
{
0x41, 0x03, 0x7D, 0x2E, 0xDC, 0xDC, 0xE0, 0xC4,
0x9B, 0x7F, 0xB4, 0xA6, 0xAA, 0x09, 0x99, 0xCA,
0x66, 0x97, 0x6C, 0x74, 0x83, 0xAF, 0xE6, 0x31,
0xD4, 0xED, 0xA2, 0x83, 0x14, 0x4F, 0x6D, 0xFC
},
{
0xC4, 0x46, 0x6F, 0x84, 0x97, 0xCA, 0x2E, 0xEB,
0x45, 0x83, 0xA0, 0xB0, 0x8E, 0x9D, 0x9A, 0xC7,
0x43, 0x95, 0x70, 0x9F, 0xDA, 0x10, 0x9D, 0x24,
0xF2, 0xE4, 0x46, 0x21, 0x96, 0x77, 0x9C, 0x5D
},
{
0x75, 0xF6, 0x09, 0x33, 0x8A, 0xA6, 0x7D, 0x96,
0x9A, 0x2A, 0xE2, 0xA2, 0x36, 0x2B, 0x2D, 0xA9,
0xD7, 0x7C, 0x69, 0x5D, 0xFD, 0x1D, 0xF7, 0x22,
0x4A, 0x69, 0x01, 0xDB, 0x93, 0x2C, 0x33, 0x64
},
{
0x68, 0x60, 0x6C, 0xEB, 0x98, 0x9D, 0x54, 0x88,
0xFC, 0x7C, 0xF6, 0x49, 0xF3, 0xD7, 0xC2, 0x72,
0xEF, 0x05, 0x5D, 0xA1, 0xA9, 0x3F, 0xAE, 0xCD,
0x55, 0xFE, 0x06, 0xF6, 0x96, 0x70, 0x98, 0xCA
},
{
0x44, 0x34, 0x6B, 0xDE, 0xB7, 0xE0, 0x52, 0xF6,
0x25, 0x50, 0x48, 0xF0, 0xD9, 0xB4, 0x2C, 0x42,
0x5B, 0xAB, 0x9C, 0x3D, 0xD2, 0x41, 0x68, 0x21,
0x2C, 0x3E, 0xCF, 0x1E, 0xBF, 0x34, 0xE6, 0xAE
},
{
0x8E, 0x9C, 0xF6, 0xE1, 0xF3, 0x66, 0x47, 0x1F,
0x2A, 0xC7, 0xD2, 0xEE, 0x9B, 0x5E, 0x62, 0x66,
0xFD, 0xA7, 0x1F, 0x8F, 0x2E, 0x41, 0x09, 0xF2,
0x23, 0x7E, 0xD5, 0xF8, 0x81, 0x3F, 0xC7, 0x18
},
{
0x84, 0xBB, 0xEB, 0x84, 0x06, 0xD2, 0x50, 0x95,
0x1F, 0x8C, 0x1B, 0x3E, 0x86, 0xA7, 0xC0, 0x10,
0x08, 0x29, 0x21, 0x83, 0x3D, 0xFD, 0x95, 0x55,
0xA2, 0xF9, 0x09, 0xB1, 0x08, 0x6E, 0xB4, 0xB8
},
{
0xEE, 0x66, 0x6F, 0x3E, 0xEF, 0x0F, 0x7E, 0x2A,
0x9C, 0x22, 0x29, 0x58, 0xC9, 0x7E, 0xAF, 0x35,
0xF5, 0x1C, 0xED, 0x39, 0x3D, 0x71, 0x44, 0x85,
0xAB, 0x09, 0xA0, 0x69, 0x34, 0x0F, 0xDF, 0x88
},
{
0xC1, 0x53, 0xD3, 0x4A, 0x65, 0xC4, 0x7B, 0x4A,
0x62, 0xC5, 0xCA, 0xCF, 0x24, 0x01, 0x09, 0x75,
0xD0, 0x35, 0x6B, 0x2F, 0x32, 0xC8, 0xF5, 0xDA,
0x53, 0x0D, 0x33, 0x88, 0x16, 0xAD, 0x5D, 0xE6
},
{
0x9F, 0xC5, 0x45, 0x01, 0x09, 0xE1, 0xB7, 0x79,
0xF6, 0xC7, 0xAE, 0x79, 0xD5, 0x6C, 0x27, 0x63,
0x5C, 0x8D, 0xD4, 0x26, 0xC5, 0xA9, 0xD5, 0x4E,
0x25, 0x78, 0xDB, 0x98, 0x9B, 0x8C, 0x3B, 0x4E
},
{
0xD1, 0x2B, 0xF3, 0x73, 0x2E, 0xF4, 0xAF, 0x5C,
0x22, 0xFA, 0x90, 0x35, 0x6A, 0xF8, 0xFC, 0x50,
0xFC, 0xB4, 0x0F, 0x8F, 0x2E, 0xA5, 0xC8, 0x59,
0x47, 0x37, 0xA3, 0xB3, 0xD5, 0xAB, 0xDB, 0xD7
},
{
0x11, 0x03, 0x0B, 0x92, 0x89, 0xBB, 0xA5, 0xAF,
0x65, 0x26, 0x06, 0x72, 0xAB, 0x6F, 0xEE, 0x88,
0xB8, 0x74, 0x20, 0xAC, 0xEF, 0x4A, 0x17, 0x89,
0xA2, 0x07, 0x3B, 0x7E, 0xC2, 0xF2, 0xA0, 0x9E
},
{
0x69, 0xCB, 0x19, 0x2B, 0x84, 0x44, 0x00, 0x5C,
0x8C, 0x0C, 0xEB, 0x12, 0xC8, 0x46, 0x86, 0x07,
0x68, 0x18, 0x8C, 0xDA, 0x0A, 0xEC, 0x27, 0xA9,
0xC8, 0xA5, 0x5C, 0xDE, 0xE2, 0x12, 0x36, 0x32
},
{
0xDB, 0x44, 0x4C, 0x15, 0x59, 0x7B, 0x5F, 0x1A,
0x03, 0xD1, 0xF9, 0xED, 0xD1, 0x6E, 0x4A, 0x9F,
0x43, 0xA6, 0x67, 0xCC, 0x27, 0x51, 0x75, 0xDF,
0xA2, 0xB7, 0x04, 0xE3, 0xBB, 0x1A, 0x9B, 0x83
},
{
0x3F, 0xB7, 0x35, 0x06, 0x1A, 0xBC, 0x51, 0x9D,
0xFE, 0x97, 0x9E, 0x54, 0xC1, 0xEE, 0x5B, 0xFA,
0xD0, 0xA9, 0xD8, 0x58, 0xB3, 0x31, 0x5B, 0xAD,
0x34, 0xBD, 0xE9, 0x99, 0xEF, 0xD7, 0x24, 0xDD
},
};
static const uint8_t blake2b_keyed_kat[BLAKE2_KAT_LENGTH][BLAKE2B_512_SIZE] =
{
{
0x10, 0xEB, 0xB6, 0x77, 0x00, 0xB1, 0x86, 0x8E,
0xFB, 0x44, 0x17, 0x98, 0x7A, 0xCF, 0x46, 0x90,
0xAE, 0x9D, 0x97, 0x2F, 0xB7, 0xA5, 0x90, 0xC2,
0xF0, 0x28, 0x71, 0x79, 0x9A, 0xAA, 0x47, 0x86,
0xB5, 0xE9, 0x96, 0xE8, 0xF0, 0xF4, 0xEB, 0x98,
0x1F, 0xC2, 0x14, 0xB0, 0x05, 0xF4, 0x2D, 0x2F,
0xF4, 0x23, 0x34, 0x99, 0x39, 0x16, 0x53, 0xDF,
0x7A, 0xEF, 0xCB, 0xC1, 0x3F, 0xC5, 0x15, 0x68
},
{
0x96, 0x1F, 0x6D, 0xD1, 0xE4, 0xDD, 0x30, 0xF6,
0x39, 0x01, 0x69, 0x0C, 0x51, 0x2E, 0x78, 0xE4,
0xB4, 0x5E, 0x47, 0x42, 0xED, 0x19, 0x7C, 0x3C,
0x5E, 0x45, 0xC5, 0x49, 0xFD, 0x25, 0xF2, 0xE4,
0x18, 0x7B, 0x0B, 0xC9, 0xFE, 0x30, 0x49, 0x2B,
0x16, 0xB0, 0xD0, 0xBC, 0x4E, 0xF9, 0xB0, 0xF3,
0x4C, 0x70, 0x03, 0xFA, 0xC0, 0x9A, 0x5E, 0xF1,
0x53, 0x2E, 0x69, 0x43, 0x02, 0x34, 0xCE, 0xBD
},
{
0xDA, 0x2C, 0xFB, 0xE2, 0xD8, 0x40, 0x9A, 0x0F,
0x38, 0x02, 0x61, 0x13, 0x88, 0x4F, 0x84, 0xB5,
0x01, 0x56, 0x37, 0x1A, 0xE3, 0x04, 0xC4, 0x43,
0x01, 0x73, 0xD0, 0x8A, 0x99, 0xD9, 0xFB, 0x1B,
0x98, 0x31, 0x64, 0xA3, 0x77, 0x07, 0x06, 0xD5,
0x37, 0xF4, 0x9E, 0x0C, 0x91, 0x6D, 0x9F, 0x32,
0xB9, 0x5C, 0xC3, 0x7A, 0x95, 0xB9, 0x9D, 0x85,
0x74, 0x36, 0xF0, 0x23, 0x2C, 0x88, 0xA9, 0x65
},
{
0x33, 0xD0, 0x82, 0x5D, 0xDD, 0xF7, 0xAD, 0xA9,
0x9B, 0x0E, 0x7E, 0x30, 0x71, 0x04, 0xAD, 0x07,
0xCA, 0x9C, 0xFD, 0x96, 0x92, 0x21, 0x4F, 0x15,
0x61, 0x35, 0x63, 0x15, 0xE7, 0x84, 0xF3, 0xE5,
0xA1, 0x7E, 0x36, 0x4A, 0xE9, 0xDB, 0xB1, 0x4C,
0xB2, 0x03, 0x6D, 0xF9, 0x32, 0xB7, 0x7F, 0x4B,
0x29, 0x27, 0x61, 0x36, 0x5F, 0xB3, 0x28, 0xDE,
0x7A, 0xFD, 0xC6, 0xD8, 0x99, 0x8F, 0x5F, 0xC1
},
{
0xBE, 0xAA, 0x5A, 0x3D, 0x08, 0xF3, 0x80, 0x71,
0x43, 0xCF, 0x62, 0x1D, 0x95, 0xCD, 0x69, 0x05,
0x14, 0xD0, 0xB4, 0x9E, 0xFF, 0xF9, 0xC9, 0x1D,
0x24, 0xB5, 0x92, 0x41, 0xEC, 0x0E, 0xEF, 0xA5,
0xF6, 0x01, 0x96, 0xD4, 0x07, 0x04, 0x8B, 0xBA,
0x8D, 0x21, 0x46, 0x82, 0x8E, 0xBC, 0xB0, 0x48,
0x8D, 0x88, 0x42, 0xFD, 0x56, 0xBB, 0x4F, 0x6D,
0xF8, 0xE1, 0x9C, 0x4B, 0x4D, 0xAA, 0xB8, 0xAC
},
{
0x09, 0x80, 0x84, 0xB5, 0x1F, 0xD1, 0x3D, 0xEA,
0xE5, 0xF4, 0x32, 0x0D, 0xE9, 0x4A, 0x68, 0x8E,
0xE0, 0x7B, 0xAE, 0xA2, 0x80, 0x04, 0x86, 0x68,
0x9A, 0x86, 0x36, 0x11, 0x7B, 0x46, 0xC1, 0xF4,
0xC1, 0xF6, 0xAF, 0x7F, 0x74, 0xAE, 0x7C, 0x85,
0x76, 0x00, 0x45, 0x6A, 0x58, 0xA3, 0xAF, 0x25,
0x1D, 0xC4, 0x72, 0x3A, 0x64, 0xCC, 0x7C, 0x0A,
0x5A, 0xB6, 0xD9, 0xCA, 0xC9, 0x1C, 0x20, 0xBB
},
{
0x60, 0x44, 0x54, 0x0D, 0x56, 0x08, 0x53, 0xEB,
0x1C, 0x57, 0xDF, 0x00, 0x77, 0xDD, 0x38, 0x10,
0x94, 0x78, 0x1C, 0xDB, 0x90, 0x73, 0xE5, 0xB1,
0xB3, 0xD3, 0xF6, 0xC7, 0x82, 0x9E, 0x12, 0x06,
0x6B, 0xBA, 0xCA, 0x96, 0xD9, 0x89, 0xA6, 0x90,
0xDE, 0x72, 0xCA, 0x31, 0x33, 0xA8, 0x36, 0x52,
0xBA, 0x28, 0x4A, 0x6D, 0x62, 0x94, 0x2B, 0x27,
0x1F, 0xFA, 0x26, 0x20, 0xC9, 0xE7, 0x5B, 0x1F
},
{
0x7A, 0x8C, 0xFE, 0x9B, 0x90, 0xF7, 0x5F, 0x7E,
0xCB, 0x3A, 0xCC, 0x05, 0x3A, 0xAE, 0xD6, 0x19,
0x31, 0x12, 0xB6, 0xF6, 0xA4, 0xAE, 0xEB, 0x3F,
0x65, 0xD3, 0xDE, 0x54, 0x19, 0x42, 0xDE, 0xB9,
0xE2, 0x22, 0x81, 0x52, 0xA3, 0xC4, 0xBB, 0xBE,
0x72, 0xFC, 0x3B, 0x12, 0x62, 0x95, 0x28, 0xCF,
0xBB, 0x09, 0xFE, 0x63, 0x0F, 0x04, 0x74, 0x33,
0x9F, 0x54, 0xAB, 0xF4, 0x53, 0xE2, 0xED, 0x52
},
{
0x38, 0x0B, 0xEA, 0xF6, 0xEA, 0x7C, 0xC9, 0x36,
0x5E, 0x27, 0x0E, 0xF0, 0xE6, 0xF3, 0xA6, 0x4F,
0xB9, 0x02, 0xAC, 0xAE, 0x51, 0xDD, 0x55, 0x12,
0xF8, 0x42, 0x59, 0xAD, 0x2C, 0x91, 0xF4, 0xBC,
0x41, 0x08, 0xDB, 0x73, 0x19, 0x2A, 0x5B, 0xBF,
0xB0, 0xCB, 0xCF, 0x71, 0xE4, 0x6C, 0x3E, 0x21,
0xAE, 0xE1, 0xC5, 0xE8, 0x60, 0xDC, 0x96, 0xE8,
0xEB, 0x0B, 0x7B, 0x84, 0x26, 0xE6, 0xAB, 0xE9
},
{
0x60, 0xFE, 0x3C, 0x45, 0x35, 0xE1, 0xB5, 0x9D,
0x9A, 0x61, 0xEA, 0x85, 0x00, 0xBF, 0xAC, 0x41,
0xA6, 0x9D, 0xFF, 0xB1, 0xCE, 0xAD, 0xD9, 0xAC,
0xA3, 0x23, 0xE9, 0xA6, 0x25, 0xB6, 0x4D, 0xA5,
0x76, 0x3B, 0xAD, 0x72, 0x26, 0xDA, 0x02, 0xB9,
0xC8, 0xC4, 0xF1, 0xA5, 0xDE, 0x14, 0x0A, 0xC5,
0xA6, 0xC1, 0x12, 0x4E, 0x4F, 0x71, 0x8C, 0xE0,
0xB2, 0x8E, 0xA4, 0x73, 0x93, 0xAA, 0x66, 0x37
},
{
0x4F, 0xE1, 0x81, 0xF5, 0x4A, 0xD6, 0x3A, 0x29,
0x83, 0xFE, 0xAA, 0xF7, 0x7D, 0x1E, 0x72, 0x35,
0xC2, 0xBE, 0xB1, 0x7F, 0xA3, 0x28, 0xB6, 0xD9,
0x50, 0x5B, 0xDA, 0x32, 0x7D, 0xF1, 0x9F, 0xC3,
0x7F, 0x02, 0xC4, 0xB6, 0xF0, 0x36, 0x8C, 0xE2,
0x31, 0x47, 0x31, 0x3A, 0x8E, 0x57, 0x38, 0xB5,
0xFA, 0x2A, 0x95, 0xB2, 0x9D, 0xE1, 0xC7, 0xF8,
0x26, 0x4E, 0xB7, 0x7B, 0x69, 0xF5, 0x85, 0xCD
},
{
0xF2, 0x28, 0x77, 0x3C, 0xE3, 0xF3, 0xA4, 0x2B,
0x5F, 0x14, 0x4D, 0x63, 0x23, 0x7A, 0x72, 0xD9,
0x96, 0x93, 0xAD, 0xB8, 0x83, 0x7D, 0x0E, 0x11,
0x2A, 0x8A, 0x0F, 0x8F, 0xFF, 0xF2, 0xC3, 0x62,
0x85, 0x7A, 0xC4, 0x9C, 0x11, 0xEC, 0x74, 0x0D,
0x15, 0x00, 0x74, 0x9D, 0xAC, 0x9B, 0x1F, 0x45,
0x48, 0x10, 0x8B, 0xF3, 0x15, 0x57, 0x94, 0xDC,
0xC9, 0xE4, 0x08, 0x28, 0x49, 0xE2, 0xB8, 0x5B
},
{
0x96, 0x24, 0x52, 0xA8, 0x45, 0x5C, 0xC5, 0x6C,
0x85, 0x11, 0x31, 0x7E, 0x3B, 0x1F, 0x3B, 0x2C,
0x37, 0xDF, 0x75, 0xF5, 0x88, 0xE9, 0x43, 0x25,
0xFD, 0xD7, 0x70, 0x70, 0x35, 0x9C, 0xF6, 0x3A,
0x9A, 0xE6, 0xE9, 0x30, 0x93, 0x6F, 0xDF, 0x8E,
0x1E, 0x08, 0xFF, 0xCA, 0x44, 0x0C, 0xFB, 0x72,
0xC2, 0x8F, 0x06, 0xD8, 0x9A, 0x21, 0x51, 0xD1,
0xC4, 0x6C, 0xD5, 0xB2, 0x68, 0xEF, 0x85, 0x63
},
{
0x43, 0xD4, 0x4B, 0xFA, 0x18, 0x76, 0x8C, 0x59,
0x89, 0x6B, 0xF7, 0xED, 0x17, 0x65, 0xCB, 0x2D,
0x14, 0xAF, 0x8C, 0x26, 0x02, 0x66, 0x03, 0x90,
0x99, 0xB2, 0x5A, 0x60, 0x3E, 0x4D, 0xDC, 0x50,
0x39, 0xD6, 0xEF, 0x3A, 0x91, 0x84, 0x7D, 0x10,
0x88, 0xD4, 0x01, 0xC0, 0xC7, 0xE8, 0x47, 0x78,
0x1A, 0x8A, 0x59, 0x0D, 0x33, 0xA3, 0xC6, 0xCB,
0x4D, 0xF0, 0xFA, 0xB1, 0xC2, 0xF2, 0x23, 0x55
},
{
0xDC, 0xFF, 0xA9, 0xD5, 0x8C, 0x2A, 0x4C, 0xA2,
0xCD, 0xBB, 0x0C, 0x7A, 0xA4, 0xC4, 0xC1, 0xD4,
0x51, 0x65, 0x19, 0x00, 0x89, 0xF4, 0xE9, 0x83,
0xBB, 0x1C, 0x2C, 0xAB, 0x4A, 0xAE, 0xFF, 0x1F,
0xA2, 0xB5, 0xEE, 0x51, 0x6F, 0xEC, 0xD7, 0x80,
0x54, 0x02, 0x40, 0xBF, 0x37, 0xE5, 0x6C, 0x8B,
0xCC, 0xA7, 0xFA, 0xB9, 0x80, 0xE1, 0xE6, 0x1C,
0x94, 0x00, 0xD8, 0xA9, 0xA5, 0xB1, 0x4A, 0xC6
},
{
0x6F, 0xBF, 0x31, 0xB4, 0x5A, 0xB0, 0xC0, 0xB8,
0xDA, 0xD1, 0xC0, 0xF5, 0xF4, 0x06, 0x13, 0x79,
0x91, 0x2D, 0xDE, 0x5A, 0xA9, 0x22, 0x09, 0x9A,
0x03, 0x0B, 0x72, 0x5C, 0x73, 0x34, 0x6C, 0x52,
0x42, 0x91, 0xAD, 0xEF, 0x89, 0xD2, 0xF6, 0xFD,
0x8D, 0xFC, 0xDA, 0x6D, 0x07, 0xDA, 0xD8, 0x11,
0xA9, 0x31, 0x45, 0x36, 0xC2, 0x91, 0x5E, 0xD4,
0x5D, 0xA3, 0x49, 0x47, 0xE8, 0x3D, 0xE3, 0x4E
},
{
0xA0, 0xC6, 0x5B, 0xDD, 0xDE, 0x8A, 0xDE, 0xF5,
0x72, 0x82, 0xB0, 0x4B, 0x11, 0xE7, 0xBC, 0x8A,
0xAB, 0x10, 0x5B, 0x99, 0x23, 0x1B, 0x75, 0x0C,
0x02, 0x1F, 0x4A, 0x73, 0x5C, 0xB1, 0xBC, 0xFA,
0xB8, 0x75, 0x53, 0xBB, 0xA3, 0xAB, 0xB0, 0xC3,
0xE6, 0x4A, 0x0B, 0x69, 0x55, 0x28, 0x51, 0x85,
0xA0, 0xBD, 0x35, 0xFB, 0x8C, 0xFD, 0xE5, 0x57,
0x32, 0x9B, 0xEB, 0xB1, 0xF6, 0x29, 0xEE, 0x93
},
{
0xF9, 0x9D, 0x81, 0x55, 0x50, 0x55, 0x8E, 0x81,
0xEC, 0xA2, 0xF9, 0x67, 0x18, 0xAE, 0xD1, 0x0D,
0x86, 0xF3, 0xF1, 0xCF, 0xB6, 0x75, 0xCC, 0xE0,
0x6B, 0x0E, 0xFF, 0x02, 0xF6, 0x17, 0xC5, 0xA4,
0x2C, 0x5A, 0xA7, 0x60, 0x27, 0x0F, 0x26, 0x79,
0xDA, 0x26, 0x77, 0xC5, 0xAE, 0xB9, 0x4F, 0x11,
0x42, 0x27, 0x7F, 0x21, 0xC7, 0xF7, 0x9F, 0x3C,
0x4F, 0x0C, 0xCE, 0x4E, 0xD8, 0xEE, 0x62, 0xB1
},
{
0x95, 0x39, 0x1D, 0xA8, 0xFC, 0x7B, 0x91, 0x7A,
0x20, 0x44, 0xB3, 0xD6, 0xF5, 0x37, 0x4E, 0x1C,
0xA0, 0x72, 0xB4, 0x14, 0x54, 0xD5, 0x72, 0xC7,
0x35, 0x6C, 0x05, 0xFD, 0x4B, 0xC1, 0xE0, 0xF4,
0x0B, 0x8B, 0xB8, 0xB4, 0xA9, 0xF6, 0xBC, 0xE9,
0xBE, 0x2C, 0x46, 0x23, 0xC3, 0x99, 0xB0, 0xDC,
0xA0, 0xDA, 0xB0, 0x5C, 0xB7, 0x28, 0x1B, 0x71,
0xA2, 0x1B, 0x0E, 0xBC, 0xD9, 0xE5, 0x56, 0x70
},
{
0x04, 0xB9, 0xCD, 0x3D, 0x20, 0xD2, 0x21, 0xC0,
0x9A, 0xC8, 0x69, 0x13, 0xD3, 0xDC, 0x63, 0x04,
0x19, 0x89, 0xA9, 0xA1, 0xE6, 0x94, 0xF1, 0xE6,
0x39, 0xA3, 0xBA, 0x7E, 0x45, 0x18, 0x40, 0xF7,
0x50, 0xC2, 0xFC, 0x19, 0x1D, 0x56, 0xAD, 0x61,
0xF2, 0xE7, 0x93, 0x6B, 0xC0, 0xAC, 0x8E, 0x09,
0x4B, 0x60, 0xCA, 0xEE, 0xD8, 0x78, 0xC1, 0x87,
0x99, 0x04, 0x54, 0x02, 0xD6, 0x1C, 0xEA, 0xF9
},
{
0xEC, 0x0E, 0x0E, 0xF7, 0x07, 0xE4, 0xED, 0x6C,
0x0C, 0x66, 0xF9, 0xE0, 0x89, 0xE4, 0x95, 0x4B,
0x05, 0x80, 0x30, 0xD2, 0xDD, 0x86, 0x39, 0x8F,
0xE8, 0x40, 0x59, 0x63, 0x1F, 0x9E, 0xE5, 0x91,
0xD9, 0xD7, 0x73, 0x75, 0x35, 0x51, 0x49, 0x17,
0x8C, 0x0C, 0xF8, 0xF8, 0xE7, 0xC4, 0x9E, 0xD2,
0xA5, 0xE4, 0xF9, 0x54, 0x88, 0xA2, 0x24, 0x70,
0x67, 0xC2, 0x08, 0x51, 0x0F, 0xAD, 0xC4, 0x4C
},
{
0x9A, 0x37, 0xCC, 0xE2, 0x73, 0xB7, 0x9C, 0x09,
0x91, 0x36, 0x77, 0x51, 0x0E, 0xAF, 0x76, 0x88,
0xE8, 0x9B, 0x33, 0x14, 0xD3, 0x53, 0x2F, 0xD2,
0x76, 0x4C, 0x39, 0xDE, 0x02, 0x2A, 0x29, 0x45,
0xB5, 0x71, 0x0D, 0x13, 0x51, 0x7A, 0xF8, 0xDD,
0xC0, 0x31, 0x66, 0x24, 0xE7, 0x3B, 0xEC, 0x1C,
0xE6, 0x7D, 0xF1, 0x52, 0x28, 0x30, 0x20, 0x36,
0xF3, 0x30, 0xAB, 0x0C, 0xB4, 0xD2, 0x18, 0xDD
},
{
0x4C, 0xF9, 0xBB, 0x8F, 0xB3, 0xD4, 0xDE, 0x8B,
0x38, 0xB2, 0xF2, 0x62, 0xD3, 0xC4, 0x0F, 0x46,
0xDF, 0xE7, 0x47, 0xE8, 0xFC, 0x0A, 0x41, 0x4C,
0x19, 0x3D, 0x9F, 0xCF, 0x75, 0x31, 0x06, 0xCE,
0x47, 0xA1, 0x8F, 0x17, 0x2F, 0x12, 0xE8, 0xA2,
0xF1, 0xC2, 0x67, 0x26, 0x54, 0x53, 0x58, 0xE5,
0xEE, 0x28, 0xC9, 0xE2, 0x21, 0x3A, 0x87, 0x87,
0xAA, 0xFB, 0xC5, 0x16, 0xD2, 0x34, 0x31, 0x52
},
{
0x64, 0xE0, 0xC6, 0x3A, 0xF9, 0xC8, 0x08, 0xFD,
0x89, 0x31, 0x37, 0x12, 0x98, 0x67, 0xFD, 0x91,
0x93, 0x9D, 0x53, 0xF2, 0xAF, 0x04, 0xBE, 0x4F,
0xA2, 0x68, 0x00, 0x61, 0x00, 0x06, 0x9B, 0x2D,
0x69, 0xDA, 0xA5, 0xC5, 0xD8, 0xED, 0x7F, 0xDD,
0xCB, 0x2A, 0x70, 0xEE, 0xEC, 0xDF, 0x2B, 0x10,
0x5D, 0xD4, 0x6A, 0x1E, 0x3B, 0x73, 0x11, 0x72,
0x8F, 0x63, 0x9A, 0xB4, 0x89, 0x32, 0x6B, 0xC9
},
{
0x5E, 0x9C, 0x93, 0x15, 0x8D, 0x65, 0x9B, 0x2D,
0xEF, 0x06, 0xB0, 0xC3, 0xC7, 0x56, 0x50, 0x45,
0x54, 0x26, 0x62, 0xD6, 0xEE, 0xE8, 0xA9, 0x6A,
0x89, 0xB7, 0x8A, 0xDE, 0x09, 0xFE, 0x8B, 0x3D,
0xCC, 0x09, 0x6D, 0x4F, 0xE4, 0x88, 0x15, 0xD8,
0x8D, 0x8F, 0x82, 0x62, 0x01, 0x56, 0x60, 0x2A,
0xF5, 0x41, 0x95, 0x5E, 0x1F, 0x6C, 0xA3, 0x0D,
0xCE, 0x14, 0xE2, 0x54, 0xC3, 0x26, 0xB8, 0x8F
},
{
0x77, 0x75, 0xDF, 0xF8, 0x89, 0x45, 0x8D, 0xD1,
0x1A, 0xEF, 0x41, 0x72, 0x76, 0x85, 0x3E, 0x21,
0x33, 0x5E, 0xB8, 0x8E, 0x4D, 0xEC, 0x9C, 0xFB,
0x4E, 0x9E, 0xDB, 0x49, 0x82, 0x00, 0x88, 0x55,
0x1A, 0x2C, 0xA6, 0x03, 0x39, 0xF1, 0x20, 0x66,
0x10, 0x11, 0x69, 0xF0, 0xDF, 0xE8, 0x4B, 0x09,
0x8F, 0xDD, 0xB1, 0x48, 0xD9, 0xDA, 0x6B, 0x3D,
0x61, 0x3D, 0xF2, 0x63, 0x88, 0x9A, 0xD6, 0x4B
},
{
0xF0, 0xD2, 0x80, 0x5A, 0xFB, 0xB9, 0x1F, 0x74,
0x39, 0x51, 0x35, 0x1A, 0x6D, 0x02, 0x4F, 0x93,
0x53, 0xA2, 0x3C, 0x7C, 0xE1, 0xFC, 0x2B, 0x05,
0x1B, 0x3A, 0x8B, 0x96, 0x8C, 0x23, 0x3F, 0x46,
0xF5, 0x0F, 0x80, 0x6E, 0xCB, 0x15, 0x68, 0xFF,
0xAA, 0x0B, 0x60, 0x66, 0x1E, 0x33, 0x4B, 0x21,
0xDD, 0xE0, 0x4F, 0x8F, 0xA1, 0x55, 0xAC, 0x74,
0x0E, 0xEB, 0x42, 0xE2, 0x0B, 0x60, 0xD7, 0x64
},
{
0x86, 0xA2, 0xAF, 0x31, 0x6E, 0x7D, 0x77, 0x54,
0x20, 0x1B, 0x94, 0x2E, 0x27, 0x53, 0x64, 0xAC,
0x12, 0xEA, 0x89, 0x62, 0xAB, 0x5B, 0xD8, 0xD7,
0xFB, 0x27, 0x6D, 0xC5, 0xFB, 0xFF, 0xC8, 0xF9,
0xA2, 0x8C, 0xAE, 0x4E, 0x48, 0x67, 0xDF, 0x67,
0x80, 0xD9, 0xB7, 0x25, 0x24, 0x16, 0x09, 0x27,
0xC8, 0x55, 0xDA, 0x5B, 0x60, 0x78, 0xE0, 0xB5,
0x54, 0xAA, 0x91, 0xE3, 0x1C, 0xB9, 0xCA, 0x1D
},
{
0x10, 0xBD, 0xF0, 0xCA, 0xA0, 0x80, 0x27, 0x05,
0xE7, 0x06, 0x36, 0x9B, 0xAF, 0x8A, 0x3F, 0x79,
0xD7, 0x2C, 0x0A, 0x03, 0xA8, 0x06, 0x75, 0xA7,
0xBB, 0xB0, 0x0B, 0xE3, 0xA4, 0x5E, 0x51, 0x64,
0x24, 0xD1, 0xEE, 0x88, 0xEF, 0xB5, 0x6F, 0x6D,
0x57, 0x77, 0x54, 0x5A, 0xE6, 0xE2, 0x77, 0x65,
0xC3, 0xA8, 0xF5, 0xE4, 0x93, 0xFC, 0x30, 0x89,
0x15, 0x63, 0x89, 0x33, 0xA1, 0xDF, 0xEE, 0x55
},
{
0xB0, 0x17, 0x81, 0x09, 0x2B, 0x17, 0x48, 0x45,
0x9E, 0x2E, 0x4E, 0xC1, 0x78, 0x69, 0x66, 0x27,
0xBF, 0x4E, 0xBA, 0xFE, 0xBB, 0xA7, 0x74, 0xEC,
0xF0, 0x18, 0xB7, 0x9A, 0x68, 0xAE, 0xB8, 0x49,
0x17, 0xBF, 0x0B, 0x84, 0xBB, 0x79, 0xD1, 0x7B,
0x74, 0x31, 0x51, 0x14, 0x4C, 0xD6, 0x6B, 0x7B,
0x33, 0xA4, 0xB9, 0xE5, 0x2C, 0x76, 0xC4, 0xE1,
0x12, 0x05, 0x0F, 0xF5, 0x38, 0x5B, 0x7F, 0x0B
},
{
0xC6, 0xDB, 0xC6, 0x1D, 0xEC, 0x6E, 0xAE, 0xAC,
0x81, 0xE3, 0xD5, 0xF7, 0x55, 0x20, 0x3C, 0x8E,
0x22, 0x05, 0x51, 0x53, 0x4A, 0x0B, 0x2F, 0xD1,
0x05, 0xA9, 0x18, 0x89, 0x94, 0x5A, 0x63, 0x85,
0x50, 0x20, 0x4F, 0x44, 0x09, 0x3D, 0xD9, 0x98,
0xC0, 0x76, 0x20, 0x5D, 0xFF, 0xAD, 0x70, 0x3A,
0x0E, 0x5C, 0xD3, 0xC7, 0xF4, 0x38, 0xA7, 0xE6,
0x34, 0xCD, 0x59, 0xFE, 0xDE, 0xDB, 0x53, 0x9E
},
{
0xEB, 0xA5, 0x1A, 0xCF, 0xFB, 0x4C, 0xEA, 0x31,
0xDB, 0x4B, 0x8D, 0x87, 0xE9, 0xBF, 0x7D, 0xD4,
0x8F, 0xE9, 0x7B, 0x02, 0x53, 0xAE, 0x67, 0xAA,
0x58, 0x0F, 0x9A, 0xC4, 0xA9, 0xD9, 0x41, 0xF2,
0xBE, 0xA5, 0x18, 0xEE, 0x28, 0x68, 0x18, 0xCC,
0x9F, 0x63, 0x3F, 0x2A, 0x3B, 0x9F, 0xB6, 0x8E,
0x59, 0x4B, 0x48, 0xCD, 0xD6, 0xD5, 0x15, 0xBF,
0x1D, 0x52, 0xBA, 0x6C, 0x85, 0xA2, 0x03, 0xA7
},
{
0x86, 0x22, 0x1F, 0x3A, 0xDA, 0x52, 0x03, 0x7B,
0x72, 0x22, 0x4F, 0x10, 0x5D, 0x79, 0x99, 0x23,
0x1C, 0x5E, 0x55, 0x34, 0xD0, 0x3D, 0xA9, 0xD9,
0xC0, 0xA1, 0x2A, 0xCB, 0x68, 0x46, 0x0C, 0xD3,
0x75, 0xDA, 0xF8, 0xE2, 0x43, 0x86, 0x28, 0x6F,
0x96, 0x68, 0xF7, 0x23, 0x26, 0xDB, 0xF9, 0x9B,
0xA0, 0x94, 0x39, 0x24, 0x37, 0xD3, 0x98, 0xE9,
0x5B, 0xB8, 0x16, 0x1D, 0x71, 0x7F, 0x89, 0x91
},
{
0x55, 0x95, 0xE0, 0x5C, 0x13, 0xA7, 0xEC, 0x4D,
0xC8, 0xF4, 0x1F, 0xB7, 0x0C, 0xB5, 0x0A, 0x71,
0xBC, 0xE1, 0x7C, 0x02, 0x4F, 0xF6, 0xDE, 0x7A,
0xF6, 0x18, 0xD0, 0xCC, 0x4E, 0x9C, 0x32, 0xD9,
0x57, 0x0D, 0x6D, 0x3E, 0xA4, 0x5B, 0x86, 0x52,
0x54, 0x91, 0x03, 0x0C, 0x0D, 0x8F, 0x2B, 0x18,
0x36, 0xD5, 0x77, 0x8C, 0x1C, 0xE7, 0x35, 0xC1,
0x77, 0x07, 0xDF, 0x36, 0x4D, 0x05, 0x43, 0x47
},
{
0xCE, 0x0F, 0x4F, 0x6A, 0xCA, 0x89, 0x59, 0x0A,
0x37, 0xFE, 0x03, 0x4D, 0xD7, 0x4D, 0xD5, 0xFA,
0x65, 0xEB, 0x1C, 0xBD, 0x0A, 0x41, 0x50, 0x8A,
0xAD, 0xDC, 0x09, 0x35, 0x1A, 0x3C, 0xEA, 0x6D,
0x18, 0xCB, 0x21, 0x89, 0xC5, 0x4B, 0x70, 0x0C,
0x00, 0x9F, 0x4C, 0xBF, 0x05, 0x21, 0xC7, 0xEA,
0x01, 0xBE, 0x61, 0xC5, 0xAE, 0x09, 0xCB, 0x54,
0xF2, 0x7B, 0xC1, 0xB4, 0x4D, 0x65, 0x8C, 0x82
},
{
0x7E, 0xE8, 0x0B, 0x06, 0xA2, 0x15, 0xA3, 0xBC,
0xA9, 0x70, 0xC7, 0x7C, 0xDA, 0x87, 0x61, 0x82,
0x2B, 0xC1, 0x03, 0xD4, 0x4F, 0xA4, 0xB3, 0x3F,
0x4D, 0x07, 0xDC, 0xB9, 0x97, 0xE3, 0x6D, 0x55,
0x29, 0x8B, 0xCE, 0xAE, 0x12, 0x24, 0x1B, 0x3F,
0xA0, 0x7F, 0xA6, 0x3B, 0xE5, 0x57, 0x60, 0x68,
0xDA, 0x38, 0x7B, 0x8D, 0x58, 0x59, 0xAE, 0xAB,
0x70, 0x13, 0x69, 0x84, 0x8B, 0x17, 0x6D, 0x42
},
{
0x94, 0x0A, 0x84, 0xB6, 0xA8, 0x4D, 0x10, 0x9A,
0xAB, 0x20, 0x8C, 0x02, 0x4C, 0x6C, 0xE9, 0x64,
0x76, 0x76, 0xBA, 0x0A, 0xAA, 0x11, 0xF8, 0x6D,
0xBB, 0x70, 0x18, 0xF9, 0xFD, 0x22, 0x20, 0xA6,
0xD9, 0x01, 0xA9, 0x02, 0x7F, 0x9A, 0xBC, 0xF9,
0x35, 0x37, 0x27, 0x27, 0xCB, 0xF0, 0x9E, 0xBD,
0x61, 0xA2, 0xA2, 0xEE, 0xB8, 0x76, 0x53, 0xE8,
0xEC, 0xAD, 0x1B, 0xAB, 0x85, 0xDC, 0x83, 0x27
},
{
0x20, 0x20, 0xB7, 0x82, 0x64, 0xA8, 0x2D, 0x9F,
0x41, 0x51, 0x14, 0x1A, 0xDB, 0xA8, 0xD4, 0x4B,
0xF2, 0x0C, 0x5E, 0xC0, 0x62, 0xEE, 0xE9, 0xB5,
0x95, 0xA1, 0x1F, 0x9E, 0x84, 0x90, 0x1B, 0xF1,
0x48, 0xF2, 0x98, 0xE0, 0xC9, 0xF8, 0x77, 0x7D,
0xCD, 0xBC, 0x7C, 0xC4, 0x67, 0x0A, 0xAC, 0x35,
0x6C, 0xC2, 0xAD, 0x8C, 0xCB, 0x16, 0x29, 0xF1,
0x6F, 0x6A, 0x76, 0xBC, 0xEF, 0xBE, 0xE7, 0x60
},
{
0xD1, 0xB8, 0x97, 0xB0, 0xE0, 0x75, 0xBA, 0x68,
0xAB, 0x57, 0x2A, 0xDF, 0x9D, 0x9C, 0x43, 0x66,
0x63, 0xE4, 0x3E, 0xB3, 0xD8, 0xE6, 0x2D, 0x92,
0xFC, 0x49, 0xC9, 0xBE, 0x21, 0x4E, 0x6F, 0x27,
0x87, 0x3F, 0xE2, 0x15, 0xA6, 0x51, 0x70, 0xE6,
0xBE, 0xA9, 0x02, 0x40, 0x8A, 0x25, 0xB4, 0x95,
0x06, 0xF4, 0x7B, 0xAB, 0xD0, 0x7C, 0xEC, 0xF7,
0x11, 0x3E, 0xC1, 0x0C, 0x5D, 0xD3, 0x12, 0x52
},
{
0xB1, 0x4D, 0x0C, 0x62, 0xAB, 0xFA, 0x46, 0x9A,
0x35, 0x71, 0x77, 0xE5, 0x94, 0xC1, 0x0C, 0x19,
0x42, 0x43, 0xED, 0x20, 0x25, 0xAB, 0x8A, 0xA5,
0xAD, 0x2F, 0xA4, 0x1A, 0xD3, 0x18, 0xE0, 0xFF,
0x48, 0xCD, 0x5E, 0x60, 0xBE, 0xC0, 0x7B, 0x13,
0x63, 0x4A, 0x71, 0x1D, 0x23, 0x26, 0xE4, 0x88,
0xA9, 0x85, 0xF3, 0x1E, 0x31, 0x15, 0x33, 0x99,
0xE7, 0x30, 0x88, 0xEF, 0xC8, 0x6A, 0x5C, 0x55
},
{
0x41, 0x69, 0xC5, 0xCC, 0x80, 0x8D, 0x26, 0x97,
0xDC, 0x2A, 0x82, 0x43, 0x0D, 0xC2, 0x3E, 0x3C,
0xD3, 0x56, 0xDC, 0x70, 0xA9, 0x45, 0x66, 0x81,
0x05, 0x02, 0xB8, 0xD6, 0x55, 0xB3, 0x9A, 0xBF,
0x9E, 0x7F, 0x90, 0x2F, 0xE7, 0x17, 0xE0, 0x38,
0x92, 0x19, 0x85, 0x9E, 0x19, 0x45, 0xDF, 0x1A,
0xF6, 0xAD, 0xA4, 0x2E, 0x4C, 0xCD, 0xA5, 0x5A,
0x19, 0x7B, 0x71, 0x00, 0xA3, 0x0C, 0x30, 0xA1
},
{
0x25, 0x8A, 0x4E, 0xDB, 0x11, 0x3D, 0x66, 0xC8,
0x39, 0xC8, 0xB1, 0xC9, 0x1F, 0x15, 0xF3, 0x5A,
0xDE, 0x60, 0x9F, 0x11, 0xCD, 0x7F, 0x86, 0x81,
0xA4, 0x04, 0x5B, 0x9F, 0xEF, 0x7B, 0x0B, 0x24,
0xC8, 0x2C, 0xDA, 0x06, 0xA5, 0xF2, 0x06, 0x7B,
0x36, 0x88, 0x25, 0xE3, 0x91, 0x4E, 0x53, 0xD6,
0x94, 0x8E, 0xDE, 0x92, 0xEF, 0xD6, 0xE8, 0x38,
0x7F, 0xA2, 0xE5, 0x37, 0x23, 0x9B, 0x5B, 0xEE
},
{
0x79, 0xD2, 0xD8, 0x69, 0x6D, 0x30, 0xF3, 0x0F,
0xB3, 0x46, 0x57, 0x76, 0x11, 0x71, 0xA1, 0x1E,
0x6C, 0x3F, 0x1E, 0x64, 0xCB, 0xE7, 0xBE, 0xBE,
0xE1, 0x59, 0xCB, 0x95, 0xBF, 0xAF, 0x81, 0x2B,
0x4F, 0x41, 0x1E, 0x2F, 0x26, 0xD9, 0xC4, 0x21,
0xDC, 0x2C, 0x28, 0x4A, 0x33, 0x42, 0xD8, 0x23,
0xEC, 0x29, 0x38, 0x49, 0xE4, 0x2D, 0x1E, 0x46,
0xB0, 0xA4, 0xAC, 0x1E, 0x3C, 0x86, 0xAB, 0xAA
},
{
0x8B, 0x94, 0x36, 0x01, 0x0D, 0xC5, 0xDE, 0xE9,
0x92, 0xAE, 0x38, 0xAE, 0xA9, 0x7F, 0x2C, 0xD6,
0x3B, 0x94, 0x6D, 0x94, 0xFE, 0xDD, 0x2E, 0xC9,
0x67, 0x1D, 0xCD, 0xE3, 0xBD, 0x4C, 0xE9, 0x56,
0x4D, 0x55, 0x5C, 0x66, 0xC1, 0x5B, 0xB2, 0xB9,
0x00, 0xDF, 0x72, 0xED, 0xB6, 0xB8, 0x91, 0xEB,
0xCA, 0xDF, 0xEF, 0xF6, 0x3C, 0x9E, 0xA4, 0x03,
0x6A, 0x99, 0x8B, 0xE7, 0x97, 0x39, 0x81, 0xE7
},
{
0xC8, 0xF6, 0x8E, 0x69, 0x6E, 0xD2, 0x82, 0x42,
0xBF, 0x99, 0x7F, 0x5B, 0x3B, 0x34, 0x95, 0x95,
0x08, 0xE4, 0x2D, 0x61, 0x38, 0x10, 0xF1, 0xE2,
0xA4, 0x35, 0xC9, 0x6E, 0xD2, 0xFF, 0x56, 0x0C,
0x70, 0x22, 0xF3, 0x61, 0xA9, 0x23, 0x4B, 0x98,
0x37, 0xFE, 0xEE, 0x90, 0xBF, 0x47, 0x92, 0x2E,
0xE0, 0xFD, 0x5F, 0x8D, 0xDF, 0x82, 0x37, 0x18,
0xD8, 0x6D, 0x1E, 0x16, 0xC6, 0x09, 0x00, 0x71
},
{
0xB0, 0x2D, 0x3E, 0xEE, 0x48, 0x60, 0xD5, 0x86,
0x8B, 0x2C, 0x39, 0xCE, 0x39, 0xBF, 0xE8, 0x10,
0x11, 0x29, 0x05, 0x64, 0xDD, 0x67, 0x8C, 0x85,
0xE8, 0x78, 0x3F, 0x29, 0x30, 0x2D, 0xFC, 0x13,
0x99, 0xBA, 0x95, 0xB6, 0xB5, 0x3C, 0xD9, 0xEB,
0xBF, 0x40, 0x0C, 0xCA, 0x1D, 0xB0, 0xAB, 0x67,
0xE1, 0x9A, 0x32, 0x5F, 0x2D, 0x11, 0x58, 0x12,
0xD2, 0x5D, 0x00, 0x97, 0x8A, 0xD1, 0xBC, 0xA4
},
{
0x76, 0x93, 0xEA, 0x73, 0xAF, 0x3A, 0xC4, 0xDA,
0xD2, 0x1C, 0xA0, 0xD8, 0xDA, 0x85, 0xB3, 0x11,
0x8A, 0x7D, 0x1C, 0x60, 0x24, 0xCF, 0xAF, 0x55,
0x76, 0x99, 0x86, 0x82, 0x17, 0xBC, 0x0C, 0x2F,
0x44, 0xA1, 0x99, 0xBC, 0x6C, 0x0E, 0xDD, 0x51,
0x97, 0x98, 0xBA, 0x05, 0xBD, 0x5B, 0x1B, 0x44,
0x84, 0x34, 0x6A, 0x47, 0xC2, 0xCA, 0xDF, 0x6B,
0xF3, 0x0B, 0x78, 0x5C, 0xC8, 0x8B, 0x2B, 0xAF
},
{
0xA0, 0xE5, 0xC1, 0xC0, 0x03, 0x1C, 0x02, 0xE4,
0x8B, 0x7F, 0x09, 0xA5, 0xE8, 0x96, 0xEE, 0x9A,
0xEF, 0x2F, 0x17, 0xFC, 0x9E, 0x18, 0xE9, 0x97,
0xD7, 0xF6, 0xCA, 0xC7, 0xAE, 0x31, 0x64, 0x22,
0xC2, 0xB1, 0xE7, 0x79, 0x84, 0xE5, 0xF3, 0xA7,
0x3C, 0xB4, 0x5D, 0xEE, 0xD5, 0xD3, 0xF8, 0x46,
0x00, 0x10, 0x5E, 0x6E, 0xE3, 0x8F, 0x2D, 0x09,
0x0C, 0x7D, 0x04, 0x42, 0xEA, 0x34, 0xC4, 0x6D
},
{
0x41, 0xDA, 0xA6, 0xAD, 0xCF, 0xDB, 0x69, 0xF1,
0x44, 0x0C, 0x37, 0xB5, 0x96, 0x44, 0x01, 0x65,
0xC1, 0x5A, 0xDA, 0x59, 0x68, 0x13, 0xE2, 0xE2,
0x2F, 0x06, 0x0F, 0xCD, 0x55, 0x1F, 0x24, 0xDE,
0xE8, 0xE0, 0x4B, 0xA6, 0x89, 0x03, 0x87, 0x88,
0x6C, 0xEE, 0xC4, 0xA7, 0xA0, 0xD7, 0xFC, 0x6B,
0x44, 0x50, 0x63, 0x92, 0xEC, 0x38, 0x22, 0xC0,
0xD8, 0xC1, 0xAC, 0xFC, 0x7D, 0x5A, 0xEB, 0xE8
},
{
0x14, 0xD4, 0xD4, 0x0D, 0x59, 0x84, 0xD8, 0x4C,
0x5C, 0xF7, 0x52, 0x3B, 0x77, 0x98, 0xB2, 0x54,
0xE2, 0x75, 0xA3, 0xA8, 0xCC, 0x0A, 0x1B, 0xD0,
0x6E, 0xBC, 0x0B, 0xEE, 0x72, 0x68, 0x56, 0xAC,
0xC3, 0xCB, 0xF5, 0x16, 0xFF, 0x66, 0x7C, 0xDA,
0x20, 0x58, 0xAD, 0x5C, 0x34, 0x12, 0x25, 0x44,
0x60, 0xA8, 0x2C, 0x92, 0x18, 0x70, 0x41, 0x36,
0x3C, 0xC7, 0x7A, 0x4D, 0xC2, 0x15, 0xE4, 0x87
},
{
0xD0, 0xE7, 0xA1, 0xE2, 0xB9, 0xA4, 0x47, 0xFE,
0xE8, 0x3E, 0x22, 0x77, 0xE9, 0xFF, 0x80, 0x10,
0xC2, 0xF3, 0x75, 0xAE, 0x12, 0xFA, 0x7A, 0xAA,
0x8C, 0xA5, 0xA6, 0x31, 0x78, 0x68, 0xA2, 0x6A,
0x36, 0x7A, 0x0B, 0x69, 0xFB, 0xC1, 0xCF, 0x32,
0xA5, 0x5D, 0x34, 0xEB, 0x37, 0x06, 0x63, 0x01,
0x6F, 0x3D, 0x21, 0x10, 0x23, 0x0E, 0xBA, 0x75,
0x40, 0x28, 0xA5, 0x6F, 0x54, 0xAC, 0xF5, 0x7C
},
{
0xE7, 0x71, 0xAA, 0x8D, 0xB5, 0xA3, 0xE0, 0x43,
0xE8, 0x17, 0x8F, 0x39, 0xA0, 0x85, 0x7B, 0xA0,
0x4A, 0x3F, 0x18, 0xE4, 0xAA, 0x05, 0x74, 0x3C,
0xF8, 0xD2, 0x22, 0xB0, 0xB0, 0x95, 0x82, 0x53,
0x50, 0xBA, 0x42, 0x2F, 0x63, 0x38, 0x2A, 0x23,
0xD9, 0x2E, 0x41, 0x49, 0x07, 0x4E, 0x81, 0x6A,
0x36, 0xC1, 0xCD, 0x28, 0x28, 0x4D, 0x14, 0x62,
0x67, 0x94, 0x0B, 0x31, 0xF8, 0x81, 0x8E, 0xA2
},
{
0xFE, 0xB4, 0xFD, 0x6F, 0x9E, 0x87, 0xA5, 0x6B,
0xEF, 0x39, 0x8B, 0x32, 0x84, 0xD2, 0xBD, 0xA5,
0xB5, 0xB0, 0xE1, 0x66, 0x58, 0x3A, 0x66, 0xB6,
0x1E, 0x53, 0x84, 0x57, 0xFF, 0x05, 0x84, 0x87,
0x2C, 0x21, 0xA3, 0x29, 0x62, 0xB9, 0x92, 0x8F,
0xFA, 0xB5, 0x8D, 0xE4, 0xAF, 0x2E, 0xDD, 0x4E,
0x15, 0xD8, 0xB3, 0x55, 0x70, 0x52, 0x32, 0x07,
0xFF, 0x4E, 0x2A, 0x5A, 0xA7, 0x75, 0x4C, 0xAA
},
{
0x46, 0x2F, 0x17, 0xBF, 0x00, 0x5F, 0xB1, 0xC1,
0xB9, 0xE6, 0x71, 0x77, 0x9F, 0x66, 0x52, 0x09,
0xEC, 0x28, 0x73, 0xE3, 0xE4, 0x11, 0xF9, 0x8D,
0xAB, 0xF2, 0x40, 0xA1, 0xD5, 0xEC, 0x3F, 0x95,
0xCE, 0x67, 0x96, 0xB6, 0xFC, 0x23, 0xFE, 0x17,
0x19, 0x03, 0xB5, 0x02, 0x02, 0x34, 0x67, 0xDE,
0xC7, 0x27, 0x3F, 0xF7, 0x48, 0x79, 0xB9, 0x29,
0x67, 0xA2, 0xA4, 0x3A, 0x5A, 0x18, 0x3D, 0x33
},
{
0xD3, 0x33, 0x81, 0x93, 0xB6, 0x45, 0x53, 0xDB,
0xD3, 0x8D, 0x14, 0x4B, 0xEA, 0x71, 0xC5, 0x91,
0x5B, 0xB1, 0x10, 0xE2, 0xD8, 0x81, 0x80, 0xDB,
0xC5, 0xDB, 0x36, 0x4F, 0xD6, 0x17, 0x1D, 0xF3,
0x17, 0xFC, 0x72, 0x68, 0x83, 0x1B, 0x5A, 0xEF,
0x75, 0xE4, 0x34, 0x2B, 0x2F, 0xAD, 0x87, 0x97,
0xBA, 0x39, 0xED, 0xDC, 0xEF, 0x80, 0xE6, 0xEC,
0x08, 0x15, 0x93, 0x50, 0xB1, 0xAD, 0x69, 0x6D
},
{
0xE1, 0x59, 0x0D, 0x58, 0x5A, 0x3D, 0x39, 0xF7,
0xCB, 0x59, 0x9A, 0xBD, 0x47, 0x90, 0x70, 0x96,
0x64, 0x09, 0xA6, 0x84, 0x6D, 0x43, 0x77, 0xAC,
0xF4, 0x47, 0x1D, 0x06, 0x5D, 0x5D, 0xB9, 0x41,
0x29, 0xCC, 0x9B, 0xE9, 0x25, 0x73, 0xB0, 0x5E,
0xD2, 0x26, 0xBE, 0x1E, 0x9B, 0x7C, 0xB0, 0xCA,
0xBE, 0x87, 0x91, 0x85, 0x89, 0xF8, 0x0D, 0xAD,
0xD4, 0xEF, 0x5E, 0xF2, 0x5A, 0x93, 0xD2, 0x8E
},
{
0xF8, 0xF3, 0x72, 0x6A, 0xC5, 0xA2, 0x6C, 0xC8,
0x01, 0x32, 0x49, 0x3A, 0x6F, 0xED, 0xCB, 0x0E,
0x60, 0x76, 0x0C, 0x09, 0xCF, 0xC8, 0x4C, 0xAD,
0x17, 0x81, 0x75, 0x98, 0x68, 0x19, 0x66, 0x5E,
0x76, 0x84, 0x2D, 0x7B, 0x9F, 0xED, 0xF7, 0x6D,
0xDD, 0xEB, 0xF5, 0xD3, 0xF5, 0x6F, 0xAA, 0xAD,
0x44, 0x77, 0x58, 0x7A, 0xF2, 0x16, 0x06, 0xD3,
0x96, 0xAE, 0x57, 0x0D, 0x8E, 0x71, 0x9A, 0xF2
},
{
0x30, 0x18, 0x60, 0x55, 0xC0, 0x79, 0x49, 0x94,
0x81, 0x83, 0xC8, 0x50, 0xE9, 0xA7, 0x56, 0xCC,
0x09, 0x93, 0x7E, 0x24, 0x7D, 0x9D, 0x92, 0x8E,
0x86, 0x9E, 0x20, 0xBA, 0xFC, 0x3C, 0xD9, 0x72,
0x17, 0x19, 0xD3, 0x4E, 0x04, 0xA0, 0x89, 0x9B,
0x92, 0xC7, 0x36, 0x08, 0x45, 0x50, 0x18, 0x68,
0x86, 0xEF, 0xBA, 0x2E, 0x79, 0x0D, 0x8B, 0xE6,
0xEB, 0xF0, 0x40, 0xB2, 0x09, 0xC4, 0x39, 0xA4
},
{
0xF3, 0xC4, 0x27, 0x6C, 0xB8, 0x63, 0x63, 0x77,
0x12, 0xC2, 0x41, 0xC4, 0x44, 0xC5, 0xCC, 0x1E,
0x35, 0x54, 0xE0, 0xFD, 0xDB, 0x17, 0x4D, 0x03,
0x58, 0x19, 0xDD, 0x83, 0xEB, 0x70, 0x0B, 0x4C,
0xE8, 0x8D, 0xF3, 0xAB, 0x38, 0x41, 0xBA, 0x02,
0x08, 0x5E, 0x1A, 0x99, 0xB4, 0xE1, 0x73, 0x10,
0xC5, 0x34, 0x10, 0x75, 0xC0, 0x45, 0x8B, 0xA3,
0x76, 0xC9, 0x5A, 0x68, 0x18, 0xFB, 0xB3, 0xE2
},
{
0x0A, 0xA0, 0x07, 0xC4, 0xDD, 0x9D, 0x58, 0x32,
0x39, 0x30, 0x40, 0xA1, 0x58, 0x3C, 0x93, 0x0B,
0xCA, 0x7D, 0xC5, 0xE7, 0x7E, 0xA5, 0x3A, 0xDD,
0x7E, 0x2B, 0x3F, 0x7C, 0x8E, 0x23, 0x13, 0x68,
0x04, 0x35, 0x20, 0xD4, 0xA3, 0xEF, 0x53, 0xC9,
0x69, 0xB6, 0xBB, 0xFD, 0x02, 0x59, 0x46, 0xF6,
0x32, 0xBD, 0x7F, 0x76, 0x5D, 0x53, 0xC2, 0x10,
0x03, 0xB8, 0xF9, 0x83, 0xF7, 0x5E, 0x2A, 0x6A
},
{
0x08, 0xE9, 0x46, 0x47, 0x20, 0x53, 0x3B, 0x23,
0xA0, 0x4E, 0xC2, 0x4F, 0x7A, 0xE8, 0xC1, 0x03,
0x14, 0x5F, 0x76, 0x53, 0x87, 0xD7, 0x38, 0x77,
0x7D, 0x3D, 0x34, 0x34, 0x77, 0xFD, 0x1C, 0x58,
0xDB, 0x05, 0x21, 0x42, 0xCA, 0xB7, 0x54, 0xEA,
0x67, 0x43, 0x78, 0xE1, 0x87, 0x66, 0xC5, 0x35,
0x42, 0xF7, 0x19, 0x70, 0x17, 0x1C, 0xC4, 0xF8,
0x16, 0x94, 0x24, 0x6B, 0x71, 0x7D, 0x75, 0x64
},
{
0xD3, 0x7F, 0xF7, 0xAD, 0x29, 0x79, 0x93, 0xE7,
0xEC, 0x21, 0xE0, 0xF1, 0xB4, 0xB5, 0xAE, 0x71,
0x9C, 0xDC, 0x83, 0xC5, 0xDB, 0x68, 0x75, 0x27,
0xF2, 0x75, 0x16, 0xCB, 0xFF, 0xA8, 0x22, 0x88,
0x8A, 0x68, 0x10, 0xEE, 0x5C, 0x1C, 0xA7, 0xBF,
0xE3, 0x32, 0x11, 0x19, 0xBE, 0x1A, 0xB7, 0xBF,
0xA0, 0xA5, 0x02, 0x67, 0x1C, 0x83, 0x29, 0x49,
0x4D, 0xF7, 0xAD, 0x6F, 0x52, 0x2D, 0x44, 0x0F
},
{
0xDD, 0x90, 0x42, 0xF6, 0xE4, 0x64, 0xDC, 0xF8,
0x6B, 0x12, 0x62, 0xF6, 0xAC, 0xCF, 0xAF, 0xBD,
0x8C, 0xFD, 0x90, 0x2E, 0xD3, 0xED, 0x89, 0xAB,
0xF7, 0x8F, 0xFA, 0x48, 0x2D, 0xBD, 0xEE, 0xB6,
0x96, 0x98, 0x42, 0x39, 0x4C, 0x9A, 0x11, 0x68,
0xAE, 0x3D, 0x48, 0x1A, 0x01, 0x78, 0x42, 0xF6,
0x60, 0x00, 0x2D, 0x42, 0x44, 0x7C, 0x6B, 0x22,
0xF7, 0xB7, 0x2F, 0x21, 0xAA, 0xE0, 0x21, 0xC9
},
{
0xBD, 0x96, 0x5B, 0xF3, 0x1E, 0x87, 0xD7, 0x03,
0x27, 0x53, 0x6F, 0x2A, 0x34, 0x1C, 0xEB, 0xC4,
0x76, 0x8E, 0xCA, 0x27, 0x5F, 0xA0, 0x5E, 0xF9,
0x8F, 0x7F, 0x1B, 0x71, 0xA0, 0x35, 0x12, 0x98,
0xDE, 0x00, 0x6F, 0xBA, 0x73, 0xFE, 0x67, 0x33,
0xED, 0x01, 0xD7, 0x58, 0x01, 0xB4, 0xA9, 0x28,
0xE5, 0x42, 0x31, 0xB3, 0x8E, 0x38, 0xC5, 0x62,
0xB2, 0xE3, 0x3E, 0xA1, 0x28, 0x49, 0x92, 0xFA
},
{
0x65, 0x67, 0x6D, 0x80, 0x06, 0x17, 0x97, 0x2F,
0xBD, 0x87, 0xE4, 0xB9, 0x51, 0x4E, 0x1C, 0x67,
0x40, 0x2B, 0x7A, 0x33, 0x10, 0x96, 0xD3, 0xBF,
0xAC, 0x22, 0xF1, 0xAB, 0xB9, 0x53, 0x74, 0xAB,
0xC9, 0x42, 0xF1, 0x6E, 0x9A, 0xB0, 0xEA, 0xD3,
0x3B, 0x87, 0xC9, 0x19, 0x68, 0xA6, 0xE5, 0x09,
0xE1, 0x19, 0xFF, 0x07, 0x78, 0x7B, 0x3E, 0xF4,
0x83, 0xE1, 0xDC, 0xDC, 0xCF, 0x6E, 0x30, 0x22
},
{
0x93, 0x9F, 0xA1, 0x89, 0x69, 0x9C, 0x5D, 0x2C,
0x81, 0xDD, 0xD1, 0xFF, 0xC1, 0xFA, 0x20, 0x7C,
0x97, 0x0B, 0x6A, 0x36, 0x85, 0xBB, 0x29, 0xCE,
0x1D, 0x3E, 0x99, 0xD4, 0x2F, 0x2F, 0x74, 0x42,
0xDA, 0x53, 0xE9, 0x5A, 0x72, 0x90, 0x73, 0x14,
0xF4, 0x58, 0x83, 0x99, 0xA3, 0xFF, 0x5B, 0x0A,
0x92, 0xBE, 0xB3, 0xF6, 0xBE, 0x26, 0x94, 0xF9,
0xF8, 0x6E, 0xCF, 0x29, 0x52, 0xD5, 0xB4, 0x1C
},
{
0xC5, 0x16, 0x54, 0x17, 0x01, 0x86, 0x3F, 0x91,
0x00, 0x5F, 0x31, 0x41, 0x08, 0xCE, 0xEC, 0xE3,
0xC6, 0x43, 0xE0, 0x4F, 0xC8, 0xC4, 0x2F, 0xD2,
0xFF, 0x55, 0x62, 0x20, 0xE6, 0x16, 0xAA, 0xA6,
0xA4, 0x8A, 0xEB, 0x97, 0xA8, 0x4B, 0xAD, 0x74,
0x78, 0x2E, 0x8D, 0xFF, 0x96, 0xA1, 0xA2, 0xFA,
0x94, 0x93, 0x39, 0xD7, 0x22, 0xED, 0xCA, 0xA3,
0x2B, 0x57, 0x06, 0x70, 0x41, 0xDF, 0x88, 0xCC
},
{
0x98, 0x7F, 0xD6, 0xE0, 0xD6, 0x85, 0x7C, 0x55,
0x3E, 0xAE, 0xBB, 0x3D, 0x34, 0x97, 0x0A, 0x2C,
0x2F, 0x6E, 0x89, 0xA3, 0x54, 0x8F, 0x49, 0x25,
0x21, 0x72, 0x2B, 0x80, 0xA1, 0xC2, 0x1A, 0x15,
0x38, 0x92, 0x34, 0x6D, 0x2C, 0xBA, 0x64, 0x44,
0x21, 0x2D, 0x56, 0xDA, 0x9A, 0x26, 0xE3, 0x24,
0xDC, 0xCB, 0xC0, 0xDC, 0xDE, 0x85, 0xD4, 0xD2,
0xEE, 0x43, 0x99, 0xEE, 0xC5, 0xA6, 0x4E, 0x8F
},
{
0xAE, 0x56, 0xDE, 0xB1, 0xC2, 0x32, 0x8D, 0x9C,
0x40, 0x17, 0x70, 0x6B, 0xCE, 0x6E, 0x99, 0xD4,
0x13, 0x49, 0x05, 0x3B, 0xA9, 0xD3, 0x36, 0xD6,
0x77, 0xC4, 0xC2, 0x7D, 0x9F, 0xD5, 0x0A, 0xE6,
0xAE, 0xE1, 0x7E, 0x85, 0x31, 0x54, 0xE1, 0xF4,
0xFE, 0x76, 0x72, 0x34, 0x6D, 0xA2, 0xEA, 0xA3,
0x1E, 0xEA, 0x53, 0xFC, 0xF2, 0x4A, 0x22, 0x80,
0x4F, 0x11, 0xD0, 0x3D, 0xA6, 0xAB, 0xFC, 0x2B
},
{
0x49, 0xD6, 0xA6, 0x08, 0xC9, 0xBD, 0xE4, 0x49,
0x18, 0x70, 0x49, 0x85, 0x72, 0xAC, 0x31, 0xAA,
0xC3, 0xFA, 0x40, 0x93, 0x8B, 0x38, 0xA7, 0x81,
0x8F, 0x72, 0x38, 0x3E, 0xB0, 0x40, 0xAD, 0x39,
0x53, 0x2B, 0xC0, 0x65, 0x71, 0xE1, 0x3D, 0x76,
0x7E, 0x69, 0x45, 0xAB, 0x77, 0xC0, 0xBD, 0xC3,
0xB0, 0x28, 0x42, 0x53, 0x34, 0x3F, 0x9F, 0x6C,
0x12, 0x44, 0xEB, 0xF2, 0xFF, 0x0D, 0xF8, 0x66
},
{
0xDA, 0x58, 0x2A, 0xD8, 0xC5, 0x37, 0x0B, 0x44,
0x69, 0xAF, 0x86, 0x2A, 0xA6, 0x46, 0x7A, 0x22,
0x93, 0xB2, 0xB2, 0x8B, 0xD8, 0x0A, 0xE0, 0xE9,
0x1F, 0x42, 0x5A, 0xD3, 0xD4, 0x72, 0x49, 0xFD,
0xF9, 0x88, 0x25, 0xCC, 0x86, 0xF1, 0x40, 0x28,
0xC3, 0x30, 0x8C, 0x98, 0x04, 0xC7, 0x8B, 0xFE,
0xEE, 0xEE, 0x46, 0x14, 0x44, 0xCE, 0x24, 0x36,
0x87, 0xE1, 0xA5, 0x05, 0x22, 0x45, 0x6A, 0x1D
},
{
0xD5, 0x26, 0x6A, 0xA3, 0x33, 0x11, 0x94, 0xAE,
0xF8, 0x52, 0xEE, 0xD8, 0x6D, 0x7B, 0x5B, 0x26,
0x33, 0xA0, 0xAF, 0x1C, 0x73, 0x59, 0x06, 0xF2,
0xE1, 0x32, 0x79, 0xF1, 0x49, 0x31, 0xA9, 0xFC,
0x3B, 0x0E, 0xAC, 0x5C, 0xE9, 0x24, 0x52, 0x73,
0xBD, 0x1A, 0xA9, 0x29, 0x05, 0xAB, 0xE1, 0x62,
0x78, 0xEF, 0x7E, 0xFD, 0x47, 0x69, 0x47, 0x89,
0xA7, 0x28, 0x3B, 0x77, 0xDA, 0x3C, 0x70, 0xF8
},
{
0x29, 0x62, 0x73, 0x4C, 0x28, 0x25, 0x21, 0x86,
0xA9, 0xA1, 0x11, 0x1C, 0x73, 0x2A, 0xD4, 0xDE,
0x45, 0x06, 0xD4, 0xB4, 0x48, 0x09, 0x16, 0x30,
0x3E, 0xB7, 0x99, 0x1D, 0x65, 0x9C, 0xCD, 0xA0,
0x7A, 0x99, 0x11, 0x91, 0x4B, 0xC7, 0x5C, 0x41,
0x8A, 0xB7, 0xA4, 0x54, 0x17, 0x57, 0xAD, 0x05,
0x47, 0x96, 0xE2, 0x67, 0x97, 0xFE, 0xAF, 0x36,
0xE9, 0xF6, 0xAD, 0x43, 0xF1, 0x4B, 0x35, 0xA4
},
{
0xE8, 0xB7, 0x9E, 0xC5, 0xD0, 0x6E, 0x11, 0x1B,
0xDF, 0xAF, 0xD7, 0x1E, 0x9F, 0x57, 0x60, 0xF0,
0x0A, 0xC8, 0xAC, 0x5D, 0x8B, 0xF7, 0x68, 0xF9,
0xFF, 0x6F, 0x08, 0xB8, 0xF0, 0x26, 0x09, 0x6B,
0x1C, 0xC3, 0xA4, 0xC9, 0x73, 0x33, 0x30, 0x19,
0xF1, 0xE3, 0x55, 0x3E, 0x77, 0xDA, 0x3F, 0x98,
0xCB, 0x9F, 0x54, 0x2E, 0x0A, 0x90, 0xE5, 0xF8,
0xA9, 0x40, 0xCC, 0x58, 0xE5, 0x98, 0x44, 0xB3
},
{
0xDF, 0xB3, 0x20, 0xC4, 0x4F, 0x9D, 0x41, 0xD1,
0xEF, 0xDC, 0xC0, 0x15, 0xF0, 0x8D, 0xD5, 0x53,
0x9E, 0x52, 0x6E, 0x39, 0xC8, 0x7D, 0x50, 0x9A,
0xE6, 0x81, 0x2A, 0x96, 0x9E, 0x54, 0x31, 0xBF,
0x4F, 0xA7, 0xD9, 0x1F, 0xFD, 0x03, 0xB9, 0x81,
0xE0, 0xD5, 0x44, 0xCF, 0x72, 0xD7, 0xB1, 0xC0,
0x37, 0x4F, 0x88, 0x01, 0x48, 0x2E, 0x6D, 0xEA,
0x2E, 0xF9, 0x03, 0x87, 0x7E, 0xBA, 0x67, 0x5E
},
{
0xD8, 0x86, 0x75, 0x11, 0x8F, 0xDB, 0x55, 0xA5,
0xFB, 0x36, 0x5A, 0xC2, 0xAF, 0x1D, 0x21, 0x7B,
0xF5, 0x26, 0xCE, 0x1E, 0xE9, 0xC9, 0x4B, 0x2F,
0x00, 0x90, 0xB2, 0xC5, 0x8A, 0x06, 0xCA, 0x58,
0x18, 0x7D, 0x7F, 0xE5, 0x7C, 0x7B, 0xED, 0x9D,
0x26, 0xFC, 0xA0, 0x67, 0xB4, 0x11, 0x0E, 0xEF,
0xCD, 0x9A, 0x0A, 0x34, 0x5D, 0xE8, 0x72, 0xAB,
0xE2, 0x0D, 0xE3, 0x68, 0x00, 0x1B, 0x07, 0x45
},
{
0xB8, 0x93, 0xF2, 0xFC, 0x41, 0xF7, 0xB0, 0xDD,
0x6E, 0x2F, 0x6A, 0xA2, 0xE0, 0x37, 0x0C, 0x0C,
0xFF, 0x7D, 0xF0, 0x9E, 0x3A, 0xCF, 0xCC, 0x0E,
0x92, 0x0B, 0x6E, 0x6F, 0xAD, 0x0E, 0xF7, 0x47,
0xC4, 0x06, 0x68, 0x41, 0x7D, 0x34, 0x2B, 0x80,
0xD2, 0x35, 0x1E, 0x8C, 0x17, 0x5F, 0x20, 0x89,
0x7A, 0x06, 0x2E, 0x97, 0x65, 0xE6, 0xC6, 0x7B,
0x53, 0x9B, 0x6B, 0xA8, 0xB9, 0x17, 0x05, 0x45
},
{
0x6C, 0x67, 0xEC, 0x56, 0x97, 0xAC, 0xCD, 0x23,
0x5C, 0x59, 0xB4, 0x86, 0xD7, 0xB7, 0x0B, 0xAE,
0xED, 0xCB, 0xD4, 0xAA, 0x64, 0xEB, 0xD4, 0xEE,
0xF3, 0xC7, 0xEA, 0xC1, 0x89, 0x56, 0x1A, 0x72,
0x62, 0x50, 0xAE, 0xC4, 0xD4, 0x8C, 0xAD, 0xCA,
0xFB, 0xBE, 0x2C, 0xE3, 0xC1, 0x6C, 0xE2, 0xD6,
0x91, 0xA8, 0xCC, 0xE0, 0x6E, 0x88, 0x79, 0x55,
0x6D, 0x44, 0x83, 0xED, 0x71, 0x65, 0xC0, 0x63
},
{
0xF1, 0xAA, 0x2B, 0x04, 0x4F, 0x8F, 0x0C, 0x63,
0x8A, 0x3F, 0x36, 0x2E, 0x67, 0x7B, 0x5D, 0x89,
0x1D, 0x6F, 0xD2, 0xAB, 0x07, 0x65, 0xF6, 0xEE,
0x1E, 0x49, 0x87, 0xDE, 0x05, 0x7E, 0xAD, 0x35,
0x78, 0x83, 0xD9, 0xB4, 0x05, 0xB9, 0xD6, 0x09,
0xEE, 0xA1, 0xB8, 0x69, 0xD9, 0x7F, 0xB1, 0x6D,
0x9B, 0x51, 0x01, 0x7C, 0x55, 0x3F, 0x3B, 0x93,
0xC0, 0xA1, 0xE0, 0xF1, 0x29, 0x6F, 0xED, 0xCD
},
{
0xCB, 0xAA, 0x25, 0x95, 0x72, 0xD4, 0xAE, 0xBF,
0xC1, 0x91, 0x7A, 0xCD, 0xDC, 0x58, 0x2B, 0x9F,
0x8D, 0xFA, 0xA9, 0x28, 0xA1, 0x98, 0xCA, 0x7A,
0xCD, 0x0F, 0x2A, 0xA7, 0x6A, 0x13, 0x4A, 0x90,
0x25, 0x2E, 0x62, 0x98, 0xA6, 0x5B, 0x08, 0x18,
0x6A, 0x35, 0x0D, 0x5B, 0x76, 0x26, 0x69, 0x9F,
0x8C, 0xB7, 0x21, 0xA3, 0xEA, 0x59, 0x21, 0xB7,
0x53, 0xAE, 0x3A, 0x2D, 0xCE, 0x24, 0xBA, 0x3A
},
{
0xFA, 0x15, 0x49, 0xC9, 0x79, 0x6C, 0xD4, 0xD3,
0x03, 0xDC, 0xF4, 0x52, 0xC1, 0xFB, 0xD5, 0x74,
0x4F, 0xD9, 0xB9, 0xB4, 0x70, 0x03, 0xD9, 0x20,
0xB9, 0x2D, 0xE3, 0x48, 0x39, 0xD0, 0x7E, 0xF2,
0xA2, 0x9D, 0xED, 0x68, 0xF6, 0xFC, 0x9E, 0x6C,
0x45, 0xE0, 0x71, 0xA2, 0xE4, 0x8B, 0xD5, 0x0C,
0x50, 0x84, 0xE9, 0x6B, 0x65, 0x7D, 0xD0, 0x40,
0x40, 0x45, 0xA1, 0xDD, 0xEF, 0xE2, 0x82, 0xED
},
{
0x5C, 0xF2, 0xAC, 0x89, 0x7A, 0xB4, 0x44, 0xDC,
0xB5, 0xC8, 0xD8, 0x7C, 0x49, 0x5D, 0xBD, 0xB3,
0x4E, 0x18, 0x38, 0xB6, 0xB6, 0x29, 0x42, 0x7C,
0xAA, 0x51, 0x70, 0x2A, 0xD0, 0xF9, 0x68, 0x85,
0x25, 0xF1, 0x3B, 0xEC, 0x50, 0x3A, 0x3C, 0x3A,
0x2C, 0x80, 0xA6, 0x5E, 0x0B, 0x57, 0x15, 0xE8,
0xAF, 0xAB, 0x00, 0xFF, 0xA5, 0x6E, 0xC4, 0x55,
0xA4, 0x9A, 0x1A, 0xD3, 0x0A, 0xA2, 0x4F, 0xCD
},
{
0x9A, 0xAF, 0x80, 0x20, 0x7B, 0xAC, 0xE1, 0x7B,
0xB7, 0xAB, 0x14, 0x57, 0x57, 0xD5, 0x69, 0x6B,
0xDE, 0x32, 0x40, 0x6E, 0xF2, 0x2B, 0x44, 0x29,
0x2E, 0xF6, 0x5D, 0x45, 0x19, 0xC3, 0xBB, 0x2A,
0xD4, 0x1A, 0x59, 0xB6, 0x2C, 0xC3, 0xE9, 0x4B,
0x6F, 0xA9, 0x6D, 0x32, 0xA7, 0xFA, 0xAD, 0xAE,
0x28, 0xAF, 0x7D, 0x35, 0x09, 0x72, 0x19, 0xAA,
0x3F, 0xD8, 0xCD, 0xA3, 0x1E, 0x40, 0xC2, 0x75
},
{
0xAF, 0x88, 0xB1, 0x63, 0x40, 0x2C, 0x86, 0x74,
0x5C, 0xB6, 0x50, 0xC2, 0x98, 0x8F, 0xB9, 0x52,
0x11, 0xB9, 0x4B, 0x03, 0xEF, 0x29, 0x0E, 0xED,
0x96, 0x62, 0x03, 0x42, 0x41, 0xFD, 0x51, 0xCF,
0x39, 0x8F, 0x80, 0x73, 0xE3, 0x69, 0x35, 0x4C,
0x43, 0xEA, 0xE1, 0x05, 0x2F, 0x9B, 0x63, 0xB0,
0x81, 0x91, 0xCA, 0xA1, 0x38, 0xAA, 0x54, 0xFE,
0xA8, 0x89, 0xCC, 0x70, 0x24, 0x23, 0x68, 0x97
},
{
0x48, 0xFA, 0x7D, 0x64, 0xE1, 0xCE, 0xEE, 0x27,
0xB9, 0x86, 0x4D, 0xB5, 0xAD, 0xA4, 0xB5, 0x3D,
0x00, 0xC9, 0xBC, 0x76, 0x26, 0x55, 0x58, 0x13,
0xD3, 0xCD, 0x67, 0x30, 0xAB, 0x3C, 0xC0, 0x6F,
0xF3, 0x42, 0xD7, 0x27, 0x90, 0x5E, 0x33, 0x17,
0x1B, 0xDE, 0x6E, 0x84, 0x76, 0xE7, 0x7F, 0xB1,
0x72, 0x08, 0x61, 0xE9, 0x4B, 0x73, 0xA2, 0xC5,
0x38, 0xD2, 0x54, 0x74, 0x62, 0x85, 0xF4, 0x30
},
{
0x0E, 0x6F, 0xD9, 0x7A, 0x85, 0xE9, 0x04, 0xF8,
0x7B, 0xFE, 0x85, 0xBB, 0xEB, 0x34, 0xF6, 0x9E,
0x1F, 0x18, 0x10, 0x5C, 0xF4, 0xED, 0x4F, 0x87,
0xAE, 0xC3, 0x6C, 0x6E, 0x8B, 0x5F, 0x68, 0xBD,
0x2A, 0x6F, 0x3D, 0xC8, 0xA9, 0xEC, 0xB2, 0xB6,
0x1D, 0xB4, 0xEE, 0xDB, 0x6B, 0x2E, 0xA1, 0x0B,
0xF9, 0xCB, 0x02, 0x51, 0xFB, 0x0F, 0x8B, 0x34,
0x4A, 0xBF, 0x7F, 0x36, 0x6B, 0x6D, 0xE5, 0xAB
},
{
0x06, 0x62, 0x2D, 0xA5, 0x78, 0x71, 0x76, 0x28,
0x7F, 0xDC, 0x8F, 0xED, 0x44, 0x0B, 0xAD, 0x18,
0x7D, 0x83, 0x00, 0x99, 0xC9, 0x4E, 0x6D, 0x04,
0xC8, 0xE9, 0xC9, 0x54, 0xCD, 0xA7, 0x0C, 0x8B,
0xB9, 0xE1, 0xFC, 0x4A, 0x6D, 0x0B, 0xAA, 0x83,
0x1B, 0x9B, 0x78, 0xEF, 0x66, 0x48, 0x68, 0x1A,
0x48, 0x67, 0xA1, 0x1D, 0xA9, 0x3E, 0xE3, 0x6E,
0x5E, 0x6A, 0x37, 0xD8, 0x7F, 0xC6, 0x3F, 0x6F
},
{
0x1D, 0xA6, 0x77, 0x2B, 0x58, 0xFA, 0xBF, 0x9C,
0x61, 0xF6, 0x8D, 0x41, 0x2C, 0x82, 0xF1, 0x82,
0xC0, 0x23, 0x6D, 0x7D, 0x57, 0x5E, 0xF0, 0xB5,
0x8D, 0xD2, 0x24, 0x58, 0xD6, 0x43, 0xCD, 0x1D,
0xFC, 0x93, 0xB0, 0x38, 0x71, 0xC3, 0x16, 0xD8,
0x43, 0x0D, 0x31, 0x29, 0x95, 0xD4, 0x19, 0x7F,
0x08, 0x74, 0xC9, 0x91, 0x72, 0xBA, 0x00, 0x4A,
0x01, 0xEE, 0x29, 0x5A, 0xBA, 0xC2, 0x4E, 0x46
},
{
0x3C, 0xD2, 0xD9, 0x32, 0x0B, 0x7B, 0x1D, 0x5F,
0xB9, 0xAA, 0xB9, 0x51, 0xA7, 0x60, 0x23, 0xFA,
0x66, 0x7B, 0xE1, 0x4A, 0x91, 0x24, 0xE3, 0x94,
0x51, 0x39, 0x18, 0xA3, 0xF4, 0x40, 0x96, 0xAE,
0x49, 0x04, 0xBA, 0x0F, 0xFC, 0x15, 0x0B, 0x63,
0xBC, 0x7A, 0xB1, 0xEE, 0xB9, 0xA6, 0xE2, 0x57,
0xE5, 0xC8, 0xF0, 0x00, 0xA7, 0x03, 0x94, 0xA5,
0xAF, 0xD8, 0x42, 0x71, 0x5D, 0xE1, 0x5F, 0x29
},
{
0x04, 0xCD, 0xC1, 0x4F, 0x74, 0x34, 0xE0, 0xB4,
0xBE, 0x70, 0xCB, 0x41, 0xDB, 0x4C, 0x77, 0x9A,
0x88, 0xEA, 0xEF, 0x6A, 0xCC, 0xEB, 0xCB, 0x41,
0xF2, 0xD4, 0x2F, 0xFF, 0xE7, 0xF3, 0x2A, 0x8E,
0x28, 0x1B, 0x5C, 0x10, 0x3A, 0x27, 0x02, 0x1D,
0x0D, 0x08, 0x36, 0x22, 0x50, 0x75, 0x3C, 0xDF,
0x70, 0x29, 0x21, 0x95, 0xA5, 0x3A, 0x48, 0x72,
0x8C, 0xEB, 0x58, 0x44, 0xC2, 0xD9, 0x8B, 0xAB
},
{
0x90, 0x71, 0xB7, 0xA8, 0xA0, 0x75, 0xD0, 0x09,
0x5B, 0x8F, 0xB3, 0xAE, 0x51, 0x13, 0x78, 0x57,
0x35, 0xAB, 0x98, 0xE2, 0xB5, 0x2F, 0xAF, 0x91,
0xD5, 0xB8, 0x9E, 0x44, 0xAA, 0xC5, 0xB5, 0xD4,
0xEB, 0xBF, 0x91, 0x22, 0x3B, 0x0F, 0xF4, 0xC7,
0x19, 0x05, 0xDA, 0x55, 0x34, 0x2E, 0x64, 0x65,
0x5D, 0x6E, 0xF8, 0xC8, 0x9A, 0x47, 0x68, 0xC3,
0xF9, 0x3A, 0x6D, 0xC0, 0x36, 0x6B, 0x5B, 0xC8
},
{
0xEB, 0xB3, 0x02, 0x40, 0xDD, 0x96, 0xC7, 0xBC,
0x8D, 0x0A, 0xBE, 0x49, 0xAA, 0x4E, 0xDC, 0xBB,
0x4A, 0xFD, 0xC5, 0x1F, 0xF9, 0xAA, 0xF7, 0x20,
0xD3, 0xF9, 0xE7, 0xFB, 0xB0, 0xF9, 0xC6, 0xD6,
0x57, 0x13, 0x50, 0x50, 0x17, 0x69, 0xFC, 0x4E,
0xBD, 0x0B, 0x21, 0x41, 0x24, 0x7F, 0xF4, 0x00,
0xD4, 0xFD, 0x4B, 0xE4, 0x14, 0xED, 0xF3, 0x77,
0x57, 0xBB, 0x90, 0xA3, 0x2A, 0xC5, 0xC6, 0x5A
},
{
0x85, 0x32, 0xC5, 0x8B, 0xF3, 0xC8, 0x01, 0x5D,
0x9D, 0x1C, 0xBE, 0x00, 0xEE, 0xF1, 0xF5, 0x08,
0x2F, 0x8F, 0x36, 0x32, 0xFB, 0xE9, 0xF1, 0xED,
0x4F, 0x9D, 0xFB, 0x1F, 0xA7, 0x9E, 0x82, 0x83,
0x06, 0x6D, 0x77, 0xC4, 0x4C, 0x4A, 0xF9, 0x43,
0xD7, 0x6B, 0x30, 0x03, 0x64, 0xAE, 0xCB, 0xD0,
0x64, 0x8C, 0x8A, 0x89, 0x39, 0xBD, 0x20, 0x41,
0x23, 0xF4, 0xB5, 0x62, 0x60, 0x42, 0x2D, 0xEC
},
{
0xFE, 0x98, 0x46, 0xD6, 0x4F, 0x7C, 0x77, 0x08,
0x69, 0x6F, 0x84, 0x0E, 0x2D, 0x76, 0xCB, 0x44,
0x08, 0xB6, 0x59, 0x5C, 0x2F, 0x81, 0xEC, 0x6A,
0x28, 0xA7, 0xF2, 0xF2, 0x0C, 0xB8, 0x8C, 0xFE,
0x6A, 0xC0, 0xB9, 0xE9, 0xB8, 0x24, 0x4F, 0x08,
0xBD, 0x70, 0x95, 0xC3, 0x50, 0xC1, 0xD0, 0x84,
0x2F, 0x64, 0xFB, 0x01, 0xBB, 0x7F, 0x53, 0x2D,
0xFC, 0xD4, 0x73, 0x71, 0xB0, 0xAE, 0xEB, 0x79
},
{
0x28, 0xF1, 0x7E, 0xA6, 0xFB, 0x6C, 0x42, 0x09,
0x2D, 0xC2, 0x64, 0x25, 0x7E, 0x29, 0x74, 0x63,
0x21, 0xFB, 0x5B, 0xDA, 0xEA, 0x98, 0x73, 0xC2,
0xA7, 0xFA, 0x9D, 0x8F, 0x53, 0x81, 0x8E, 0x89,
0x9E, 0x16, 0x1B, 0xC7, 0x7D, 0xFE, 0x80, 0x90,
0xAF, 0xD8, 0x2B, 0xF2, 0x26, 0x6C, 0x5C, 0x1B,
0xC9, 0x30, 0xA8, 0xD1, 0x54, 0x76, 0x24, 0x43,
0x9E, 0x66, 0x2E, 0xF6, 0x95, 0xF2, 0x6F, 0x24
},
{
0xEC, 0x6B, 0x7D, 0x7F, 0x03, 0x0D, 0x48, 0x50,
0xAC, 0xAE, 0x3C, 0xB6, 0x15, 0xC2, 0x1D, 0xD2,
0x52, 0x06, 0xD6, 0x3E, 0x84, 0xD1, 0xDB, 0x8D,
0x95, 0x73, 0x70, 0x73, 0x7B, 0xA0, 0xE9, 0x84,
0x67, 0xEA, 0x0C, 0xE2, 0x74, 0xC6, 0x61, 0x99,
0x90, 0x1E, 0xAE, 0xC1, 0x8A, 0x08, 0x52, 0x57,
0x15, 0xF5, 0x3B, 0xFD, 0xB0, 0xAA, 0xCB, 0x61,
0x3D, 0x34, 0x2E, 0xBD, 0xCE, 0xED, 0xDC, 0x3B
},
{
0xB4, 0x03, 0xD3, 0x69, 0x1C, 0x03, 0xB0, 0xD3,
0x41, 0x8D, 0xF3, 0x27, 0xD5, 0x86, 0x0D, 0x34,
0xBB, 0xFC, 0xC4, 0x51, 0x9B, 0xFB, 0xCE, 0x36,
0xBF, 0x33, 0xB2, 0x08, 0x38, 0x5F, 0xAD, 0xB9,
0x18, 0x6B, 0xC7, 0x8A, 0x76, 0xC4, 0x89, 0xD8,
0x9F, 0xD5, 0x7E, 0x7D, 0xC7, 0x54, 0x12, 0xD2,
0x3B, 0xCD, 0x1D, 0xAE, 0x84, 0x70, 0xCE, 0x92,
0x74, 0x75, 0x4B, 0xB8, 0x58, 0x5B, 0x13, 0xC5
},
{
0x31, 0xFC, 0x79, 0x73, 0x8B, 0x87, 0x72, 0xB3,
0xF5, 0x5C, 0xD8, 0x17, 0x88, 0x13, 0xB3, 0xB5,
0x2D, 0x0D, 0xB5, 0xA4, 0x19, 0xD3, 0x0B, 0xA9,
0x49, 0x5C, 0x4B, 0x9D, 0xA0, 0x21, 0x9F, 0xAC,
0x6D, 0xF8, 0xE7, 0xC2, 0x3A, 0x81, 0x15, 0x51,
0xA6, 0x2B, 0x82, 0x7F, 0x25, 0x6E, 0xCD, 0xB8,
0x12, 0x4A, 0xC8, 0xA6, 0x79, 0x2C, 0xCF, 0xEC,
0xC3, 0xB3, 0x01, 0x27, 0x22, 0xE9, 0x44, 0x63
},
{
0xBB, 0x20, 0x39, 0xEC, 0x28, 0x70, 0x91, 0xBC,
0xC9, 0x64, 0x2F, 0xC9, 0x00, 0x49, 0xE7, 0x37,
0x32, 0xE0, 0x2E, 0x57, 0x7E, 0x28, 0x62, 0xB3,
0x22, 0x16, 0xAE, 0x9B, 0xED, 0xCD, 0x73, 0x0C,
0x4C, 0x28, 0x4E, 0xF3, 0x96, 0x8C, 0x36, 0x8B,
0x7D, 0x37, 0x58, 0x4F, 0x97, 0xBD, 0x4B, 0x4D,
0xC6, 0xEF, 0x61, 0x27, 0xAC, 0xFE, 0x2E, 0x6A,
0xE2, 0x50, 0x91, 0x24, 0xE6, 0x6C, 0x8A, 0xF4
},
{
0xF5, 0x3D, 0x68, 0xD1, 0x3F, 0x45, 0xED, 0xFC,
0xB9, 0xBD, 0x41, 0x5E, 0x28, 0x31, 0xE9, 0x38,
0x35, 0x0D, 0x53, 0x80, 0xD3, 0x43, 0x22, 0x78,
0xFC, 0x1C, 0x0C, 0x38, 0x1F, 0xCB, 0x7C, 0x65,
0xC8, 0x2D, 0xAF, 0xE0, 0x51, 0xD8, 0xC8, 0xB0,
0xD4, 0x4E, 0x09, 0x74, 0xA0, 0xE5, 0x9E, 0xC7,
0xBF, 0x7E, 0xD0, 0x45, 0x9F, 0x86, 0xE9, 0x6F,
0x32, 0x9F, 0xC7, 0x97, 0x52, 0x51, 0x0F, 0xD3
},
{
0x8D, 0x56, 0x8C, 0x79, 0x84, 0xF0, 0xEC, 0xDF,
0x76, 0x40, 0xFB, 0xC4, 0x83, 0xB5, 0xD8, 0xC9,
0xF8, 0x66, 0x34, 0xF6, 0xF4, 0x32, 0x91, 0x84,
0x1B, 0x30, 0x9A, 0x35, 0x0A, 0xB9, 0xC1, 0x13,
0x7D, 0x24, 0x06, 0x6B, 0x09, 0xDA, 0x99, 0x44,
0xBA, 0xC5, 0x4D, 0x5B, 0xB6, 0x58, 0x0D, 0x83,
0x60, 0x47, 0xAA, 0xC7, 0x4A, 0xB7, 0x24, 0xB8,
0x87, 0xEB, 0xF9, 0x3D, 0x4B, 0x32, 0xEC, 0xA9
},
{
0xC0, 0xB6, 0x5C, 0xE5, 0xA9, 0x6F, 0xF7, 0x74,
0xC4, 0x56, 0xCA, 0xC3, 0xB5, 0xF2, 0xC4, 0xCD,
0x35, 0x9B, 0x4F, 0xF5, 0x3E, 0xF9, 0x3A, 0x3D,
0xA0, 0x77, 0x8B, 0xE4, 0x90, 0x0D, 0x1E, 0x8D,
0xA1, 0x60, 0x1E, 0x76, 0x9E, 0x8F, 0x1B, 0x02,
0xD2, 0xA2, 0xF8, 0xC5, 0xB9, 0xFA, 0x10, 0xB4,
0x4F, 0x1C, 0x18, 0x69, 0x85, 0x46, 0x8F, 0xEE,
0xB0, 0x08, 0x73, 0x02, 0x83, 0xA6, 0x65, 0x7D
},
{
0x49, 0x00, 0xBB, 0xA6, 0xF5, 0xFB, 0x10, 0x3E,
0xCE, 0x8E, 0xC9, 0x6A, 0xDA, 0x13, 0xA5, 0xC3,
0xC8, 0x54, 0x88, 0xE0, 0x55, 0x51, 0xDA, 0x6B,
0x6B, 0x33, 0xD9, 0x88, 0xE6, 0x11, 0xEC, 0x0F,
0xE2, 0xE3, 0xC2, 0xAA, 0x48, 0xEA, 0x6A, 0xE8,
0x98, 0x6A, 0x3A, 0x23, 0x1B, 0x22, 0x3C, 0x5D,
0x27, 0xCE, 0xC2, 0xEA, 0xDD, 0xE9, 0x1C, 0xE0,
0x79, 0x81, 0xEE, 0x65, 0x28, 0x62, 0xD1, 0xE4
},
{
0xC7, 0xF5, 0xC3, 0x7C, 0x72, 0x85, 0xF9, 0x27,
0xF7, 0x64, 0x43, 0x41, 0x4D, 0x43, 0x57, 0xFF,
0x78, 0x96, 0x47, 0xD7, 0xA0, 0x05, 0xA5, 0xA7,
0x87, 0xE0, 0x3C, 0x34, 0x6B, 0x57, 0xF4, 0x9F,
0x21, 0xB6, 0x4F, 0xA9, 0xCF, 0x4B, 0x7E, 0x45,
0x57, 0x3E, 0x23, 0x04, 0x90, 0x17, 0x56, 0x71,
0x21, 0xA9, 0xC3, 0xD4, 0xB2, 0xB7, 0x3E, 0xC5,
0xE9, 0x41, 0x35, 0x77, 0x52, 0x5D, 0xB4, 0x5A
},
{
0xEC, 0x70, 0x96, 0x33, 0x07, 0x36, 0xFD, 0xB2,
0xD6, 0x4B, 0x56, 0x53, 0xE7, 0x47, 0x5D, 0xA7,
0x46, 0xC2, 0x3A, 0x46, 0x13, 0xA8, 0x26, 0x87,
0xA2, 0x80, 0x62, 0xD3, 0x23, 0x63, 0x64, 0x28,
0x4A, 0xC0, 0x17, 0x20, 0xFF, 0xB4, 0x06, 0xCF,
0xE2, 0x65, 0xC0, 0xDF, 0x62, 0x6A, 0x18, 0x8C,
0x9E, 0x59, 0x63, 0xAC, 0xE5, 0xD3, 0xD5, 0xBB,
0x36, 0x3E, 0x32, 0xC3, 0x8C, 0x21, 0x90, 0xA6
},
{
0x82, 0xE7, 0x44, 0xC7, 0x5F, 0x46, 0x49, 0xEC,
0x52, 0xB8, 0x07, 0x71, 0xA7, 0x7D, 0x47, 0x5A,
0x3B, 0xC0, 0x91, 0x98, 0x95, 0x56, 0x96, 0x0E,
0x27, 0x6A, 0x5F, 0x9E, 0xAD, 0x92, 0xA0, 0x3F,
0x71, 0x87, 0x42, 0xCD, 0xCF, 0xEA, 0xEE, 0x5C,
0xB8, 0x5C, 0x44, 0xAF, 0x19, 0x8A, 0xDC, 0x43,
0xA4, 0xA4, 0x28, 0xF5, 0xF0, 0xC2, 0xDD, 0xB0,
0xBE, 0x36, 0x05, 0x9F, 0x06, 0xD7, 0xDF, 0x73
},
{
0x28, 0x34, 0xB7, 0xA7, 0x17, 0x0F, 0x1F, 0x5B,
0x68, 0x55, 0x9A, 0xB7, 0x8C, 0x10, 0x50, 0xEC,
0x21, 0xC9, 0x19, 0x74, 0x0B, 0x78, 0x4A, 0x90,
0x72, 0xF6, 0xE5, 0xD6, 0x9F, 0x82, 0x8D, 0x70,
0xC9, 0x19, 0xC5, 0x03, 0x9F, 0xB1, 0x48, 0xE3,
0x9E, 0x2C, 0x8A, 0x52, 0x11, 0x83, 0x78, 0xB0,
0x64, 0xCA, 0x8D, 0x50, 0x01, 0xCD, 0x10, 0xA5,
0x47, 0x83, 0x87, 0xB9, 0x66, 0x71, 0x5E, 0xD6
},
{
0x16, 0xB4, 0xAD, 0xA8, 0x83, 0xF7, 0x2F, 0x85,
0x3B, 0xB7, 0xEF, 0x25, 0x3E, 0xFC, 0xAB, 0x0C,
0x3E, 0x21, 0x61, 0x68, 0x7A, 0xD6, 0x15, 0x43,
0xA0, 0xD2, 0x82, 0x4F, 0x91, 0xC1, 0xF8, 0x13,
0x47, 0xD8, 0x6B, 0xE7, 0x09, 0xB1, 0x69, 0x96,
0xE1, 0x7F, 0x2D, 0xD4, 0x86, 0x92, 0x7B, 0x02,
0x88, 0xAD, 0x38, 0xD1, 0x30, 0x63, 0xC4, 0xA9,
0x67, 0x2C, 0x39, 0x39, 0x7D, 0x37, 0x89, 0xB6
},
{
0x78, 0xD0, 0x48, 0xF3, 0xA6, 0x9D, 0x8B, 0x54,
0xAE, 0x0E, 0xD6, 0x3A, 0x57, 0x3A, 0xE3, 0x50,
0xD8, 0x9F, 0x7C, 0x6C, 0xF1, 0xF3, 0x68, 0x89,
0x30, 0xDE, 0x89, 0x9A, 0xFA, 0x03, 0x76, 0x97,
0x62, 0x9B, 0x31, 0x4E, 0x5C, 0xD3, 0x03, 0xAA,
0x62, 0xFE, 0xEA, 0x72, 0xA2, 0x5B, 0xF4, 0x2B,
0x30, 0x4B, 0x6C, 0x6B, 0xCB, 0x27, 0xFA, 0xE2,
0x1C, 0x16, 0xD9, 0x25, 0xE1, 0xFB, 0xDA, 0xC3
},
{
0x0F, 0x74, 0x6A, 0x48, 0x74, 0x92, 0x87, 0xAD,
0xA7, 0x7A, 0x82, 0x96, 0x1F, 0x05, 0xA4, 0xDA,
0x4A, 0xBD, 0xB7, 0xD7, 0x7B, 0x12, 0x20, 0xF8,
0x36, 0xD0, 0x9E, 0xC8, 0x14, 0x35, 0x9C, 0x0E,
0xC0, 0x23, 0x9B, 0x8C, 0x7B, 0x9F, 0xF9, 0xE0,
0x2F, 0x56, 0x9D, 0x1B, 0x30, 0x1E, 0xF6, 0x7C,
0x46, 0x12, 0xD1, 0xDE, 0x4F, 0x73, 0x0F, 0x81,
0xC1, 0x2C, 0x40, 0xCC, 0x06, 0x3C, 0x5C, 0xAA
},
{
0xF0, 0xFC, 0x85, 0x9D, 0x3B, 0xD1, 0x95, 0xFB,
0xDC, 0x2D, 0x59, 0x1E, 0x4C, 0xDA, 0xC1, 0x51,
0x79, 0xEC, 0x0F, 0x1D, 0xC8, 0x21, 0xC1, 0x1D,
0xF1, 0xF0, 0xC1, 0xD2, 0x6E, 0x62, 0x60, 0xAA,
0xA6, 0x5B, 0x79, 0xFA, 0xFA, 0xCA, 0xFD, 0x7D,
0x3A, 0xD6, 0x1E, 0x60, 0x0F, 0x25, 0x09, 0x05,
0xF5, 0x87, 0x8C, 0x87, 0x45, 0x28, 0x97, 0x64,
0x7A, 0x35, 0xB9, 0x95, 0xBC, 0xAD, 0xC3, 0xA3
},
{
0x26, 0x20, 0xF6, 0x87, 0xE8, 0x62, 0x5F, 0x6A,
0x41, 0x24, 0x60, 0xB4, 0x2E, 0x2C, 0xEF, 0x67,
0x63, 0x42, 0x08, 0xCE, 0x10, 0xA0, 0xCB, 0xD4,
0xDF, 0xF7, 0x04, 0x4A, 0x41, 0xB7, 0x88, 0x00,
0x77, 0xE9, 0xF8, 0xDC, 0x3B, 0x8D, 0x12, 0x16,
0xD3, 0x37, 0x6A, 0x21, 0xE0, 0x15, 0xB5, 0x8F,
0xB2, 0x79, 0xB5, 0x21, 0xD8, 0x3F, 0x93, 0x88,
0xC7, 0x38, 0x2C, 0x85, 0x05, 0x59, 0x0B, 0x9B
},
{
0x22, 0x7E, 0x3A, 0xED, 0x8D, 0x2C, 0xB1, 0x0B,
0x91, 0x8F, 0xCB, 0x04, 0xF9, 0xDE, 0x3E, 0x6D,
0x0A, 0x57, 0xE0, 0x84, 0x76, 0xD9, 0x37, 0x59,
0xCD, 0x7B, 0x2E, 0xD5, 0x4A, 0x1C, 0xBF, 0x02,
0x39, 0xC5, 0x28, 0xFB, 0x04, 0xBB, 0xF2, 0x88,
0x25, 0x3E, 0x60, 0x1D, 0x3B, 0xC3, 0x8B, 0x21,
0x79, 0x4A, 0xFE, 0xF9, 0x0B, 0x17, 0x09, 0x4A,
0x18, 0x2C, 0xAC, 0x55, 0x77, 0x45, 0xE7, 0x5F
},
{
0x1A, 0x92, 0x99, 0x01, 0xB0, 0x9C, 0x25, 0xF2,
0x7D, 0x6B, 0x35, 0xBE, 0x7B, 0x2F, 0x1C, 0x47,
0x45, 0x13, 0x1F, 0xDE, 0xBC, 0xA7, 0xF3, 0xE2,
0x45, 0x19, 0x26, 0x72, 0x04, 0x34, 0xE0, 0xDB,
0x6E, 0x74, 0xFD, 0x69, 0x3A, 0xD2, 0x9B, 0x77,
0x7D, 0xC3, 0x35, 0x5C, 0x59, 0x2A, 0x36, 0x1C,
0x48, 0x73, 0xB0, 0x11, 0x33, 0xA5, 0x7C, 0x2E,
0x3B, 0x70, 0x75, 0xCB, 0xDB, 0x86, 0xF4, 0xFC
},
{
0x5F, 0xD7, 0x96, 0x8B, 0xC2, 0xFE, 0x34, 0xF2,
0x20, 0xB5, 0xE3, 0xDC, 0x5A, 0xF9, 0x57, 0x17,
0x42, 0xD7, 0x3B, 0x7D, 0x60, 0x81, 0x9F, 0x28,
0x88, 0xB6, 0x29, 0x07, 0x2B, 0x96, 0xA9, 0xD8,
0xAB, 0x2D, 0x91, 0xB8, 0x2D, 0x0A, 0x9A, 0xAB,
0xA6, 0x1B, 0xBD, 0x39, 0x95, 0x81, 0x32, 0xFC,
0xC4, 0x25, 0x70, 0x23, 0xD1, 0xEC, 0xA5, 0x91,
0xB3, 0x05, 0x4E, 0x2D, 0xC8, 0x1C, 0x82, 0x00
},
{
0xDF, 0xCC, 0xE8, 0xCF, 0x32, 0x87, 0x0C, 0xC6,
0xA5, 0x03, 0xEA, 0xDA, 0xFC, 0x87, 0xFD, 0x6F,
0x78, 0x91, 0x8B, 0x9B, 0x4D, 0x07, 0x37, 0xDB,
0x68, 0x10, 0xBE, 0x99, 0x6B, 0x54, 0x97, 0xE7,
0xE5, 0xCC, 0x80, 0xE3, 0x12, 0xF6, 0x1E, 0x71,
0xFF, 0x3E, 0x96, 0x24, 0x43, 0x60, 0x73, 0x15,
0x64, 0x03, 0xF7, 0x35, 0xF5, 0x6B, 0x0B, 0x01,
0x84, 0x5C, 0x18, 0xF6, 0xCA, 0xF7, 0x72, 0xE6
},
{
0x02, 0xF7, 0xEF, 0x3A, 0x9C, 0xE0, 0xFF, 0xF9,
0x60, 0xF6, 0x70, 0x32, 0xB2, 0x96, 0xEF, 0xCA,
0x30, 0x61, 0xF4, 0x93, 0x4D, 0x69, 0x07, 0x49,
0xF2, 0xD0, 0x1C, 0x35, 0xC8, 0x1C, 0x14, 0xF3,
0x9A, 0x67, 0xFA, 0x35, 0x0B, 0xC8, 0xA0, 0x35,
0x9B, 0xF1, 0x72, 0x4B, 0xFF, 0xC3, 0xBC, 0xA6,
0xD7, 0xC7, 0xBB, 0xA4, 0x79, 0x1F, 0xD5, 0x22,
0xA3, 0xAD, 0x35, 0x3C, 0x02, 0xEC, 0x5A, 0xA8
},
{
0x64, 0xBE, 0x5C, 0x6A, 0xBA, 0x65, 0xD5, 0x94,
0x84, 0x4A, 0xE7, 0x8B, 0xB0, 0x22, 0xE5, 0xBE,
0xBE, 0x12, 0x7F, 0xD6, 0xB6, 0xFF, 0xA5, 0xA1,
0x37, 0x03, 0x85, 0x5A, 0xB6, 0x3B, 0x62, 0x4D,
0xCD, 0x1A, 0x36, 0x3F, 0x99, 0x20, 0x3F, 0x63,
0x2E, 0xC3, 0x86, 0xF3, 0xEA, 0x76, 0x7F, 0xC9,
0x92, 0xE8, 0xED, 0x96, 0x86, 0x58, 0x6A, 0xA2,
0x75, 0x55, 0xA8, 0x59, 0x9D, 0x5B, 0x80, 0x8F
},
{
0xF7, 0x85, 0x85, 0x50, 0x5C, 0x4E, 0xAA, 0x54,
0xA8, 0xB5, 0xBE, 0x70, 0xA6, 0x1E, 0x73, 0x5E,
0x0F, 0xF9, 0x7A, 0xF9, 0x44, 0xDD, 0xB3, 0x00,
0x1E, 0x35, 0xD8, 0x6C, 0x4E, 0x21, 0x99, 0xD9,
0x76, 0x10, 0x4B, 0x6A, 0xE3, 0x17, 0x50, 0xA3,
0x6A, 0x72, 0x6E, 0xD2, 0x85, 0x06, 0x4F, 0x59,
0x81, 0xB5, 0x03, 0x88, 0x9F, 0xEF, 0x82, 0x2F,
0xCD, 0xC2, 0x89, 0x8D, 0xDD, 0xB7, 0x88, 0x9A
},
{
0xE4, 0xB5, 0x56, 0x60, 0x33, 0x86, 0x95, 0x72,
0xED, 0xFD, 0x87, 0x47, 0x9A, 0x5B, 0xB7, 0x3C,
0x80, 0xE8, 0x75, 0x9B, 0x91, 0x23, 0x28, 0x79,
0xD9, 0x6B, 0x1D, 0xDA, 0x36, 0xC0, 0x12, 0x07,
0x6E, 0xE5, 0xA2, 0xED, 0x7A, 0xE2, 0xDE, 0x63,
0xEF, 0x84, 0x06, 0xA0, 0x6A, 0xEA, 0x82, 0xC1,
0x88, 0x03, 0x1B, 0x56, 0x0B, 0xEA, 0xFB, 0x58,
0x3F, 0xB3, 0xDE, 0x9E, 0x57, 0x95, 0x2A, 0x7E
},
{
0xE1, 0xB3, 0xE7, 0xED, 0x86, 0x7F, 0x6C, 0x94,
0x84, 0xA2, 0xA9, 0x7F, 0x77, 0x15, 0xF2, 0x5E,
0x25, 0x29, 0x4E, 0x99, 0x2E, 0x41, 0xF6, 0xA7,
0xC1, 0x61, 0xFF, 0xC2, 0xAD, 0xC6, 0xDA, 0xAE,
0xB7, 0x11, 0x31, 0x02, 0xD5, 0xE6, 0x09, 0x02,
0x87, 0xFE, 0x6A, 0xD9, 0x4C, 0xE5, 0xD6, 0xB7,
0x39, 0xC6, 0xCA, 0x24, 0x0B, 0x05, 0xC7, 0x6F,
0xB7, 0x3F, 0x25, 0xDD, 0x02, 0x4B, 0xF9, 0x35
},
{
0x85, 0xFD, 0x08, 0x5F, 0xDC, 0x12, 0xA0, 0x80,
0x98, 0x3D, 0xF0, 0x7B, 0xD7, 0x01, 0x2B, 0x0D,
0x40, 0x2A, 0x0F, 0x40, 0x43, 0xFC, 0xB2, 0x77,
0x5A, 0xDF, 0x0B, 0xAD, 0x17, 0x4F, 0x9B, 0x08,
0xD1, 0x67, 0x6E, 0x47, 0x69, 0x85, 0x78, 0x5C,
0x0A, 0x5D, 0xCC, 0x41, 0xDB, 0xFF, 0x6D, 0x95,
0xEF, 0x4D, 0x66, 0xA3, 0xFB, 0xDC, 0x4A, 0x74,
0xB8, 0x2B, 0xA5, 0x2D, 0xA0, 0x51, 0x2B, 0x74
},
{
0xAE, 0xD8, 0xFA, 0x76, 0x4B, 0x0F, 0xBF, 0xF8,
0x21, 0xE0, 0x52, 0x33, 0xD2, 0xF7, 0xB0, 0x90,
0x0E, 0xC4, 0x4D, 0x82, 0x6F, 0x95, 0xE9, 0x3C,
0x34, 0x3C, 0x1B, 0xC3, 0xBA, 0x5A, 0x24, 0x37,
0x4B, 0x1D, 0x61, 0x6E, 0x7E, 0x7A, 0xBA, 0x45,
0x3A, 0x0A, 0xDA, 0x5E, 0x4F, 0xAB, 0x53, 0x82,
0x40, 0x9E, 0x0D, 0x42, 0xCE, 0x9C, 0x2B, 0xC7,
0xFB, 0x39, 0xA9, 0x9C, 0x34, 0x0C, 0x20, 0xF0
},
{
0x7B, 0xA3, 0xB2, 0xE2, 0x97, 0x23, 0x35, 0x22,
0xEE, 0xB3, 0x43, 0xBD, 0x3E, 0xBC, 0xFD, 0x83,
0x5A, 0x04, 0x00, 0x77, 0x35, 0xE8, 0x7F, 0x0C,
0xA3, 0x00, 0xCB, 0xEE, 0x6D, 0x41, 0x65, 0x65,
0x16, 0x21, 0x71, 0x58, 0x1E, 0x40, 0x20, 0xFF,
0x4C, 0xF1, 0x76, 0x45, 0x0F, 0x12, 0x91, 0xEA,
0x22, 0x85, 0xCB, 0x9E, 0xBF, 0xFE, 0x4C, 0x56,
0x66, 0x06, 0x27, 0x68, 0x51, 0x45, 0x05, 0x1C
},
{
0xDE, 0x74, 0x8B, 0xCF, 0x89, 0xEC, 0x88, 0x08,
0x47, 0x21, 0xE1, 0x6B, 0x85, 0xF3, 0x0A, 0xDB,
0x1A, 0x61, 0x34, 0xD6, 0x64, 0xB5, 0x84, 0x35,
0x69, 0xBA, 0xBC, 0x5B, 0xBD, 0x1A, 0x15, 0xCA,
0x9B, 0x61, 0x80, 0x3C, 0x90, 0x1A, 0x4F, 0xEF,
0x32, 0x96, 0x5A, 0x17, 0x49, 0xC9, 0xF3, 0xA4,
0xE2, 0x43, 0xE1, 0x73, 0x93, 0x9D, 0xC5, 0xA8,
0xDC, 0x49, 0x5C, 0x67, 0x1A, 0xB5, 0x21, 0x45
},
{
0xAA, 0xF4, 0xD2, 0xBD, 0xF2, 0x00, 0xA9, 0x19,
0x70, 0x6D, 0x98, 0x42, 0xDC, 0xE1, 0x6C, 0x98,
0x14, 0x0D, 0x34, 0xBC, 0x43, 0x3D, 0xF3, 0x20,
0xAB, 0xA9, 0xBD, 0x42, 0x9E, 0x54, 0x9A, 0xA7,
0xA3, 0x39, 0x76, 0x52, 0xA4, 0xD7, 0x68, 0x27,
0x77, 0x86, 0xCF, 0x99, 0x3C, 0xDE, 0x23, 0x38,
0x67, 0x3E, 0xD2, 0xE6, 0xB6, 0x6C, 0x96, 0x1F,
0xEF, 0xB8, 0x2C, 0xD2, 0x0C, 0x93, 0x33, 0x8F
},
{
0xC4, 0x08, 0x21, 0x89, 0x68, 0xB7, 0x88, 0xBF,
0x86, 0x4F, 0x09, 0x97, 0xE6, 0xBC, 0x4C, 0x3D,
0xBA, 0x68, 0xB2, 0x76, 0xE2, 0x12, 0x5A, 0x48,
0x43, 0x29, 0x60, 0x52, 0xFF, 0x93, 0xBF, 0x57,
0x67, 0xB8, 0xCD, 0xCE, 0x71, 0x31, 0xF0, 0x87,
0x64, 0x30, 0xC1, 0x16, 0x5F, 0xEC, 0x6C, 0x4F,
0x47, 0xAD, 0xAA, 0x4F, 0xD8, 0xBC, 0xFA, 0xCE,
0xF4, 0x63, 0xB5, 0xD3, 0xD0, 0xFA, 0x61, 0xA0
},
{
0x76, 0xD2, 0xD8, 0x19, 0xC9, 0x2B, 0xCE, 0x55,
0xFA, 0x8E, 0x09, 0x2A, 0xB1, 0xBF, 0x9B, 0x9E,
0xAB, 0x23, 0x7A, 0x25, 0x26, 0x79, 0x86, 0xCA,
0xCF, 0x2B, 0x8E, 0xE1, 0x4D, 0x21, 0x4D, 0x73,
0x0D, 0xC9, 0xA5, 0xAA, 0x2D, 0x7B, 0x59, 0x6E,
0x86, 0xA1, 0xFD, 0x8F, 0xA0, 0x80, 0x4C, 0x77,
0x40, 0x2D, 0x2F, 0xCD, 0x45, 0x08, 0x36, 0x88,
0xB2, 0x18, 0xB1, 0xCD, 0xFA, 0x0D, 0xCB, 0xCB
},
{
0x72, 0x06, 0x5E, 0xE4, 0xDD, 0x91, 0xC2, 0xD8,
0x50, 0x9F, 0xA1, 0xFC, 0x28, 0xA3, 0x7C, 0x7F,
0xC9, 0xFA, 0x7D, 0x5B, 0x3F, 0x8A, 0xD3, 0xD0,
0xD7, 0xA2, 0x56, 0x26, 0xB5, 0x7B, 0x1B, 0x44,
0x78, 0x8D, 0x4C, 0xAF, 0x80, 0x62, 0x90, 0x42,
0x5F, 0x98, 0x90, 0xA3, 0xA2, 0xA3, 0x5A, 0x90,
0x5A, 0xB4, 0xB3, 0x7A, 0xCF, 0xD0, 0xDA, 0x6E,
0x45, 0x17, 0xB2, 0x52, 0x5C, 0x96, 0x51, 0xE4
},
{
0x64, 0x47, 0x5D, 0xFE, 0x76, 0x00, 0xD7, 0x17,
0x1B, 0xEA, 0x0B, 0x39, 0x4E, 0x27, 0xC9, 0xB0,
0x0D, 0x8E, 0x74, 0xDD, 0x1E, 0x41, 0x6A, 0x79,
0x47, 0x36, 0x82, 0xAD, 0x3D, 0xFD, 0xBB, 0x70,
0x66, 0x31, 0x55, 0x80, 0x55, 0xCF, 0xC8, 0xA4,
0x0E, 0x07, 0xBD, 0x01, 0x5A, 0x45, 0x40, 0xDC,
0xDE, 0xA1, 0x58, 0x83, 0xCB, 0xBF, 0x31, 0x41,
0x2D, 0xF1, 0xDE, 0x1C, 0xD4, 0x15, 0x2B, 0x91
},
{
0x12, 0xCD, 0x16, 0x74, 0xA4, 0x48, 0x8A, 0x5D,
0x7C, 0x2B, 0x31, 0x60, 0xD2, 0xE2, 0xC4, 0xB5,
0x83, 0x71, 0xBE, 0xDA, 0xD7, 0x93, 0x41, 0x8D,
0x6F, 0x19, 0xC6, 0xEE, 0x38, 0x5D, 0x70, 0xB3,
0xE0, 0x67, 0x39, 0x36, 0x9D, 0x4D, 0xF9, 0x10,
0xED, 0xB0, 0xB0, 0xA5, 0x4C, 0xBF, 0xF4, 0x3D,
0x54, 0x54, 0x4C, 0xD3, 0x7A, 0xB3, 0xA0, 0x6C,
0xFA, 0x0A, 0x3D, 0xDA, 0xC8, 0xB6, 0x6C, 0x89
},
{
0x60, 0x75, 0x69, 0x66, 0x47, 0x9D, 0xED, 0xC6,
0xDD, 0x4B, 0xCF, 0xF8, 0xEA, 0x7D, 0x1D, 0x4C,
0xE4, 0xD4, 0xAF, 0x2E, 0x7B, 0x09, 0x7E, 0x32,
0xE3, 0x76, 0x35, 0x18, 0x44, 0x11, 0x47, 0xCC,
0x12, 0xB3, 0xC0, 0xEE, 0x6D, 0x2E, 0xCA, 0xBF,
0x11, 0x98, 0xCE, 0xC9, 0x2E, 0x86, 0xA3, 0x61,
0x6F, 0xBA, 0x4F, 0x4E, 0x87, 0x2F, 0x58, 0x25,
0x33, 0x0A, 0xDB, 0xB4, 0xC1, 0xDE, 0xE4, 0x44
},
{
0xA7, 0x80, 0x3B, 0xCB, 0x71, 0xBC, 0x1D, 0x0F,
0x43, 0x83, 0xDD, 0xE1, 0xE0, 0x61, 0x2E, 0x04,
0xF8, 0x72, 0xB7, 0x15, 0xAD, 0x30, 0x81, 0x5C,
0x22, 0x49, 0xCF, 0x34, 0xAB, 0xB8, 0xB0, 0x24,
0x91, 0x5C, 0xB2, 0xFC, 0x9F, 0x4E, 0x7C, 0xC4,
0xC8, 0xCF, 0xD4, 0x5B, 0xE2, 0xD5, 0xA9, 0x1E,
0xAB, 0x09, 0x41, 0xC7, 0xD2, 0x70, 0xE2, 0xDA,
0x4C, 0xA4, 0xA9, 0xF7, 0xAC, 0x68, 0x66, 0x3A
},
{
0xB8, 0x4E, 0xF6, 0xA7, 0x22, 0x9A, 0x34, 0xA7,
0x50, 0xD9, 0xA9, 0x8E, 0xE2, 0x52, 0x98, 0x71,
0x81, 0x6B, 0x87, 0xFB, 0xE3, 0xBC, 0x45, 0xB4,
0x5F, 0xA5, 0xAE, 0x82, 0xD5, 0x14, 0x15, 0x40,
0x21, 0x11, 0x65, 0xC3, 0xC5, 0xD7, 0xA7, 0x47,
0x6B, 0xA5, 0xA4, 0xAA, 0x06, 0xD6, 0x64, 0x76,
0xF0, 0xD9, 0xDC, 0x49, 0xA3, 0xF1, 0xEE, 0x72,
0xC3, 0xAC, 0xAB, 0xD4, 0x98, 0x96, 0x74, 0x14
},
{
0xFA, 0xE4, 0xB6, 0xD8, 0xEF, 0xC3, 0xF8, 0xC8,
0xE6, 0x4D, 0x00, 0x1D, 0xAB, 0xEC, 0x3A, 0x21,
0xF5, 0x44, 0xE8, 0x27, 0x14, 0x74, 0x52, 0x51,
0xB2, 0xB4, 0xB3, 0x93, 0xF2, 0xF4, 0x3E, 0x0D,
0xA3, 0xD4, 0x03, 0xC6, 0x4D, 0xB9, 0x5A, 0x2C,
0xB6, 0xE2, 0x3E, 0xBB, 0x7B, 0x9E, 0x94, 0xCD,
0xD5, 0xDD, 0xAC, 0x54, 0xF0, 0x7C, 0x4A, 0x61,
0xBD, 0x3C, 0xB1, 0x0A, 0xA6, 0xF9, 0x3B, 0x49
},
{
0x34, 0xF7, 0x28, 0x66, 0x05, 0xA1, 0x22, 0x36,
0x95, 0x40, 0x14, 0x1D, 0xED, 0x79, 0xB8, 0x95,
0x72, 0x55, 0xDA, 0x2D, 0x41, 0x55, 0xAB, 0xBF,
0x5A, 0x8D, 0xBB, 0x89, 0xC8, 0xEB, 0x7E, 0xDE,
0x8E, 0xEE, 0xF1, 0xDA, 0xA4, 0x6D, 0xC2, 0x9D,
0x75, 0x1D, 0x04, 0x5D, 0xC3, 0xB1, 0xD6, 0x58,
0xBB, 0x64, 0xB8, 0x0F, 0xF8, 0x58, 0x9E, 0xDD,
0xB3, 0x82, 0x4B, 0x13, 0xDA, 0x23, 0x5A, 0x6B
},
{
0x3B, 0x3B, 0x48, 0x43, 0x4B, 0xE2, 0x7B, 0x9E,
0xAB, 0xAB, 0xBA, 0x43, 0xBF, 0x6B, 0x35, 0xF1,
0x4B, 0x30, 0xF6, 0xA8, 0x8D, 0xC2, 0xE7, 0x50,
0xC3, 0x58, 0x47, 0x0D, 0x6B, 0x3A, 0xA3, 0xC1,
0x8E, 0x47, 0xDB, 0x40, 0x17, 0xFA, 0x55, 0x10,
0x6D, 0x82, 0x52, 0xF0, 0x16, 0x37, 0x1A, 0x00,
0xF5, 0xF8, 0xB0, 0x70, 0xB7, 0x4B, 0xA5, 0xF2,
0x3C, 0xFF, 0xC5, 0x51, 0x1C, 0x9F, 0x09, 0xF0
},
{
0xBA, 0x28, 0x9E, 0xBD, 0x65, 0x62, 0xC4, 0x8C,
0x3E, 0x10, 0xA8, 0xAD, 0x6C, 0xE0, 0x2E, 0x73,
0x43, 0x3D, 0x1E, 0x93, 0xD7, 0xC9, 0x27, 0x9D,
0x4D, 0x60, 0xA7, 0xE8, 0x79, 0xEE, 0x11, 0xF4,
0x41, 0xA0, 0x00, 0xF4, 0x8E, 0xD9, 0xF7, 0xC4,
0xED, 0x87, 0xA4, 0x51, 0x36, 0xD7, 0xDC, 0xCD,
0xCA, 0x48, 0x21, 0x09, 0xC7, 0x8A, 0x51, 0x06,
0x2B, 0x3B, 0xA4, 0x04, 0x4A, 0xDA, 0x24, 0x69
},
{
0x02, 0x29, 0x39, 0xE2, 0x38, 0x6C, 0x5A, 0x37,
0x04, 0x98, 0x56, 0xC8, 0x50, 0xA2, 0xBB, 0x10,
0xA1, 0x3D, 0xFE, 0xA4, 0x21, 0x2B, 0x4C, 0x73,
0x2A, 0x88, 0x40, 0xA9, 0xFF, 0xA5, 0xFA, 0xF5,
0x48, 0x75, 0xC5, 0x44, 0x88, 0x16, 0xB2, 0x78,
0x5A, 0x00, 0x7D, 0xA8, 0xA8, 0xD2, 0xBC, 0x7D,
0x71, 0xA5, 0x4E, 0x4E, 0x65, 0x71, 0xF1, 0x0B,
0x60, 0x0C, 0xBD, 0xB2, 0x5D, 0x13, 0xED, 0xE3
},
{
0xE6, 0xFE, 0xC1, 0x9D, 0x89, 0xCE, 0x87, 0x17,
0xB1, 0xA0, 0x87, 0x02, 0x46, 0x70, 0xFE, 0x02,
0x6F, 0x6C, 0x7C, 0xBD, 0xA1, 0x1C, 0xAE, 0xF9,
0x59, 0xBB, 0x2D, 0x35, 0x1B, 0xF8, 0x56, 0xF8,
0x05, 0x5D, 0x1C, 0x0E, 0xBD, 0xAA, 0xA9, 0xD1,
0xB1, 0x78, 0x86, 0xFC, 0x2C, 0x56, 0x2B, 0x5E,
0x99, 0x64, 0x2F, 0xC0, 0x64, 0x71, 0x0C, 0x0D,
0x34, 0x88, 0xA0, 0x2B, 0x5E, 0xD7, 0xF6, 0xFD
},
{
0x94, 0xC9, 0x6F, 0x02, 0xA8, 0xF5, 0x76, 0xAC,
0xA3, 0x2B, 0xA6, 0x1C, 0x2B, 0x20, 0x6F, 0x90,
0x72, 0x85, 0xD9, 0x29, 0x9B, 0x83, 0xAC, 0x17,
0x5C, 0x20, 0x9A, 0x8D, 0x43, 0xD5, 0x3B, 0xFE,
0x68, 0x3D, 0xD1, 0xD8, 0x3E, 0x75, 0x49, 0xCB,
0x90, 0x6C, 0x28, 0xF5, 0x9A, 0xB7, 0xC4, 0x6F,
0x87, 0x51, 0x36, 0x6A, 0x28, 0xC3, 0x9D, 0xD5,
0xFE, 0x26, 0x93, 0xC9, 0x01, 0x96, 0x66, 0xC8
},
{
0x31, 0xA0, 0xCD, 0x21, 0x5E, 0xBD, 0x2C, 0xB6,
0x1D, 0xE5, 0xB9, 0xED, 0xC9, 0x1E, 0x61, 0x95,
0xE3, 0x1C, 0x59, 0xA5, 0x64, 0x8D, 0x5C, 0x9F,
0x73, 0x7E, 0x12, 0x5B, 0x26, 0x05, 0x70, 0x8F,
0x2E, 0x32, 0x5A, 0xB3, 0x38, 0x1C, 0x8D, 0xCE,
0x1A, 0x3E, 0x95, 0x88, 0x86, 0xF1, 0xEC, 0xDC,
0x60, 0x31, 0x8F, 0x88, 0x2C, 0xFE, 0x20, 0xA2,
0x41, 0x91, 0x35, 0x2E, 0x61, 0x7B, 0x0F, 0x21
},
{
0x91, 0xAB, 0x50, 0x4A, 0x52, 0x2D, 0xCE, 0x78,
0x77, 0x9F, 0x4C, 0x6C, 0x6B, 0xA2, 0xE6, 0xB6,
0xDB, 0x55, 0x65, 0xC7, 0x6D, 0x3E, 0x7E, 0x7C,
0x92, 0x0C, 0xAF, 0x7F, 0x75, 0x7E, 0xF9, 0xDB,
0x7C, 0x8F, 0xCF, 0x10, 0xE5, 0x7F, 0x03, 0x37,
0x9E, 0xA9, 0xBF, 0x75, 0xEB, 0x59, 0x89, 0x5D,
0x96, 0xE1, 0x49, 0x80, 0x0B, 0x6A, 0xAE, 0x01,
0xDB, 0x77, 0x8B, 0xB9, 0x0A, 0xFB, 0xC9, 0x89
},
{
0xD8, 0x5C, 0xAB, 0xC6, 0xBD, 0x5B, 0x1A, 0x01,
0xA5, 0xAF, 0xD8, 0xC6, 0x73, 0x47, 0x40, 0xDA,
0x9F, 0xD1, 0xC1, 0xAC, 0xC6, 0xDB, 0x29, 0xBF,
0xC8, 0xA2, 0xE5, 0xB6, 0x68, 0xB0, 0x28, 0xB6,
0xB3, 0x15, 0x4B, 0xFB, 0x87, 0x03, 0xFA, 0x31,
0x80, 0x25, 0x1D, 0x58, 0x9A, 0xD3, 0x80, 0x40,
0xCE, 0xB7, 0x07, 0xC4, 0xBA, 0xD1, 0xB5, 0x34,
0x3C, 0xB4, 0x26, 0xB6, 0x1E, 0xAA, 0x49, 0xC1
},
{
0xD6, 0x2E, 0xFB, 0xEC, 0x2C, 0xA9, 0xC1, 0xF8,
0xBD, 0x66, 0xCE, 0x8B, 0x3F, 0x6A, 0x89, 0x8C,
0xB3, 0xF7, 0x56, 0x6B, 0xA6, 0x56, 0x8C, 0x61,
0x8A, 0xD1, 0xFE, 0xB2, 0xB6, 0x5B, 0x76, 0xC3,
0xCE, 0x1D, 0xD2, 0x0F, 0x73, 0x95, 0x37, 0x2F,
0xAF, 0x28, 0x42, 0x7F, 0x61, 0xC9, 0x27, 0x80,
0x49, 0xCF, 0x01, 0x40, 0xDF, 0x43, 0x4F, 0x56,
0x33, 0x04, 0x8C, 0x86, 0xB8, 0x1E, 0x03, 0x99
},
{
0x7C, 0x8F, 0xDC, 0x61, 0x75, 0x43, 0x9E, 0x2C,
0x3D, 0xB1, 0x5B, 0xAF, 0xA7, 0xFB, 0x06, 0x14,
0x3A, 0x6A, 0x23, 0xBC, 0x90, 0xF4, 0x49, 0xE7,
0x9D, 0xEE, 0xF7, 0x3C, 0x3D, 0x49, 0x2A, 0x67,
0x17, 0x15, 0xC1, 0x93, 0xB6, 0xFE, 0xA9, 0xF0,
0x36, 0x05, 0x0B, 0x94, 0x60, 0x69, 0x85, 0x6B,
0x89, 0x7E, 0x08, 0xC0, 0x07, 0x68, 0xF5, 0xEE,
0x5D, 0xDC, 0xF7, 0x0B, 0x7C, 0xD6, 0xD0, 0xE0
},
{
0x58, 0x60, 0x2E, 0xE7, 0x46, 0x8E, 0x6B, 0xC9,
0xDF, 0x21, 0xBD, 0x51, 0xB2, 0x3C, 0x00, 0x5F,
0x72, 0xD6, 0xCB, 0x01, 0x3F, 0x0A, 0x1B, 0x48,
0xCB, 0xEC, 0x5E, 0xCA, 0x29, 0x92, 0x99, 0xF9,
0x7F, 0x09, 0xF5, 0x4A, 0x9A, 0x01, 0x48, 0x3E,
0xAE, 0xB3, 0x15, 0xA6, 0x47, 0x8B, 0xAD, 0x37,
0xBA, 0x47, 0xCA, 0x13, 0x47, 0xC7, 0xC8, 0xFC,
0x9E, 0x66, 0x95, 0x59, 0x2C, 0x91, 0xD7, 0x23
},
{
0x27, 0xF5, 0xB7, 0x9E, 0xD2, 0x56, 0xB0, 0x50,
0x99, 0x3D, 0x79, 0x34, 0x96, 0xED, 0xF4, 0x80,
0x7C, 0x1D, 0x85, 0xA7, 0xB0, 0xA6, 0x7C, 0x9C,
0x4F, 0xA9, 0x98, 0x60, 0x75, 0x0B, 0x0A, 0xE6,
0x69, 0x89, 0x67, 0x0A, 0x8F, 0xFD, 0x78, 0x56,
0xD7, 0xCE, 0x41, 0x15, 0x99, 0xE5, 0x8C, 0x4D,
0x77, 0xB2, 0x32, 0xA6, 0x2B, 0xEF, 0x64, 0xD1,
0x52, 0x75, 0xBE, 0x46, 0xA6, 0x82, 0x35, 0xFF
},
{
0x39, 0x57, 0xA9, 0x76, 0xB9, 0xF1, 0x88, 0x7B,
0xF0, 0x04, 0xA8, 0xDC, 0xA9, 0x42, 0xC9, 0x2D,
0x2B, 0x37, 0xEA, 0x52, 0x60, 0x0F, 0x25, 0xE0,
0xC9, 0xBC, 0x57, 0x07, 0xD0, 0x27, 0x9C, 0x00,
0xC6, 0xE8, 0x5A, 0x83, 0x9B, 0x0D, 0x2D, 0x8E,
0xB5, 0x9C, 0x51, 0xD9, 0x47, 0x88, 0xEB, 0xE6,
0x24, 0x74, 0xA7, 0x91, 0xCA, 0xDF, 0x52, 0xCC,
0xCF, 0x20, 0xF5, 0x07, 0x0B, 0x65, 0x73, 0xFC
},
{
0xEA, 0xA2, 0x37, 0x6D, 0x55, 0x38, 0x0B, 0xF7,
0x72, 0xEC, 0xCA, 0x9C, 0xB0, 0xAA, 0x46, 0x68,
0xC9, 0x5C, 0x70, 0x71, 0x62, 0xFA, 0x86, 0xD5,
0x18, 0xC8, 0xCE, 0x0C, 0xA9, 0xBF, 0x73, 0x62,
0xB9, 0xF2, 0xA0, 0xAD, 0xC3, 0xFF, 0x59, 0x92,
0x2D, 0xF9, 0x21, 0xB9, 0x45, 0x67, 0xE8, 0x1E,
0x45, 0x2F, 0x6C, 0x1A, 0x07, 0xFC, 0x81, 0x7C,
0xEB, 0xE9, 0x96, 0x04, 0xB3, 0x50, 0x5D, 0x38
},
{
0xC1, 0xE2, 0xC7, 0x8B, 0x6B, 0x27, 0x34, 0xE2,
0x48, 0x0E, 0xC5, 0x50, 0x43, 0x4C, 0xB5, 0xD6,
0x13, 0x11, 0x1A, 0xDC, 0xC2, 0x1D, 0x47, 0x55,
0x45, 0xC3, 0xB1, 0xB7, 0xE6, 0xFF, 0x12, 0x44,
0x44, 0x76, 0xE5, 0xC0, 0x55, 0x13, 0x2E, 0x22,
0x29, 0xDC, 0x0F, 0x80, 0x70, 0x44, 0xBB, 0x91,
0x9B, 0x1A, 0x56, 0x62, 0xDD, 0x38, 0xA9, 0xEE,
0x65, 0xE2, 0x43, 0xA3, 0x91, 0x1A, 0xED, 0x1A
},
{
0x8A, 0xB4, 0x87, 0x13, 0x38, 0x9D, 0xD0, 0xFC,
0xF9, 0xF9, 0x65, 0xD3, 0xCE, 0x66, 0xB1, 0xE5,
0x59, 0xA1, 0xF8, 0xC5, 0x87, 0x41, 0xD6, 0x76,
0x83, 0xCD, 0x97, 0x13, 0x54, 0xF4, 0x52, 0xE6,
0x2D, 0x02, 0x07, 0xA6, 0x5E, 0x43, 0x6C, 0x5D,
0x5D, 0x8F, 0x8E, 0xE7, 0x1C, 0x6A, 0xBF, 0xE5,
0x0E, 0x66, 0x90, 0x04, 0xC3, 0x02, 0xB3, 0x1A,
0x7E, 0xA8, 0x31, 0x1D, 0x4A, 0x91, 0x60, 0x51
},
{
0x24, 0xCE, 0x0A, 0xDD, 0xAA, 0x4C, 0x65, 0x03,
0x8B, 0xD1, 0xB1, 0xC0, 0xF1, 0x45, 0x2A, 0x0B,
0x12, 0x87, 0x77, 0xAA, 0xBC, 0x94, 0xA2, 0x9D,
0xF2, 0xFD, 0x6C, 0x7E, 0x2F, 0x85, 0xF8, 0xAB,
0x9A, 0xC7, 0xEF, 0xF5, 0x16, 0xB0, 0xE0, 0xA8,
0x25, 0xC8, 0x4A, 0x24, 0xCF, 0xE4, 0x92, 0xEA,
0xAD, 0x0A, 0x63, 0x08, 0xE4, 0x6D, 0xD4, 0x2F,
0xE8, 0x33, 0x3A, 0xB9, 0x71, 0xBB, 0x30, 0xCA
},
{
0x51, 0x54, 0xF9, 0x29, 0xEE, 0x03, 0x04, 0x5B,
0x6B, 0x0C, 0x00, 0x04, 0xFA, 0x77, 0x8E, 0xDE,
0xE1, 0xD1, 0x39, 0x89, 0x32, 0x67, 0xCC, 0x84,
0x82, 0x5A, 0xD7, 0xB3, 0x6C, 0x63, 0xDE, 0x32,
0x79, 0x8E, 0x4A, 0x16, 0x6D, 0x24, 0x68, 0x65,
0x61, 0x35, 0x4F, 0x63, 0xB0, 0x07, 0x09, 0xA1,
0x36, 0x4B, 0x3C, 0x24, 0x1D, 0xE3, 0xFE, 0xBF,
0x07, 0x54, 0x04, 0x58, 0x97, 0x46, 0x7C, 0xD4
},
{
0xE7, 0x4E, 0x90, 0x79, 0x20, 0xFD, 0x87, 0xBD,
0x5A, 0xD6, 0x36, 0xDD, 0x11, 0x08, 0x5E, 0x50,
0xEE, 0x70, 0x45, 0x9C, 0x44, 0x3E, 0x1C, 0xE5,
0x80, 0x9A, 0xF2, 0xBC, 0x2E, 0xBA, 0x39, 0xF9,
0xE6, 0xD7, 0x12, 0x8E, 0x0E, 0x37, 0x12, 0xC3,
0x16, 0xDA, 0x06, 0xF4, 0x70, 0x5D, 0x78, 0xA4,
0x83, 0x8E, 0x28, 0x12, 0x1D, 0x43, 0x44, 0xA2,
0xC7, 0x9C, 0x5E, 0x0D, 0xB3, 0x07, 0xA6, 0x77
},
{
0xBF, 0x91, 0xA2, 0x23, 0x34, 0xBA, 0xC2, 0x0F,
0x3F, 0xD8, 0x06, 0x63, 0xB3, 0xCD, 0x06, 0xC4,
0xE8, 0x80, 0x2F, 0x30, 0xE6, 0xB5, 0x9F, 0x90,
0xD3, 0x03, 0x5C, 0xC9, 0x79, 0x8A, 0x21, 0x7E,
0xD5, 0xA3, 0x1A, 0xBB, 0xDA, 0x7F, 0xA6, 0x84,
0x28, 0x27, 0xBD, 0xF2, 0xA7, 0xA1, 0xC2, 0x1F,
0x6F, 0xCF, 0xCC, 0xBB, 0x54, 0xC6, 0xC5, 0x29,
0x26, 0xF3, 0x2D, 0xA8, 0x16, 0x26, 0x9B, 0xE1
},
{
0xD9, 0xD5, 0xC7, 0x4B, 0xE5, 0x12, 0x1B, 0x0B,
0xD7, 0x42, 0xF2, 0x6B, 0xFF, 0xB8, 0xC8, 0x9F,
0x89, 0x17, 0x1F, 0x3F, 0x93, 0x49, 0x13, 0x49,
0x2B, 0x09, 0x03, 0xC2, 0x71, 0xBB, 0xE2, 0xB3,
0x39, 0x5E, 0xF2, 0x59, 0x66, 0x9B, 0xEF, 0x43,
0xB5, 0x7F, 0x7F, 0xCC, 0x30, 0x27, 0xDB, 0x01,
0x82, 0x3F, 0x6B, 0xAE, 0xE6, 0x6E, 0x4F, 0x9F,
0xEA, 0xD4, 0xD6, 0x72, 0x6C, 0x74, 0x1F, 0xCE
},
{
0x50, 0xC8, 0xB8, 0xCF, 0x34, 0xCD, 0x87, 0x9F,
0x80, 0xE2, 0xFA, 0xAB, 0x32, 0x30, 0xB0, 0xC0,
0xE1, 0xCC, 0x3E, 0x9D, 0xCA, 0xDE, 0xB1, 0xB9,
0xD9, 0x7A, 0xB9, 0x23, 0x41, 0x5D, 0xD9, 0xA1,
0xFE, 0x38, 0xAD, 0xDD, 0x5C, 0x11, 0x75, 0x6C,
0x67, 0x99, 0x0B, 0x25, 0x6E, 0x95, 0xAD, 0x6D,
0x8F, 0x9F, 0xED, 0xCE, 0x10, 0xBF, 0x1C, 0x90,
0x67, 0x9C, 0xDE, 0x0E, 0xCF, 0x1B, 0xE3, 0x47
},
{
0x0A, 0x38, 0x6E, 0x7C, 0xD5, 0xDD, 0x9B, 0x77,
0xA0, 0x35, 0xE0, 0x9F, 0xE6, 0xFE, 0xE2, 0xC8,
0xCE, 0x61, 0xB5, 0x38, 0x3C, 0x87, 0xEA, 0x43,
0x20, 0x50, 0x59, 0xC5, 0xE4, 0xCD, 0x4F, 0x44,
0x08, 0x31, 0x9B, 0xB0, 0xA8, 0x23, 0x60, 0xF6,
0xA5, 0x8E, 0x6C, 0x9C, 0xE3, 0xF4, 0x87, 0xC4,
0x46, 0x06, 0x3B, 0xF8, 0x13, 0xBC, 0x6B, 0xA5,
0x35, 0xE1, 0x7F, 0xC1, 0x82, 0x6C, 0xFC, 0x91
},
{
0x1F, 0x14, 0x59, 0xCB, 0x6B, 0x61, 0xCB, 0xAC,
0x5F, 0x0E, 0xFE, 0x8F, 0xC4, 0x87, 0x53, 0x8F,
0x42, 0x54, 0x89, 0x87, 0xFC, 0xD5, 0x62, 0x21,
0xCF, 0xA7, 0xBE, 0xB2, 0x25, 0x04, 0x76, 0x9E,
0x79, 0x2C, 0x45, 0xAD, 0xFB, 0x1D, 0x6B, 0x3D,
0x60, 0xD7, 0xB7, 0x49, 0xC8, 0xA7, 0x5B, 0x0B,
0xDF, 0x14, 0xE8, 0xEA, 0x72, 0x1B, 0x95, 0xDC,
0xA5, 0x38, 0xCA, 0x6E, 0x25, 0x71, 0x12, 0x09
},
{
0xE5, 0x8B, 0x38, 0x36, 0xB7, 0xD8, 0xFE, 0xDB,
0xB5, 0x0C, 0xA5, 0x72, 0x5C, 0x65, 0x71, 0xE7,
0x4C, 0x07, 0x85, 0xE9, 0x78, 0x21, 0xDA, 0xB8,
0xB6, 0x29, 0x8C, 0x10, 0xE4, 0xC0, 0x79, 0xD4,
0xA6, 0xCD, 0xF2, 0x2F, 0x0F, 0xED, 0xB5, 0x50,
0x32, 0x92, 0x5C, 0x16, 0x74, 0x81, 0x15, 0xF0,
0x1A, 0x10, 0x5E, 0x77, 0xE0, 0x0C, 0xEE, 0x3D,
0x07, 0x92, 0x4D, 0xC0, 0xD8, 0xF9, 0x06, 0x59
},
{
0xB9, 0x29, 0xCC, 0x65, 0x05, 0xF0, 0x20, 0x15,
0x86, 0x72, 0xDE, 0xDA, 0x56, 0xD0, 0xDB, 0x08,
0x1A, 0x2E, 0xE3, 0x4C, 0x00, 0xC1, 0x10, 0x00,
0x29, 0xBD, 0xF8, 0xEA, 0x98, 0x03, 0x4F, 0xA4,
0xBF, 0x3E, 0x86, 0x55, 0xEC, 0x69, 0x7F, 0xE3,
0x6F, 0x40, 0x55, 0x3C, 0x5B, 0xB4, 0x68, 0x01,
0x64, 0x4A, 0x62, 0x7D, 0x33, 0x42, 0xF4, 0xFC,
0x92, 0xB6, 0x1F, 0x03, 0x29, 0x0F, 0xB3, 0x81
},
{
0x72, 0xD3, 0x53, 0x99, 0x4B, 0x49, 0xD3, 0xE0,
0x31, 0x53, 0x92, 0x9A, 0x1E, 0x4D, 0x4F, 0x18,
0x8E, 0xE5, 0x8A, 0xB9, 0xE7, 0x2E, 0xE8, 0xE5,
0x12, 0xF2, 0x9B, 0xC7, 0x73, 0x91, 0x38, 0x19,
0xCE, 0x05, 0x7D, 0xDD, 0x70, 0x02, 0xC0, 0x43,
0x3E, 0xE0, 0xA1, 0x61, 0x14, 0xE3, 0xD1, 0x56,
0xDD, 0x2C, 0x4A, 0x7E, 0x80, 0xEE, 0x53, 0x37,
0x8B, 0x86, 0x70, 0xF2, 0x3E, 0x33, 0xEF, 0x56
},
{
0xC7, 0x0E, 0xF9, 0xBF, 0xD7, 0x75, 0xD4, 0x08,
0x17, 0x67, 0x37, 0xA0, 0x73, 0x6D, 0x68, 0x51,
0x7C, 0xE1, 0xAA, 0xAD, 0x7E, 0x81, 0xA9, 0x3C,
0x8C, 0x1E, 0xD9, 0x67, 0xEA, 0x21, 0x4F, 0x56,
0xC8, 0xA3, 0x77, 0xB1, 0x76, 0x3E, 0x67, 0x66,
0x15, 0xB6, 0x0F, 0x39, 0x88, 0x24, 0x1E, 0xAE,
0x6E, 0xAB, 0x96, 0x85, 0xA5, 0x12, 0x49, 0x29,
0xD2, 0x81, 0x88, 0xF2, 0x9E, 0xAB, 0x06, 0xF7
},
{
0xC2, 0x30, 0xF0, 0x80, 0x26, 0x79, 0xCB, 0x33,
0x82, 0x2E, 0xF8, 0xB3, 0xB2, 0x1B, 0xF7, 0xA9,
0xA2, 0x89, 0x42, 0x09, 0x29, 0x01, 0xD7, 0xDA,
0xC3, 0x76, 0x03, 0x00, 0x83, 0x10, 0x26, 0xCF,
0x35, 0x4C, 0x92, 0x32, 0xDF, 0x3E, 0x08, 0x4D,
0x99, 0x03, 0x13, 0x0C, 0x60, 0x1F, 0x63, 0xC1,
0xF4, 0xA4, 0xA4, 0xB8, 0x10, 0x6E, 0x46, 0x8C,
0xD4, 0x43, 0xBB, 0xE5, 0xA7, 0x34, 0xF4, 0x5F
},
{
0x6F, 0x43, 0x09, 0x4C, 0xAF, 0xB5, 0xEB, 0xF1,
0xF7, 0xA4, 0x93, 0x7E, 0xC5, 0x0F, 0x56, 0xA4,
0xC9, 0xDA, 0x30, 0x3C, 0xBB, 0x55, 0xAC, 0x1F,
0x27, 0xF1, 0xF1, 0x97, 0x6C, 0xD9, 0x6B, 0xED,
0xA9, 0x46, 0x4F, 0x0E, 0x7B, 0x9C, 0x54, 0x62,
0x0B, 0x8A, 0x9F, 0xBA, 0x98, 0x31, 0x64, 0xB8,
0xBE, 0x35, 0x78, 0x42, 0x5A, 0x02, 0x4F, 0x5F,
0xE1, 0x99, 0xC3, 0x63, 0x56, 0xB8, 0x89, 0x72
},
{
0x37, 0x45, 0x27, 0x3F, 0x4C, 0x38, 0x22, 0x5D,
0xB2, 0x33, 0x73, 0x81, 0x87, 0x1A, 0x0C, 0x6A,
0xAF, 0xD3, 0xAF, 0x9B, 0x01, 0x8C, 0x88, 0xAA,
0x02, 0x02, 0x58, 0x50, 0xA5, 0xDC, 0x3A, 0x42,
0xA1, 0xA3, 0xE0, 0x3E, 0x56, 0xCB, 0xF1, 0xB0,
0x87, 0x6D, 0x63, 0xA4, 0x41, 0xF1, 0xD2, 0x85,
0x6A, 0x39, 0xB8, 0x80, 0x1E, 0xB5, 0xAF, 0x32,
0x52, 0x01, 0xC4, 0x15, 0xD6, 0x5E, 0x97, 0xFE
},
{
0xC5, 0x0C, 0x44, 0xCC, 0xA3, 0xEC, 0x3E, 0xDA,
0xAE, 0x77, 0x9A, 0x7E, 0x17, 0x94, 0x50, 0xEB,
0xDD, 0xA2, 0xF9, 0x70, 0x67, 0xC6, 0x90, 0xAA,
0x6C, 0x5A, 0x4A, 0xC7, 0xC3, 0x01, 0x39, 0xBB,
0x27, 0xC0, 0xDF, 0x4D, 0xB3, 0x22, 0x0E, 0x63,
0xCB, 0x11, 0x0D, 0x64, 0xF3, 0x7F, 0xFE, 0x07,
0x8D, 0xB7, 0x26, 0x53, 0xE2, 0xDA, 0xAC, 0xF9,
0x3A, 0xE3, 0xF0, 0xA2, 0xD1, 0xA7, 0xEB, 0x2E
},
{
0x8A, 0xEF, 0x26, 0x3E, 0x38, 0x5C, 0xBC, 0x61,
0xE1, 0x9B, 0x28, 0x91, 0x42, 0x43, 0x26, 0x2A,
0xF5, 0xAF, 0xE8, 0x72, 0x6A, 0xF3, 0xCE, 0x39,
0xA7, 0x9C, 0x27, 0x02, 0x8C, 0xF3, 0xEC, 0xD3,
0xF8, 0xD2, 0xDF, 0xD9, 0xCF, 0xC9, 0xAD, 0x91,
0xB5, 0x8F, 0x6F, 0x20, 0x77, 0x8F, 0xD5, 0xF0,
0x28, 0x94, 0xA3, 0xD9, 0x1C, 0x7D, 0x57, 0xD1,
0xE4, 0xB8, 0x66, 0xA7, 0xF3, 0x64, 0xB6, 0xBE
},
{
0x28, 0x69, 0x61, 0x41, 0xDE, 0x6E, 0x2D, 0x9B,
0xCB, 0x32, 0x35, 0x57, 0x8A, 0x66, 0x16, 0x6C,
0x14, 0x48, 0xD3, 0xE9, 0x05, 0xA1, 0xB4, 0x82,
0xD4, 0x23, 0xBE, 0x4B, 0xC5, 0x36, 0x9B, 0xC8,
0xC7, 0x4D, 0xAE, 0x0A, 0xCC, 0x9C, 0xC1, 0x23,
0xE1, 0xD8, 0xDD, 0xCE, 0x9F, 0x97, 0x91, 0x7E,
0x8C, 0x01, 0x9C, 0x55, 0x2D, 0xA3, 0x2D, 0x39,
0xD2, 0x21, 0x9B, 0x9A, 0xBF, 0x0F, 0xA8, 0xC8
},
{
0x2F, 0xB9, 0xEB, 0x20, 0x85, 0x83, 0x01, 0x81,
0x90, 0x3A, 0x9D, 0xAF, 0xE3, 0xDB, 0x42, 0x8E,
0xE1, 0x5B, 0xE7, 0x66, 0x22, 0x24, 0xEF, 0xD6,
0x43, 0x37, 0x1F, 0xB2, 0x56, 0x46, 0xAE, 0xE7,
0x16, 0xE5, 0x31, 0xEC, 0xA6, 0x9B, 0x2B, 0xDC,
0x82, 0x33, 0xF1, 0xA8, 0x08, 0x1F, 0xA4, 0x3D,
0xA1, 0x50, 0x03, 0x02, 0x97, 0x5A, 0x77, 0xF4,
0x2F, 0xA5, 0x92, 0x13, 0x67, 0x10, 0xE9, 0xDC
},
{
0x66, 0xF9, 0xA7, 0x14, 0x3F, 0x7A, 0x33, 0x14,
0xA6, 0x69, 0xBF, 0x2E, 0x24, 0xBB, 0xB3, 0x50,
0x14, 0x26, 0x1D, 0x63, 0x9F, 0x49, 0x5B, 0x6C,
0x9C, 0x1F, 0x10, 0x4F, 0xE8, 0xE3, 0x20, 0xAC,
0xA6, 0x0D, 0x45, 0x50, 0xD6, 0x9D, 0x52, 0xED,
0xBD, 0x5A, 0x3C, 0xDE, 0xB4, 0x01, 0x4A, 0xE6,
0x5B, 0x1D, 0x87, 0xAA, 0x77, 0x0B, 0x69, 0xAE,
0x5C, 0x15, 0xF4, 0x33, 0x0B, 0x0B, 0x0A, 0xD8
},
{
0xF4, 0xC4, 0xDD, 0x1D, 0x59, 0x4C, 0x35, 0x65,
0xE3, 0xE2, 0x5C, 0xA4, 0x3D, 0xAD, 0x82, 0xF6,
0x2A, 0xBE, 0xA4, 0x83, 0x5E, 0xD4, 0xCD, 0x81,
0x1B, 0xCD, 0x97, 0x5E, 0x46, 0x27, 0x98, 0x28,
0xD4, 0x4D, 0x4C, 0x62, 0xC3, 0x67, 0x9F, 0x1B,
0x7F, 0x7B, 0x9D, 0xD4, 0x57, 0x1D, 0x7B, 0x49,
0x55, 0x73, 0x47, 0xB8, 0xC5, 0x46, 0x0C, 0xBD,
0xC1, 0xBE, 0xF6, 0x90, 0xFB, 0x2A, 0x08, 0xC0
},
{
0x8F, 0x1D, 0xC9, 0x64, 0x9C, 0x3A, 0x84, 0x55,
0x1F, 0x8F, 0x6E, 0x91, 0xCA, 0xC6, 0x82, 0x42,
0xA4, 0x3B, 0x1F, 0x8F, 0x32, 0x8E, 0xE9, 0x22,
0x80, 0x25, 0x73, 0x87, 0xFA, 0x75, 0x59, 0xAA,
0x6D, 0xB1, 0x2E, 0x4A, 0xEA, 0xDC, 0x2D, 0x26,
0x09, 0x91, 0x78, 0x74, 0x9C, 0x68, 0x64, 0xB3,
0x57, 0xF3, 0xF8, 0x3B, 0x2F, 0xB3, 0xEF, 0xA8,
0xD2, 0xA8, 0xDB, 0x05, 0x6B, 0xED, 0x6B, 0xCC
},
{
0x31, 0x39, 0xC1, 0xA7, 0xF9, 0x7A, 0xFD, 0x16,
0x75, 0xD4, 0x60, 0xEB, 0xBC, 0x07, 0xF2, 0x72,
0x8A, 0xA1, 0x50, 0xDF, 0x84, 0x96, 0x24, 0x51,
0x1E, 0xE0, 0x4B, 0x74, 0x3B, 0xA0, 0xA8, 0x33,
0x09, 0x2F, 0x18, 0xC1, 0x2D, 0xC9, 0x1B, 0x4D,
0xD2, 0x43, 0xF3, 0x33, 0x40, 0x2F, 0x59, 0xFE,
0x28, 0xAB, 0xDB, 0xBB, 0xAE, 0x30, 0x1E, 0x7B,
0x65, 0x9C, 0x7A, 0x26, 0xD5, 0xC0, 0xF9, 0x79
},
{
0x06, 0xF9, 0x4A, 0x29, 0x96, 0x15, 0x8A, 0x81,
0x9F, 0xE3, 0x4C, 0x40, 0xDE, 0x3C, 0xF0, 0x37,
0x9F, 0xD9, 0xFB, 0x85, 0xB3, 0xE3, 0x63, 0xBA,
0x39, 0x26, 0xA0, 0xE7, 0xD9, 0x60, 0xE3, 0xF4,
0xC2, 0xE0, 0xC7, 0x0C, 0x7C, 0xE0, 0xCC, 0xB2,
0xA6, 0x4F, 0xC2, 0x98, 0x69, 0xF6, 0xE7, 0xAB,
0x12, 0xBD, 0x4D, 0x3F, 0x14, 0xFC, 0xE9, 0x43,
0x27, 0x90, 0x27, 0xE7, 0x85, 0xFB, 0x5C, 0x29
},
{
0xC2, 0x9C, 0x39, 0x9E, 0xF3, 0xEE, 0xE8, 0x96,
0x1E, 0x87, 0x56, 0x5C, 0x1C, 0xE2, 0x63, 0x92,
0x5F, 0xC3, 0xD0, 0xCE, 0x26, 0x7D, 0x13, 0xE4,
0x8D, 0xD9, 0xE7, 0x32, 0xEE, 0x67, 0xB0, 0xF6,
0x9F, 0xAD, 0x56, 0x40, 0x1B, 0x0F, 0x10, 0xFC,
0xAA, 0xC1, 0x19, 0x20, 0x10, 0x46, 0xCC, 0xA2,
0x8C, 0x5B, 0x14, 0xAB, 0xDE, 0xA3, 0x21, 0x2A,
0xE6, 0x55, 0x62, 0xF7, 0xF1, 0x38, 0xDB, 0x3D
},
{
0x4C, 0xEC, 0x4C, 0x9D, 0xF5, 0x2E, 0xEF, 0x05,
0xC3, 0xF6, 0xFA, 0xAA, 0x97, 0x91, 0xBC, 0x74,
0x45, 0x93, 0x71, 0x83, 0x22, 0x4E, 0xCC, 0x37,
0xA1, 0xE5, 0x8D, 0x01, 0x32, 0xD3, 0x56, 0x17,
0x53, 0x1D, 0x7E, 0x79, 0x5F, 0x52, 0xAF, 0x7B,
0x1E, 0xB9, 0xD1, 0x47, 0xDE, 0x12, 0x92, 0xD3,
0x45, 0xFE, 0x34, 0x18, 0x23, 0xF8, 0xE6, 0xBC,
0x1E, 0x5B, 0xAD, 0xCA, 0x5C, 0x65, 0x61, 0x08
},
{
0x89, 0x8B, 0xFB, 0xAE, 0x93, 0xB3, 0xE1, 0x8D,
0x00, 0x69, 0x7E, 0xAB, 0x7D, 0x97, 0x04, 0xFA,
0x36, 0xEC, 0x33, 0x9D, 0x07, 0x61, 0x31, 0xCE,
0xFD, 0xF3, 0x0E, 0xDB, 0xE8, 0xD9, 0xCC, 0x81,
0xC3, 0xA8, 0x0B, 0x12, 0x96, 0x59, 0xB1, 0x63,
0xA3, 0x23, 0xBA, 0xB9, 0x79, 0x3D, 0x4F, 0xEE,
0xD9, 0x2D, 0x54, 0xDA, 0xE9, 0x66, 0xC7, 0x75,
0x29, 0x76, 0x4A, 0x09, 0xBE, 0x88, 0xDB, 0x45
},
{
0xEE, 0x9B, 0xD0, 0x46, 0x9D, 0x3A, 0xAF, 0x4F,
0x14, 0x03, 0x5B, 0xE4, 0x8A, 0x2C, 0x3B, 0x84,
0xD9, 0xB4, 0xB1, 0xFF, 0xF1, 0xD9, 0x45, 0xE1,
0xF1, 0xC1, 0xD3, 0x89, 0x80, 0xA9, 0x51, 0xBE,
0x19, 0x7B, 0x25, 0xFE, 0x22, 0xC7, 0x31, 0xF2,
0x0A, 0xEA, 0xCC, 0x93, 0x0B, 0xA9, 0xC4, 0xA1,
0xF4, 0x76, 0x22, 0x27, 0x61, 0x7A, 0xD3, 0x50,
0xFD, 0xAB, 0xB4, 0xE8, 0x02, 0x73, 0xA0, 0xF4
},
{
0x3D, 0x4D, 0x31, 0x13, 0x30, 0x05, 0x81, 0xCD,
0x96, 0xAC, 0xBF, 0x09, 0x1C, 0x3D, 0x0F, 0x3C,
0x31, 0x01, 0x38, 0xCD, 0x69, 0x79, 0xE6, 0x02,
0x6C, 0xDE, 0x62, 0x3E, 0x2D, 0xD1, 0xB2, 0x4D,
0x4A, 0x86, 0x38, 0xBE, 0xD1, 0x07, 0x33, 0x44,
0x78, 0x3A, 0xD0, 0x64, 0x9C, 0xC6, 0x30, 0x5C,
0xCE, 0xC0, 0x4B, 0xEB, 0x49, 0xF3, 0x1C, 0x63,
0x30, 0x88, 0xA9, 0x9B, 0x65, 0x13, 0x02, 0x67
},
{
0x95, 0xC0, 0x59, 0x1A, 0xD9, 0x1F, 0x92, 0x1A,
0xC7, 0xBE, 0x6D, 0x9C, 0xE3, 0x7E, 0x06, 0x63,
0xED, 0x80, 0x11, 0xC1, 0xCF, 0xD6, 0xD0, 0x16,
0x2A, 0x55, 0x72, 0xE9, 0x43, 0x68, 0xBA, 0xC0,
0x20, 0x24, 0x48, 0x5E, 0x6A, 0x39, 0x85, 0x4A,
0xA4, 0x6F, 0xE3, 0x8E, 0x97, 0xD6, 0xC6, 0xB1,
0x94, 0x7C, 0xD2, 0x72, 0xD8, 0x6B, 0x06, 0xBB,
0x5B, 0x2F, 0x78, 0xB9, 0xB6, 0x8D, 0x55, 0x9D
},
{
0x22, 0x7B, 0x79, 0xDE, 0xD3, 0x68, 0x15, 0x3B,
0xF4, 0x6C, 0x0A, 0x3C, 0xA9, 0x78, 0xBF, 0xDB,
0xEF, 0x31, 0xF3, 0x02, 0x4A, 0x56, 0x65, 0x84,
0x24, 0x68, 0x49, 0x0B, 0x0F, 0xF7, 0x48, 0xAE,
0x04, 0xE7, 0x83, 0x2E, 0xD4, 0xC9, 0xF4, 0x9D,
0xE9, 0xB1, 0x70, 0x67, 0x09, 0xD6, 0x23, 0xE5,
0xC8, 0xC1, 0x5E, 0x3C, 0xAE, 0xCA, 0xE8, 0xD5,
0xE4, 0x33, 0x43, 0x0F, 0xF7, 0x2F, 0x20, 0xEB
},
{
0x5D, 0x34, 0xF3, 0x95, 0x2F, 0x01, 0x05, 0xEE,
0xF8, 0x8A, 0xE8, 0xB6, 0x4C, 0x6C, 0xE9, 0x5E,
0xBF, 0xAD, 0xE0, 0xE0, 0x2C, 0x69, 0xB0, 0x87,
0x62, 0xA8, 0x71, 0x2D, 0x2E, 0x49, 0x11, 0xAD,
0x3F, 0x94, 0x1F, 0xC4, 0x03, 0x4D, 0xC9, 0xB2,
0xE4, 0x79, 0xFD, 0xBC, 0xD2, 0x79, 0xB9, 0x02,
0xFA, 0xF5, 0xD8, 0x38, 0xBB, 0x2E, 0x0C, 0x64,
0x95, 0xD3, 0x72, 0xB5, 0xB7, 0x02, 0x98, 0x13
},
{
0x7F, 0x93, 0x9B, 0xF8, 0x35, 0x3A, 0xBC, 0xE4,
0x9E, 0x77, 0xF1, 0x4F, 0x37, 0x50, 0xAF, 0x20,
0xB7, 0xB0, 0x39, 0x02, 0xE1, 0xA1, 0xE7, 0xFB,
0x6A, 0xAF, 0x76, 0xD0, 0x25, 0x9C, 0xD4, 0x01,
0xA8, 0x31, 0x90, 0xF1, 0x56, 0x40, 0xE7, 0x4F,
0x3E, 0x6C, 0x5A, 0x90, 0xE8, 0x39, 0xC7, 0x82,
0x1F, 0x64, 0x74, 0x75, 0x7F, 0x75, 0xC7, 0xBF,
0x90, 0x02, 0x08, 0x4D, 0xDC, 0x7A, 0x62, 0xDC
},
{
0x06, 0x2B, 0x61, 0xA2, 0xF9, 0xA3, 0x3A, 0x71,
0xD7, 0xD0, 0xA0, 0x61, 0x19, 0x64, 0x4C, 0x70,
0xB0, 0x71, 0x6A, 0x50, 0x4D, 0xE7, 0xE5, 0xE1,
0xBE, 0x49, 0xBD, 0x7B, 0x86, 0xE7, 0xED, 0x68,
0x17, 0x71, 0x4F, 0x9F, 0x0F, 0xC3, 0x13, 0xD0,
0x61, 0x29, 0x59, 0x7E, 0x9A, 0x22, 0x35, 0xEC,
0x85, 0x21, 0xDE, 0x36, 0xF7, 0x29, 0x0A, 0x90,
0xCC, 0xFC, 0x1F, 0xFA, 0x6D, 0x0A, 0xEE, 0x29
},
{
0xF2, 0x9E, 0x01, 0xEE, 0xAE, 0x64, 0x31, 0x1E,
0xB7, 0xF1, 0xC6, 0x42, 0x2F, 0x94, 0x6B, 0xF7,
0xBE, 0xA3, 0x63, 0x79, 0x52, 0x3E, 0x7B, 0x2B,
0xBA, 0xBA, 0x7D, 0x1D, 0x34, 0xA2, 0x2D, 0x5E,
0xA5, 0xF1, 0xC5, 0xA0, 0x9D, 0x5C, 0xE1, 0xFE,
0x68, 0x2C, 0xCE, 0xD9, 0xA4, 0x79, 0x8D, 0x1A,
0x05, 0xB4, 0x6C, 0xD7, 0x2D, 0xFF, 0x5C, 0x1B,
0x35, 0x54, 0x40, 0xB2, 0xA2, 0xD4, 0x76, 0xBC
},
{
0xEC, 0x38, 0xCD, 0x3B, 0xBA, 0xB3, 0xEF, 0x35,
0xD7, 0xCB, 0x6D, 0x5C, 0x91, 0x42, 0x98, 0x35,
0x1D, 0x8A, 0x9D, 0xC9, 0x7F, 0xCE, 0xE0, 0x51,
0xA8, 0xA0, 0x2F, 0x58, 0xE3, 0xED, 0x61, 0x84,
0xD0, 0xB7, 0x81, 0x0A, 0x56, 0x15, 0x41, 0x1A,
0xB1, 0xB9, 0x52, 0x09, 0xC3, 0xC8, 0x10, 0x11,
0x4F, 0xDE, 0xB2, 0x24, 0x52, 0x08, 0x4E, 0x77,
0xF3, 0xF8, 0x47, 0xC6, 0xDB, 0xAA, 0xFE, 0x16
},
{
0xC2, 0xAE, 0xF5, 0xE0, 0xCA, 0x43, 0xE8, 0x26,
0x41, 0x56, 0x5B, 0x8C, 0xB9, 0x43, 0xAA, 0x8B,
0xA5, 0x35, 0x50, 0xCA, 0xEF, 0x79, 0x3B, 0x65,
0x32, 0xFA, 0xFA, 0xD9, 0x4B, 0x81, 0x60, 0x82,
0xF0, 0x11, 0x3A, 0x3E, 0xA2, 0xF6, 0x36, 0x08,
0xAB, 0x40, 0x43, 0x7E, 0xCC, 0x0F, 0x02, 0x29,
0xCB, 0x8F, 0xA2, 0x24, 0xDC, 0xF1, 0xC4, 0x78,
0xA6, 0x7D, 0x9B, 0x64, 0x16, 0x2B, 0x92, 0xD1
},
{
0x15, 0xF5, 0x34, 0xEF, 0xFF, 0x71, 0x05, 0xCD,
0x1C, 0x25, 0x4D, 0x07, 0x4E, 0x27, 0xD5, 0x89,
0x8B, 0x89, 0x31, 0x3B, 0x7D, 0x36, 0x6D, 0xC2,
0xD7, 0xD8, 0x71, 0x13, 0xFA, 0x7D, 0x53, 0xAA,
0xE1, 0x3F, 0x6D, 0xBA, 0x48, 0x7A, 0xD8, 0x10,
0x3D, 0x5E, 0x85, 0x4C, 0x91, 0xFD, 0xB6, 0xE1,
0xE7, 0x4B, 0x2E, 0xF6, 0xD1, 0x43, 0x17, 0x69,
0xC3, 0x07, 0x67, 0xDD, 0xE0, 0x67, 0xA3, 0x5C
},
{
0x89, 0xAC, 0xBC, 0xA0, 0xB1, 0x69, 0x89, 0x7A,
0x0A, 0x27, 0x14, 0xC2, 0xDF, 0x8C, 0x95, 0xB5,
0xB7, 0x9C, 0xB6, 0x93, 0x90, 0x14, 0x2B, 0x7D,
0x60, 0x18, 0xBB, 0x3E, 0x30, 0x76, 0xB0, 0x99,
0xB7, 0x9A, 0x96, 0x41, 0x52, 0xA9, 0xD9, 0x12,
0xB1, 0xB8, 0x64, 0x12, 0xB7, 0xE3, 0x72, 0xE9,
0xCE, 0xCA, 0xD7, 0xF2, 0x5D, 0x4C, 0xBA, 0xB8,
0xA3, 0x17, 0xBE, 0x36, 0x49, 0x2A, 0x67, 0xD7
},
{
0xE3, 0xC0, 0x73, 0x91, 0x90, 0xED, 0x84, 0x9C,
0x9C, 0x96, 0x2F, 0xD9, 0xDB, 0xB5, 0x5E, 0x20,
0x7E, 0x62, 0x4F, 0xCA, 0xC1, 0xEB, 0x41, 0x76,
0x91, 0x51, 0x54, 0x99, 0xEE, 0xA8, 0xD8, 0x26,
0x7B, 0x7E, 0x8F, 0x12, 0x87, 0xA6, 0x36, 0x33,
0xAF, 0x50, 0x11, 0xFD, 0xE8, 0xC4, 0xDD, 0xF5,
0x5B, 0xFD, 0xF7, 0x22, 0xED, 0xF8, 0x88, 0x31,
0x41, 0x4F, 0x2C, 0xFA, 0xED, 0x59, 0xCB, 0x9A
},
{
0x8D, 0x6C, 0xF8, 0x7C, 0x08, 0x38, 0x0D, 0x2D,
0x15, 0x06, 0xEE, 0xE4, 0x6F, 0xD4, 0x22, 0x2D,
0x21, 0xD8, 0xC0, 0x4E, 0x58, 0x5F, 0xBF, 0xD0,
0x82, 0x69, 0xC9, 0x8F, 0x70, 0x28, 0x33, 0xA1,
0x56, 0x32, 0x6A, 0x07, 0x24, 0x65, 0x64, 0x00,
0xEE, 0x09, 0x35, 0x1D, 0x57, 0xB4, 0x40, 0x17,
0x5E, 0x2A, 0x5D, 0xE9, 0x3C, 0xC5, 0xF8, 0x0D,
0xB6, 0xDA, 0xF8, 0x35, 0x76, 0xCF, 0x75, 0xFA
},
{
0xDA, 0x24, 0xBE, 0xDE, 0x38, 0x36, 0x66, 0xD5,
0x63, 0xEE, 0xED, 0x37, 0xF6, 0x31, 0x9B, 0xAF,
0x20, 0xD5, 0xC7, 0x5D, 0x16, 0x35, 0xA6, 0xBA,
0x5E, 0xF4, 0xCF, 0xA1, 0xAC, 0x95, 0x48, 0x7E,
0x96, 0xF8, 0xC0, 0x8A, 0xF6, 0x00, 0xAA, 0xB8,
0x7C, 0x98, 0x6E, 0xBA, 0xD4, 0x9F, 0xC7, 0x0A,
0x58, 0xB4, 0x89, 0x0B, 0x9C, 0x87, 0x6E, 0x09,
0x10, 0x16, 0xDA, 0xF4, 0x9E, 0x1D, 0x32, 0x2E
},
{
0xF9, 0xD1, 0xD1, 0xB1, 0xE8, 0x7E, 0xA7, 0xAE,
0x75, 0x3A, 0x02, 0x97, 0x50, 0xCC, 0x1C, 0xF3,
0xD0, 0x15, 0x7D, 0x41, 0x80, 0x5E, 0x24, 0x5C,
0x56, 0x17, 0xBB, 0x93, 0x4E, 0x73, 0x2F, 0x0A,
0xE3, 0x18, 0x0B, 0x78, 0xE0, 0x5B, 0xFE, 0x76,
0xC7, 0xC3, 0x05, 0x1E, 0x3E, 0x3A, 0xC7, 0x8B,
0x9B, 0x50, 0xC0, 0x51, 0x42, 0x65, 0x7E, 0x1E,
0x03, 0x21, 0x5D, 0x6E, 0xC7, 0xBF, 0xD0, 0xFC
},
{
0x11, 0xB7, 0xBC, 0x16, 0x68, 0x03, 0x20, 0x48,
0xAA, 0x43, 0x34, 0x3D, 0xE4, 0x76, 0x39, 0x5E,
0x81, 0x4B, 0xBB, 0xC2, 0x23, 0x67, 0x8D, 0xB9,
0x51, 0xA1, 0xB0, 0x3A, 0x02, 0x1E, 0xFA, 0xC9,
0x48, 0xCF, 0xBE, 0x21, 0x5F, 0x97, 0xFE, 0x9A,
0x72, 0xA2, 0xF6, 0xBC, 0x03, 0x9E, 0x39, 0x56,
0xBF, 0xA4, 0x17, 0xC1, 0xA9, 0xF1, 0x0D, 0x6D,
0x7B, 0xA5, 0xD3, 0xD3, 0x2F, 0xF3, 0x23, 0xE5
},
{
0xB8, 0xD9, 0x00, 0x0E, 0x4F, 0xC2, 0xB0, 0x66,
0xED, 0xB9, 0x1A, 0xFE, 0xE8, 0xE7, 0xEB, 0x0F,
0x24, 0xE3, 0xA2, 0x01, 0xDB, 0x8B, 0x67, 0x93,
0xC0, 0x60, 0x85, 0x81, 0xE6, 0x28, 0xED, 0x0B,
0xCC, 0x4E, 0x5A, 0xA6, 0x78, 0x79, 0x92, 0xA4,
0xBC, 0xC4, 0x4E, 0x28, 0x80, 0x93, 0xE6, 0x3E,
0xE8, 0x3A, 0xBD, 0x0B, 0xC3, 0xEC, 0x6D, 0x09,
0x34, 0xA6, 0x74, 0xA4, 0xDA, 0x13, 0x83, 0x8A
},
{
0xCE, 0x32, 0x5E, 0x29, 0x4F, 0x9B, 0x67, 0x19,
0xD6, 0xB6, 0x12, 0x78, 0x27, 0x6A, 0xE0, 0x6A,
0x25, 0x64, 0xC0, 0x3B, 0xB0, 0xB7, 0x83, 0xFA,
0xFE, 0x78, 0x5B, 0xDF, 0x89, 0xC7, 0xD5, 0xAC,
0xD8, 0x3E, 0x78, 0x75, 0x6D, 0x30, 0x1B, 0x44,
0x56, 0x99, 0x02, 0x4E, 0xAE, 0xB7, 0x7B, 0x54,
0xD4, 0x77, 0x33, 0x6E, 0xC2, 0xA4, 0xF3, 0x32,
0xF2, 0xB3, 0xF8, 0x87, 0x65, 0xDD, 0xB0, 0xC3
},
{
0x29, 0xAC, 0xC3, 0x0E, 0x96, 0x03, 0xAE, 0x2F,
0xCC, 0xF9, 0x0B, 0xF9, 0x7E, 0x6C, 0xC4, 0x63,
0xEB, 0xE2, 0x8C, 0x1B, 0x2F, 0x9B, 0x4B, 0x76,
0x5E, 0x70, 0x53, 0x7C, 0x25, 0xC7, 0x02, 0xA2,
0x9D, 0xCB, 0xFB, 0xF1, 0x4C, 0x99, 0xC5, 0x43,
0x45, 0xBA, 0x2B, 0x51, 0xF1, 0x7B, 0x77, 0xB5,
0xF1, 0x5D, 0xB9, 0x2B, 0xBA, 0xD8, 0xFA, 0x95,
0xC4, 0x71, 0xF5, 0xD0, 0x70, 0xA1, 0x37, 0xCC
},
{
0x33, 0x79, 0xCB, 0xAA, 0xE5, 0x62, 0xA8, 0x7B,
0x4C, 0x04, 0x25, 0x55, 0x0F, 0xFD, 0xD6, 0xBF,
0xE1, 0x20, 0x3F, 0x0D, 0x66, 0x6C, 0xC7, 0xEA,
0x09, 0x5B, 0xE4, 0x07, 0xA5, 0xDF, 0xE6, 0x1E,
0xE9, 0x14, 0x41, 0xCD, 0x51, 0x54, 0xB3, 0xE5,
0x3B, 0x4F, 0x5F, 0xB3, 0x1A, 0xD4, 0xC7, 0xA9,
0xAD, 0x5C, 0x7A, 0xF4, 0xAE, 0x67, 0x9A, 0xA5,
0x1A, 0x54, 0x00, 0x3A, 0x54, 0xCA, 0x6B, 0x2D
},
{
0x30, 0x95, 0xA3, 0x49, 0xD2, 0x45, 0x70, 0x8C,
0x7C, 0xF5, 0x50, 0x11, 0x87, 0x03, 0xD7, 0x30,
0x2C, 0x27, 0xB6, 0x0A, 0xF5, 0xD4, 0xE6, 0x7F,
0xC9, 0x78, 0xF8, 0xA4, 0xE6, 0x09, 0x53, 0xC7,
0xA0, 0x4F, 0x92, 0xFC, 0xF4, 0x1A, 0xEE, 0x64,
0x32, 0x1C, 0xCB, 0x70, 0x7A, 0x89, 0x58, 0x51,
0x55, 0x2B, 0x1E, 0x37, 0xB0, 0x0B, 0xC5, 0xE6,
0xB7, 0x2F, 0xA5, 0xBC, 0xEF, 0x9E, 0x3F, 0xFF
},
{
0x07, 0x26, 0x2D, 0x73, 0x8B, 0x09, 0x32, 0x1F,
0x4D, 0xBC, 0xCE, 0xC4, 0xBB, 0x26, 0xF4, 0x8C,
0xB0, 0xF0, 0xED, 0x24, 0x6C, 0xE0, 0xB3, 0x1B,
0x9A, 0x6E, 0x7B, 0xC6, 0x83, 0x04, 0x9F, 0x1F,
0x3E, 0x55, 0x45, 0xF2, 0x8C, 0xE9, 0x32, 0xDD,
0x98, 0x5C, 0x5A, 0xB0, 0xF4, 0x3B, 0xD6, 0xDE,
0x07, 0x70, 0x56, 0x0A, 0xF3, 0x29, 0x06, 0x5E,
0xD2, 0xE4, 0x9D, 0x34, 0x62, 0x4C, 0x2C, 0xBB
},
{
0xB6, 0x40, 0x5E, 0xCA, 0x8E, 0xE3, 0x31, 0x6C,
0x87, 0x06, 0x1C, 0xC6, 0xEC, 0x18, 0xDB, 0xA5,
0x3E, 0x6C, 0x25, 0x0C, 0x63, 0xBA, 0x1F, 0x3B,
0xAE, 0x9E, 0x55, 0xDD, 0x34, 0x98, 0x03, 0x6A,
0xF0, 0x8C, 0xD2, 0x72, 0xAA, 0x24, 0xD7, 0x13,
0xC6, 0x02, 0x0D, 0x77, 0xAB, 0x2F, 0x39, 0x19,
0xAF, 0x1A, 0x32, 0xF3, 0x07, 0x42, 0x06, 0x18,
0xAB, 0x97, 0xE7, 0x39, 0x53, 0x99, 0x4F, 0xB4
},
{
0x7E, 0xE6, 0x82, 0xF6, 0x31, 0x48, 0xEE, 0x45,
0xF6, 0xE5, 0x31, 0x5D, 0xA8, 0x1E, 0x5C, 0x6E,
0x55, 0x7C, 0x2C, 0x34, 0x64, 0x1F, 0xC5, 0x09,
0xC7, 0xA5, 0x70, 0x10, 0x88, 0xC3, 0x8A, 0x74,
0x75, 0x61, 0x68, 0xE2, 0xCD, 0x8D, 0x35, 0x1E,
0x88, 0xFD, 0x1A, 0x45, 0x1F, 0x36, 0x0A, 0x01,
0xF5, 0xB2, 0x58, 0x0F, 0x9B, 0x5A, 0x2E, 0x8C,
0xFC, 0x13, 0x8F, 0x3D, 0xD5, 0x9A, 0x3F, 0xFC
},
{
0x1D, 0x26, 0x3C, 0x17, 0x9D, 0x6B, 0x26, 0x8F,
0x6F, 0xA0, 0x16, 0xF3, 0xA4, 0xF2, 0x9E, 0x94,
0x38, 0x91, 0x12, 0x5E, 0xD8, 0x59, 0x3C, 0x81,
0x25, 0x60, 0x59, 0xF5, 0xA7, 0xB4, 0x4A, 0xF2,
0xDC, 0xB2, 0x03, 0x0D, 0x17, 0x5C, 0x00, 0xE6,
0x2E, 0xCA, 0xF7, 0xEE, 0x96, 0x68, 0x2A, 0xA0,
0x7A, 0xB2, 0x0A, 0x61, 0x10, 0x24, 0xA2, 0x85,
0x32, 0xB1, 0xC2, 0x5B, 0x86, 0x65, 0x79, 0x02
},
{
0x10, 0x6D, 0x13, 0x2C, 0xBD, 0xB4, 0xCD, 0x25,
0x97, 0x81, 0x28, 0x46, 0xE2, 0xBC, 0x1B, 0xF7,
0x32, 0xFE, 0xC5, 0xF0, 0xA5, 0xF6, 0x5D, 0xBB,
0x39, 0xEC, 0x4E, 0x6D, 0xC6, 0x4A, 0xB2, 0xCE,
0x6D, 0x24, 0x63, 0x0D, 0x0F, 0x15, 0xA8, 0x05,
0xC3, 0x54, 0x00, 0x25, 0xD8, 0x4A, 0xFA, 0x98,
0xE3, 0x67, 0x03, 0xC3, 0xDB, 0xEE, 0x71, 0x3E,
0x72, 0xDD, 0xE8, 0x46, 0x5B, 0xC1, 0xBE, 0x7E
},
{
0x0E, 0x79, 0x96, 0x82, 0x26, 0x65, 0x06, 0x67,
0xA8, 0xD8, 0x62, 0xEA, 0x8D, 0xA4, 0x89, 0x1A,
0xF5, 0x6A, 0x4E, 0x3A, 0x8B, 0x6D, 0x17, 0x50,
0xE3, 0x94, 0xF0, 0xDE, 0xA7, 0x6D, 0x64, 0x0D,
0x85, 0x07, 0x7B, 0xCE, 0xC2, 0xCC, 0x86, 0x88,
0x6E, 0x50, 0x67, 0x51, 0xB4, 0xF6, 0xA5, 0x83,
0x8F, 0x7F, 0x0B, 0x5F, 0xEF, 0x76, 0x5D, 0x9D,
0xC9, 0x0D, 0xCD, 0xCB, 0xAF, 0x07, 0x9F, 0x08
},
{
0x52, 0x11, 0x56, 0xA8, 0x2A, 0xB0, 0xC4, 0xE5,
0x66, 0xE5, 0x84, 0x4D, 0x5E, 0x31, 0xAD, 0x9A,
0xAF, 0x14, 0x4B, 0xBD, 0x5A, 0x46, 0x4F, 0xDC,
0xA3, 0x4D, 0xBD, 0x57, 0x17, 0xE8, 0xFF, 0x71,
0x1D, 0x3F, 0xFE, 0xBB, 0xFA, 0x08, 0x5D, 0x67,
0xFE, 0x99, 0x6A, 0x34, 0xF6, 0xD3, 0xE4, 0xE6,
0x0B, 0x13, 0x96, 0xBF, 0x4B, 0x16, 0x10, 0xC2,
0x63, 0xBD, 0xBB, 0x83, 0x4D, 0x56, 0x08, 0x16
},
{
0x1A, 0xBA, 0x88, 0xBE, 0xFC, 0x55, 0xBC, 0x25,
0xEF, 0xBC, 0xE0, 0x2D, 0xB8, 0xB9, 0x93, 0x3E,
0x46, 0xF5, 0x76, 0x61, 0xBA, 0xEA, 0xBE, 0xB2,
0x1C, 0xC2, 0x57, 0x4D, 0x2A, 0x51, 0x8A, 0x3C,
0xBA, 0x5D, 0xC5, 0xA3, 0x8E, 0x49, 0x71, 0x34,
0x40, 0xB2, 0x5F, 0x9C, 0x74, 0x4E, 0x75, 0xF6,
0xB8, 0x5C, 0x9D, 0x8F, 0x46, 0x81, 0xF6, 0x76,
0x16, 0x0F, 0x61, 0x05, 0x35, 0x7B, 0x84, 0x06
},
{
0x5A, 0x99, 0x49, 0xFC, 0xB2, 0xC4, 0x73, 0xCD,
0xA9, 0x68, 0xAC, 0x1B, 0x5D, 0x08, 0x56, 0x6D,
0xC2, 0xD8, 0x16, 0xD9, 0x60, 0xF5, 0x7E, 0x63,
0xB8, 0x98, 0xFA, 0x70, 0x1C, 0xF8, 0xEB, 0xD3,
0xF5, 0x9B, 0x12, 0x4D, 0x95, 0xBF, 0xBB, 0xED,
0xC5, 0xF1, 0xCF, 0x0E, 0x17, 0xD5, 0xEA, 0xED,
0x0C, 0x02, 0xC5, 0x0B, 0x69, 0xD8, 0xA4, 0x02,
0xCA, 0xBC, 0xCA, 0x44, 0x33, 0xB5, 0x1F, 0xD4
},
{
0xB0, 0xCE, 0xAD, 0x09, 0x80, 0x7C, 0x67, 0x2A,
0xF2, 0xEB, 0x2B, 0x0F, 0x06, 0xDD, 0xE4, 0x6C,
0xF5, 0x37, 0x0E, 0x15, 0xA4, 0x09, 0x6B, 0x1A,
0x7D, 0x7C, 0xBB, 0x36, 0xEC, 0x31, 0xC2, 0x05,
0xFB, 0xEF, 0xCA, 0x00, 0xB7, 0xA4, 0x16, 0x2F,
0xA8, 0x9F, 0xB4, 0xFB, 0x3E, 0xB7, 0x8D, 0x79,
0x77, 0x0C, 0x23, 0xF4, 0x4E, 0x72, 0x06, 0x66,
0x4C, 0xE3, 0xCD, 0x93, 0x1C, 0x29, 0x1E, 0x5D
},
{
0xBB, 0x66, 0x64, 0x93, 0x1E, 0xC9, 0x70, 0x44,
0xE4, 0x5B, 0x2A, 0xE4, 0x20, 0xAE, 0x1C, 0x55,
0x1A, 0x88, 0x74, 0xBC, 0x93, 0x7D, 0x08, 0xE9,
0x69, 0x39, 0x9C, 0x39, 0x64, 0xEB, 0xDB, 0xA8,
0x34, 0x6C, 0xDD, 0x5D, 0x09, 0xCA, 0xAF, 0xE4,
0xC2, 0x8B, 0xA7, 0xEC, 0x78, 0x81, 0x91, 0xCE,
0xCA, 0x65, 0xDD, 0xD6, 0xF9, 0x5F, 0x18, 0x58,
0x3E, 0x04, 0x0D, 0x0F, 0x30, 0xD0, 0x36, 0x4D
},
{
0x65, 0xBC, 0x77, 0x0A, 0x5F, 0xAA, 0x37, 0x92,
0x36, 0x98, 0x03, 0x68, 0x3E, 0x84, 0x4B, 0x0B,
0xE7, 0xEE, 0x96, 0xF2, 0x9F, 0x6D, 0x6A, 0x35,
0x56, 0x80, 0x06, 0xBD, 0x55, 0x90, 0xF9, 0xA4,
0xEF, 0x63, 0x9B, 0x7A, 0x80, 0x61, 0xC7, 0xB0,
0x42, 0x4B, 0x66, 0xB6, 0x0A, 0xC3, 0x4A, 0xF3,
0x11, 0x99, 0x05, 0xF3, 0x3A, 0x9D, 0x8C, 0x3A,
0xE1, 0x83, 0x82, 0xCA, 0x9B, 0x68, 0x99, 0x00
},
{
0xEA, 0x9B, 0x4D, 0xCA, 0x33, 0x33, 0x36, 0xAA,
0xF8, 0x39, 0xA4, 0x5C, 0x6E, 0xAA, 0x48, 0xB8,
0xCB, 0x4C, 0x7D, 0xDA, 0xBF, 0xFE, 0xA4, 0xF6,
0x43, 0xD6, 0x35, 0x7E, 0xA6, 0x62, 0x8A, 0x48,
0x0A, 0x5B, 0x45, 0xF2, 0xB0, 0x52, 0xC1, 0xB0,
0x7D, 0x1F, 0xED, 0xCA, 0x91, 0x8B, 0x6F, 0x11,
0x39, 0xD8, 0x0F, 0x74, 0xC2, 0x45, 0x10, 0xDC,
0xBA, 0xA4, 0xBE, 0x70, 0xEA, 0xCC, 0x1B, 0x06
},
{
0xE6, 0x34, 0x2F, 0xB4, 0xA7, 0x80, 0xAD, 0x97,
0x5D, 0x0E, 0x24, 0xBC, 0xE1, 0x49, 0x98, 0x9B,
0x91, 0xD3, 0x60, 0x55, 0x7E, 0x87, 0x99, 0x4F,
0x6B, 0x45, 0x7B, 0x89, 0x55, 0x75, 0xCC, 0x02,
0xD0, 0xC1, 0x5B, 0xAD, 0x3C, 0xE7, 0x57, 0x7F,
0x4C, 0x63, 0x92, 0x7F, 0xF1, 0x3F, 0x3E, 0x38,
0x1F, 0xF7, 0xE7, 0x2B, 0xDB, 0xE7, 0x45, 0x32,
0x48, 0x44, 0xA9, 0xD2, 0x7E, 0x3F, 0x1C, 0x01
},
{
0x3E, 0x20, 0x9C, 0x9B, 0x33, 0xE8, 0xE4, 0x61,
0x17, 0x8A, 0xB4, 0x6B, 0x1C, 0x64, 0xB4, 0x9A,
0x07, 0xFB, 0x74, 0x5F, 0x1C, 0x8B, 0xC9, 0x5F,
0xBF, 0xB9, 0x4C, 0x6B, 0x87, 0xC6, 0x95, 0x16,
0x65, 0x1B, 0x26, 0x4E, 0xF9, 0x80, 0x93, 0x7F,
0xAD, 0x41, 0x23, 0x8B, 0x91, 0xDD, 0xC0, 0x11,
0xA5, 0xDD, 0x77, 0x7C, 0x7E, 0xFD, 0x44, 0x94,
0xB4, 0xB6, 0xEC, 0xD3, 0xA9, 0xC2, 0x2A, 0xC0
},
{
0xFD, 0x6A, 0x3D, 0x5B, 0x18, 0x75, 0xD8, 0x04,
0x86, 0xD6, 0xE6, 0x96, 0x94, 0xA5, 0x6D, 0xBB,
0x04, 0xA9, 0x9A, 0x4D, 0x05, 0x1F, 0x15, 0xDB,
0x26, 0x89, 0x77, 0x6B, 0xA1, 0xC4, 0x88, 0x2E,
0x6D, 0x46, 0x2A, 0x60, 0x3B, 0x70, 0x15, 0xDC,
0x9F, 0x4B, 0x74, 0x50, 0xF0, 0x53, 0x94, 0x30,
0x3B, 0x86, 0x52, 0xCF, 0xB4, 0x04, 0xA2, 0x66,
0x96, 0x2C, 0x41, 0xBA, 0xE6, 0xE1, 0x8A, 0x94
},
{
0x95, 0x1E, 0x27, 0x51, 0x7E, 0x6B, 0xAD, 0x9E,
0x41, 0x95, 0xFC, 0x86, 0x71, 0xDE, 0xE3, 0xE7,
0xE9, 0xBE, 0x69, 0xCE, 0xE1, 0x42, 0x2C, 0xB9,
0xFE, 0xCF, 0xCE, 0x0D, 0xBA, 0x87, 0x5F, 0x7B,
0x31, 0x0B, 0x93, 0xEE, 0x3A, 0x3D, 0x55, 0x8F,
0x94, 0x1F, 0x63, 0x5F, 0x66, 0x8F, 0xF8, 0x32,
0xD2, 0xC1, 0xD0, 0x33, 0xC5, 0xE2, 0xF0, 0x99,
0x7E, 0x4C, 0x66, 0xF1, 0x47, 0x34, 0x4E, 0x02
},
{
0x8E, 0xBA, 0x2F, 0x87, 0x4F, 0x1A, 0xE8, 0x40,
0x41, 0x90, 0x3C, 0x7C, 0x42, 0x53, 0xC8, 0x22,
0x92, 0x53, 0x0F, 0xC8, 0x50, 0x95, 0x50, 0xBF,
0xDC, 0x34, 0xC9, 0x5C, 0x7E, 0x28, 0x89, 0xD5,
0x65, 0x0B, 0x0A, 0xD8, 0xCB, 0x98, 0x8E, 0x5C,
0x48, 0x94, 0xCB, 0x87, 0xFB, 0xFB, 0xB1, 0x96,
0x12, 0xEA, 0x93, 0xCC, 0xC4, 0xC5, 0xCA, 0xD1,
0x71, 0x58, 0xB9, 0x76, 0x34, 0x64, 0xB4, 0x92
},
{
0x16, 0xF7, 0x12, 0xEA, 0xA1, 0xB7, 0xC6, 0x35,
0x47, 0x19, 0xA8, 0xE7, 0xDB, 0xDF, 0xAF, 0x55,
0xE4, 0x06, 0x3A, 0x4D, 0x27, 0x7D, 0x94, 0x75,
0x50, 0x01, 0x9B, 0x38, 0xDF, 0xB5, 0x64, 0x83,
0x09, 0x11, 0x05, 0x7D, 0x50, 0x50, 0x61, 0x36,
0xE2, 0x39, 0x4C, 0x3B, 0x28, 0x94, 0x5C, 0xC9,
0x64, 0x96, 0x7D, 0x54, 0xE3, 0x00, 0x0C, 0x21,
0x81, 0x62, 0x6C, 0xFB, 0x9B, 0x73, 0xEF, 0xD2
},
{
0xC3, 0x96, 0x39, 0xE7, 0xD5, 0xC7, 0xFB, 0x8C,
0xDD, 0x0F, 0xD3, 0xE6, 0xA5, 0x20, 0x96, 0x03,
0x94, 0x37, 0x12, 0x2F, 0x21, 0xC7, 0x8F, 0x16,
0x79, 0xCE, 0xA9, 0xD7, 0x8A, 0x73, 0x4C, 0x56,
0xEC, 0xBE, 0xB2, 0x86, 0x54, 0xB4, 0xF1, 0x8E,
0x34, 0x2C, 0x33, 0x1F, 0x6F, 0x72, 0x29, 0xEC,
0x4B, 0x4B, 0xC2, 0x81, 0xB2, 0xD8, 0x0A, 0x6E,
0xB5, 0x00, 0x43, 0xF3, 0x17, 0x96, 0xC8, 0x8C
},
{
0x72, 0xD0, 0x81, 0xAF, 0x99, 0xF8, 0xA1, 0x73,
0xDC, 0xC9, 0xA0, 0xAC, 0x4E, 0xB3, 0x55, 0x74,
0x05, 0x63, 0x9A, 0x29, 0x08, 0x4B, 0x54, 0xA4,
0x01, 0x72, 0x91, 0x2A, 0x2F, 0x8A, 0x39, 0x51,
0x29, 0xD5, 0x53, 0x6F, 0x09, 0x18, 0xE9, 0x02,
0xF9, 0xE8, 0xFA, 0x60, 0x00, 0x99, 0x5F, 0x41,
0x68, 0xDD, 0xC5, 0xF8, 0x93, 0x01, 0x1B, 0xE6,
0xA0, 0xDB, 0xC9, 0xB8, 0xA1, 0xA3, 0xF5, 0xBB
},
{
0xC1, 0x1A, 0xA8, 0x1E, 0x5E, 0xFD, 0x24, 0xD5,
0xFC, 0x27, 0xEE, 0x58, 0x6C, 0xFD, 0x88, 0x47,
0xFB, 0xB0, 0xE2, 0x76, 0x01, 0xCC, 0xEC, 0xE5,
0xEC, 0xCA, 0x01, 0x98, 0xE3, 0xC7, 0x76, 0x53,
0x93, 0xBB, 0x74, 0x45, 0x7C, 0x7E, 0x7A, 0x27,
0xEB, 0x91, 0x70, 0x35, 0x0E, 0x1F, 0xB5, 0x38,
0x57, 0x17, 0x75, 0x06, 0xBE, 0x3E, 0x76, 0x2C,
0xC0, 0xF1, 0x4D, 0x8C, 0x3A, 0xFE, 0x90, 0x77
},
{
0xC2, 0x8F, 0x21, 0x50, 0xB4, 0x52, 0xE6, 0xC0,
0xC4, 0x24, 0xBC, 0xDE, 0x6F, 0x8D, 0x72, 0x00,
0x7F, 0x93, 0x10, 0xFE, 0xD7, 0xF2, 0xF8, 0x7D,
0xE0, 0xDB, 0xB6, 0x4F, 0x44, 0x79, 0xD6, 0xC1,
0x44, 0x1B, 0xA6, 0x6F, 0x44, 0xB2, 0xAC, 0xCE,
0xE6, 0x16, 0x09, 0x17, 0x7E, 0xD3, 0x40, 0x12,
0x8B, 0x40, 0x7E, 0xCE, 0xC7, 0xC6, 0x4B, 0xBE,
0x50, 0xD6, 0x3D, 0x22, 0xD8, 0x62, 0x77, 0x27
},
{
0xF6, 0x3D, 0x88, 0x12, 0x28, 0x77, 0xEC, 0x30,
0xB8, 0xC8, 0xB0, 0x0D, 0x22, 0xE8, 0x90, 0x00,
0xA9, 0x66, 0x42, 0x61, 0x12, 0xBD, 0x44, 0x16,
0x6E, 0x2F, 0x52, 0x5B, 0x76, 0x9C, 0xCB, 0xE9,
0xB2, 0x86, 0xD4, 0x37, 0xA0, 0x12, 0x91, 0x30,
0xDD, 0xE1, 0xA8, 0x6C, 0x43, 0xE0, 0x4B, 0xED,
0xB5, 0x94, 0xE6, 0x71, 0xD9, 0x82, 0x83, 0xAF,
0xE6, 0x4C, 0xE3, 0x31, 0xDE, 0x98, 0x28, 0xFD
},
{
0x34, 0x8B, 0x05, 0x32, 0x88, 0x0B, 0x88, 0xA6,
0x61, 0x4A, 0x8D, 0x74, 0x08, 0xC3, 0xF9, 0x13,
0x35, 0x7F, 0xBB, 0x60, 0xE9, 0x95, 0xC6, 0x02,
0x05, 0xBE, 0x91, 0x39, 0xE7, 0x49, 0x98, 0xAE,
0xDE, 0x7F, 0x45, 0x81, 0xE4, 0x2F, 0x6B, 0x52,
0x69, 0x8F, 0x7F, 0xA1, 0x21, 0x97, 0x08, 0xC1,
0x44, 0x98, 0x06, 0x7F, 0xD1, 0xE0, 0x95, 0x02,
0xDE, 0x83, 0xA7, 0x7D, 0xD2, 0x81, 0x15, 0x0C
},
{
0x51, 0x33, 0xDC, 0x8B, 0xEF, 0x72, 0x53, 0x59,
0xDF, 0xF5, 0x97, 0x92, 0xD8, 0x5E, 0xAF, 0x75,
0xB7, 0xE1, 0xDC, 0xD1, 0x97, 0x8B, 0x01, 0xC3,
0x5B, 0x1B, 0x85, 0xFC, 0xEB, 0xC6, 0x33, 0x88,
0xAD, 0x99, 0xA1, 0x7B, 0x63, 0x46, 0xA2, 0x17,
0xDC, 0x1A, 0x96, 0x22, 0xEB, 0xD1, 0x22, 0xEC,
0xF6, 0x91, 0x3C, 0x4D, 0x31, 0xA6, 0xB5, 0x2A,
0x69, 0x5B, 0x86, 0xAF, 0x00, 0xD7, 0x41, 0xA0
},
{
0x27, 0x53, 0xC4, 0xC0, 0xE9, 0x8E, 0xCA, 0xD8,
0x06, 0xE8, 0x87, 0x80, 0xEC, 0x27, 0xFC, 0xCD,
0x0F, 0x5C, 0x1A, 0xB5, 0x47, 0xF9, 0xE4, 0xBF,
0x16, 0x59, 0xD1, 0x92, 0xC2, 0x3A, 0xA2, 0xCC,
0x97, 0x1B, 0x58, 0xB6, 0x80, 0x25, 0x80, 0xBA,
0xEF, 0x8A, 0xDC, 0x3B, 0x77, 0x6E, 0xF7, 0x08,
0x6B, 0x25, 0x45, 0xC2, 0x98, 0x7F, 0x34, 0x8E,
0xE3, 0x71, 0x9C, 0xDE, 0xF2, 0x58, 0xC4, 0x03
},
{
0xB1, 0x66, 0x35, 0x73, 0xCE, 0x4B, 0x9D, 0x8C,
0xAE, 0xFC, 0x86, 0x50, 0x12, 0xF3, 0xE3, 0x97,
0x14, 0xB9, 0x89, 0x8A, 0x5D, 0xA6, 0xCE, 0x17,
0xC2, 0x5A, 0x6A, 0x47, 0x93, 0x1A, 0x9D, 0xDB,
0x9B, 0xBE, 0x98, 0xAD, 0xAA, 0x55, 0x3B, 0xEE,
0xD4, 0x36, 0xE8, 0x95, 0x78, 0x45, 0x54, 0x16,
0xC2, 0xA5, 0x2A, 0x52, 0x5C, 0xF2, 0x86, 0x2B,
0x8D, 0x1D, 0x49, 0xA2, 0x53, 0x1B, 0x73, 0x91
},
{
0x64, 0xF5, 0x8B, 0xD6, 0xBF, 0xC8, 0x56, 0xF5,
0xE8, 0x73, 0xB2, 0xA2, 0x95, 0x6E, 0xA0, 0xED,
0xA0, 0xD6, 0xDB, 0x0D, 0xA3, 0x9C, 0x8C, 0x7F,
0xC6, 0x7C, 0x9F, 0x9F, 0xEE, 0xFC, 0xFF, 0x30,
0x72, 0xCD, 0xF9, 0xE6, 0xEA, 0x37, 0xF6, 0x9A,
0x44, 0xF0, 0xC6, 0x1A, 0xA0, 0xDA, 0x36, 0x93,
0xC2, 0xDB, 0x5B, 0x54, 0x96, 0x0C, 0x02, 0x81,
0xA0, 0x88, 0x15, 0x1D, 0xB4, 0x2B, 0x11, 0xE8
},
{
0x07, 0x64, 0xC7, 0xBE, 0x28, 0x12, 0x5D, 0x90,
0x65, 0xC4, 0xB9, 0x8A, 0x69, 0xD6, 0x0A, 0xED,
0xE7, 0x03, 0x54, 0x7C, 0x66, 0xA1, 0x2E, 0x17,
0xE1, 0xC6, 0x18, 0x99, 0x41, 0x32, 0xF5, 0xEF,
0x82, 0x48, 0x2C, 0x1E, 0x3F, 0xE3, 0x14, 0x6C,
0xC6, 0x53, 0x76, 0xCC, 0x10, 0x9F, 0x01, 0x38,
0xED, 0x9A, 0x80, 0xE4, 0x9F, 0x1F, 0x3C, 0x7D,
0x61, 0x0D, 0x2F, 0x24, 0x32, 0xF2, 0x06, 0x05
},
{
0xF7, 0x48, 0x78, 0x43, 0x98, 0xA2, 0xFF, 0x03,
0xEB, 0xEB, 0x07, 0xE1, 0x55, 0xE6, 0x61, 0x16,
0xA8, 0x39, 0x74, 0x1A, 0x33, 0x6E, 0x32, 0xDA,
0x71, 0xEC, 0x69, 0x60, 0x01, 0xF0, 0xAD, 0x1B,
0x25, 0xCD, 0x48, 0xC6, 0x9C, 0xFC, 0xA7, 0x26,
0x5E, 0xCA, 0x1D, 0xD7, 0x19, 0x04, 0xA0, 0xCE,
0x74, 0x8A, 0xC4, 0x12, 0x4F, 0x35, 0x71, 0x07,
0x6D, 0xFA, 0x71, 0x16, 0xA9, 0xCF, 0x00, 0xE9
},
{
0x3F, 0x0D, 0xBC, 0x01, 0x86, 0xBC, 0xEB, 0x6B,
0x78, 0x5B, 0xA7, 0x8D, 0x2A, 0x2A, 0x01, 0x3C,
0x91, 0x0B, 0xE1, 0x57, 0xBD, 0xAF, 0xFA, 0xE8,
0x1B, 0xB6, 0x66, 0x3B, 0x1A, 0x73, 0x72, 0x2F,
0x7F, 0x12, 0x28, 0x79, 0x5F, 0x3E, 0xCA, 0xDA,
0x87, 0xCF, 0x6E, 0xF0, 0x07, 0x84, 0x74, 0xAF,
0x73, 0xF3, 0x1E, 0xCA, 0x0C, 0xC2, 0x00, 0xED,
0x97, 0x5B, 0x68, 0x93, 0xF7, 0x61, 0xCB, 0x6D
},
{
0xD4, 0x76, 0x2C, 0xD4, 0x59, 0x98, 0x76, 0xCA,
0x75, 0xB2, 0xB8, 0xFE, 0x24, 0x99, 0x44, 0xDB,
0xD2, 0x7A, 0xCE, 0x74, 0x1F, 0xDA, 0xB9, 0x36,
0x16, 0xCB, 0xC6, 0xE4, 0x25, 0x46, 0x0F, 0xEB,
0x51, 0xD4, 0xE7, 0xAD, 0xCC, 0x38, 0x18, 0x0E,
0x7F, 0xC4, 0x7C, 0x89, 0x02, 0x4A, 0x7F, 0x56,
0x19, 0x1A, 0xDB, 0x87, 0x8D, 0xFD, 0xE4, 0xEA,
0xD6, 0x22, 0x23, 0xF5, 0xA2, 0x61, 0x0E, 0xFE
},
{
0xCD, 0x36, 0xB3, 0xD5, 0xB4, 0xC9, 0x1B, 0x90,
0xFC, 0xBB, 0xA7, 0x95, 0x13, 0xCF, 0xEE, 0x19,
0x07, 0xD8, 0x64, 0x5A, 0x16, 0x2A, 0xFD, 0x0C,
0xD4, 0xCF, 0x41, 0x92, 0xD4, 0xA5, 0xF4, 0xC8,
0x92, 0x18, 0x3A, 0x8E, 0xAC, 0xDB, 0x2B, 0x6B,
0x6A, 0x9D, 0x9A, 0xA8, 0xC1, 0x1A, 0xC1, 0xB2,
0x61, 0xB3, 0x80, 0xDB, 0xEE, 0x24, 0xCA, 0x46,
0x8F, 0x1B, 0xFD, 0x04, 0x3C, 0x58, 0xEE, 0xFE
},
{
0x98, 0x59, 0x34, 0x52, 0x28, 0x16, 0x61, 0xA5,
0x3C, 0x48, 0xA9, 0xD8, 0xCD, 0x79, 0x08, 0x26,
0xC1, 0xA1, 0xCE, 0x56, 0x77, 0x38, 0x05, 0x3D,
0x0B, 0xEE, 0x4A, 0x91, 0xA3, 0xD5, 0xBD, 0x92,
0xEE, 0xFD, 0xBA, 0xBE, 0xBE, 0x32, 0x04, 0xF2,
0x03, 0x1C, 0xA5, 0xF7, 0x81, 0xBD, 0xA9, 0x9E,
0xF5, 0xD8, 0xAE, 0x56, 0xE5, 0xB0, 0x4A, 0x9E,
0x1E, 0xCD, 0x21, 0xB0, 0xEB, 0x05, 0xD3, 0xE1
},
{
0x77, 0x1F, 0x57, 0xDD, 0x27, 0x75, 0xCC, 0xDA,
0xB5, 0x59, 0x21, 0xD3, 0xE8, 0xE3, 0x0C, 0xCF,
0x48, 0x4D, 0x61, 0xFE, 0x1C, 0x1B, 0x9C, 0x2A,
0xE8, 0x19, 0xD0, 0xFB, 0x2A, 0x12, 0xFA, 0xB9,
0xBE, 0x70, 0xC4, 0xA7, 0xA1, 0x38, 0xDA, 0x84,
0xE8, 0x28, 0x04, 0x35, 0xDA, 0xAD, 0xE5, 0xBB,
0xE6, 0x6A, 0xF0, 0x83, 0x6A, 0x15, 0x4F, 0x81,
0x7F, 0xB1, 0x7F, 0x33, 0x97, 0xE7, 0x25, 0xA3
},
{
0xC6, 0x08, 0x97, 0xC6, 0xF8, 0x28, 0xE2, 0x1F,
0x16, 0xFB, 0xB5, 0xF1, 0x5B, 0x32, 0x3F, 0x87,
0xB6, 0xC8, 0x95, 0x5E, 0xAB, 0xF1, 0xD3, 0x80,
0x61, 0xF7, 0x07, 0xF6, 0x08, 0xAB, 0xDD, 0x99,
0x3F, 0xAC, 0x30, 0x70, 0x63, 0x3E, 0x28, 0x6C,
0xF8, 0x33, 0x9C, 0xE2, 0x95, 0xDD, 0x35, 0x2D,
0xF4, 0xB4, 0xB4, 0x0B, 0x2F, 0x29, 0xDA, 0x1D,
0xD5, 0x0B, 0x3A, 0x05, 0xD0, 0x79, 0xE6, 0xBB
},
{
0x82, 0x10, 0xCD, 0x2C, 0x2D, 0x3B, 0x13, 0x5C,
0x2C, 0xF0, 0x7F, 0xA0, 0xD1, 0x43, 0x3C, 0xD7,
0x71, 0xF3, 0x25, 0xD0, 0x75, 0xC6, 0x46, 0x9D,
0x9C, 0x7F, 0x1B, 0xA0, 0x94, 0x3C, 0xD4, 0xAB,
0x09, 0x80, 0x8C, 0xAB, 0xF4, 0xAC, 0xB9, 0xCE,
0x5B, 0xB8, 0x8B, 0x49, 0x89, 0x29, 0xB4, 0xB8,
0x47, 0xF6, 0x81, 0xAD, 0x2C, 0x49, 0x0D, 0x04,
0x2D, 0xB2, 0xAE, 0xC9, 0x42, 0x14, 0xB0, 0x6B
},
{
0x1D, 0x4E, 0xDF, 0xFF, 0xD8, 0xFD, 0x80, 0xF7,
0xE4, 0x10, 0x78, 0x40, 0xFA, 0x3A, 0xA3, 0x1E,
0x32, 0x59, 0x84, 0x91, 0xE4, 0xAF, 0x70, 0x13,
0xC1, 0x97, 0xA6, 0x5B, 0x7F, 0x36, 0xDD, 0x3A,
0xC4, 0xB4, 0x78, 0x45, 0x61, 0x11, 0xCD, 0x43,
0x09, 0xD9, 0x24, 0x35, 0x10, 0x78, 0x2F, 0xA3,
0x1B, 0x7C, 0x4C, 0x95, 0xFA, 0x95, 0x15, 0x20,
0xD0, 0x20, 0xEB, 0x7E, 0x5C, 0x36, 0xE4, 0xEF
},
{
0xAF, 0x8E, 0x6E, 0x91, 0xFA, 0xB4, 0x6C, 0xE4,
0x87, 0x3E, 0x1A, 0x50, 0xA8, 0xEF, 0x44, 0x8C,
0xC2, 0x91, 0x21, 0xF7, 0xF7, 0x4D, 0xEE, 0xF3,
0x4A, 0x71, 0xEF, 0x89, 0xCC, 0x00, 0xD9, 0x27,
0x4B, 0xC6, 0xC2, 0x45, 0x4B, 0xBB, 0x32, 0x30,
0xD8, 0xB2, 0xEC, 0x94, 0xC6, 0x2B, 0x1D, 0xEC,
0x85, 0xF3, 0x59, 0x3B, 0xFA, 0x30, 0xEA, 0x6F,
0x7A, 0x44, 0xD7, 0xC0, 0x94, 0x65, 0xA2, 0x53
},
{
0x29, 0xFD, 0x38, 0x4E, 0xD4, 0x90, 0x6F, 0x2D,
0x13, 0xAA, 0x9F, 0xE7, 0xAF, 0x90, 0x59, 0x90,
0x93, 0x8B, 0xED, 0x80, 0x7F, 0x18, 0x32, 0x45,
0x4A, 0x37, 0x2A, 0xB4, 0x12, 0xEE, 0xA1, 0xF5,
0x62, 0x5A, 0x1F, 0xCC, 0x9A, 0xC8, 0x34, 0x3B,
0x7C, 0x67, 0xC5, 0xAB, 0xA6, 0xE0, 0xB1, 0xCC,
0x46, 0x44, 0x65, 0x49, 0x13, 0x69, 0x2C, 0x6B,
0x39, 0xEB, 0x91, 0x87, 0xCE, 0xAC, 0xD3, 0xEC
},
{
0xA2, 0x68, 0xC7, 0x88, 0x5D, 0x98, 0x74, 0xA5,
0x1C, 0x44, 0xDF, 0xFE, 0xD8, 0xEA, 0x53, 0xE9,
0x4F, 0x78, 0x45, 0x6E, 0x0B, 0x2E, 0xD9, 0x9F,
0xF5, 0xA3, 0x92, 0x47, 0x60, 0x81, 0x38, 0x26,
0xD9, 0x60, 0xA1, 0x5E, 0xDB, 0xED, 0xBB, 0x5D,
0xE5, 0x22, 0x6B, 0xA4, 0xB0, 0x74, 0xE7, 0x1B,
0x05, 0xC5, 0x5B, 0x97, 0x56, 0xBB, 0x79, 0xE5,
0x5C, 0x02, 0x75, 0x4C, 0x2C, 0x7B, 0x6C, 0x8A
},
{
0x0C, 0xF8, 0x54, 0x54, 0x88, 0xD5, 0x6A, 0x86,
0x81, 0x7C, 0xD7, 0xEC, 0xB1, 0x0F, 0x71, 0x16,
0xB7, 0xEA, 0x53, 0x0A, 0x45, 0xB6, 0xEA, 0x49,
0x7B, 0x6C, 0x72, 0xC9, 0x97, 0xE0, 0x9E, 0x3D,
0x0D, 0xA8, 0x69, 0x8F, 0x46, 0xBB, 0x00, 0x6F,
0xC9, 0x77, 0xC2, 0xCD, 0x3D, 0x11, 0x77, 0x46,
0x3A, 0xC9, 0x05, 0x7F, 0xDD, 0x16, 0x62, 0xC8,
0x5D, 0x0C, 0x12, 0x64, 0x43, 0xC1, 0x04, 0x73
},
{
0xB3, 0x96, 0x14, 0x26, 0x8F, 0xDD, 0x87, 0x81,
0x51, 0x5E, 0x2C, 0xFE, 0xBF, 0x89, 0xB4, 0xD5,
0x40, 0x2B, 0xAB, 0x10, 0xC2, 0x26, 0xE6, 0x34,
0x4E, 0x6B, 0x9A, 0xE0, 0x00, 0xFB, 0x0D, 0x6C,
0x79, 0xCB, 0x2F, 0x3E, 0xC8, 0x0E, 0x80, 0xEA,
0xEB, 0x19, 0x80, 0xD2, 0xF8, 0x69, 0x89, 0x16,
0xBD, 0x2E, 0x9F, 0x74, 0x72, 0x36, 0x65, 0x51,
0x16, 0x64, 0x9C, 0xD3, 0xCA, 0x23, 0xA8, 0x37
},
{
0x74, 0xBE, 0xF0, 0x92, 0xFC, 0x6F, 0x1E, 0x5D,
0xBA, 0x36, 0x63, 0xA3, 0xFB, 0x00, 0x3B, 0x2A,
0x5B, 0xA2, 0x57, 0x49, 0x65, 0x36, 0xD9, 0x9F,
0x62, 0xB9, 0xD7, 0x3F, 0x8F, 0x9E, 0xB3, 0xCE,
0x9F, 0xF3, 0xEE, 0xC7, 0x09, 0xEB, 0x88, 0x36,
0x55, 0xEC, 0x9E, 0xB8, 0x96, 0xB9, 0x12, 0x8F,
0x2A, 0xFC, 0x89, 0xCF, 0x7D, 0x1A, 0xB5, 0x8A,
0x72, 0xF4, 0xA3, 0xBF, 0x03, 0x4D, 0x2B, 0x4A
},
{
0x3A, 0x98, 0x8D, 0x38, 0xD7, 0x56, 0x11, 0xF3,
0xEF, 0x38, 0xB8, 0x77, 0x49, 0x80, 0xB3, 0x3E,
0x57, 0x3B, 0x6C, 0x57, 0xBE, 0xE0, 0x46, 0x9B,
0xA5, 0xEE, 0xD9, 0xB4, 0x4F, 0x29, 0x94, 0x5E,
0x73, 0x47, 0x96, 0x7F, 0xBA, 0x2C, 0x16, 0x2E,
0x1C, 0x3B, 0xE7, 0xF3, 0x10, 0xF2, 0xF7, 0x5E,
0xE2, 0x38, 0x1E, 0x7B, 0xFD, 0x6B, 0x3F, 0x0B,
0xAE, 0xA8, 0xD9, 0x5D, 0xFB, 0x1D, 0xAF, 0xB1
},
{
0x58, 0xAE, 0xDF, 0xCE, 0x6F, 0x67, 0xDD, 0xC8,
0x5A, 0x28, 0xC9, 0x92, 0xF1, 0xC0, 0xBD, 0x09,
0x69, 0xF0, 0x41, 0xE6, 0x6F, 0x1E, 0xE8, 0x80,
0x20, 0xA1, 0x25, 0xCB, 0xFC, 0xFE, 0xBC, 0xD6,
0x17, 0x09, 0xC9, 0xC4, 0xEB, 0xA1, 0x92, 0xC1,
0x5E, 0x69, 0xF0, 0x20, 0xD4, 0x62, 0x48, 0x60,
0x19, 0xFA, 0x8D, 0xEA, 0x0C, 0xD7, 0xA4, 0x29,
0x21, 0xA1, 0x9D, 0x2F, 0xE5, 0x46, 0xD4, 0x3D
},
{
0x93, 0x47, 0xBD, 0x29, 0x14, 0x73, 0xE6, 0xB4,
0xE3, 0x68, 0x43, 0x7B, 0x8E, 0x56, 0x1E, 0x06,
0x5F, 0x64, 0x9A, 0x6D, 0x8A, 0xDA, 0x47, 0x9A,
0xD0, 0x9B, 0x19, 0x99, 0xA8, 0xF2, 0x6B, 0x91,
0xCF, 0x61, 0x20, 0xFD, 0x3B, 0xFE, 0x01, 0x4E,
0x83, 0xF2, 0x3A, 0xCF, 0xA4, 0xC0, 0xAD, 0x7B,
0x37, 0x12, 0xB2, 0xC3, 0xC0, 0x73, 0x32, 0x70,
0x66, 0x31, 0x12, 0xCC, 0xD9, 0x28, 0x5C, 0xD9
},
{
0xB3, 0x21, 0x63, 0xE7, 0xC5, 0xDB, 0xB5, 0xF5,
0x1F, 0xDC, 0x11, 0xD2, 0xEA, 0xC8, 0x75, 0xEF,
0xBB, 0xCB, 0x7E, 0x76, 0x99, 0x09, 0x0A, 0x7E,
0x7F, 0xF8, 0xA8, 0xD5, 0x07, 0x95, 0xAF, 0x5D,
0x74, 0xD9, 0xFF, 0x98, 0x54, 0x3E, 0xF8, 0xCD,
0xF8, 0x9A, 0xC1, 0x3D, 0x04, 0x85, 0x27, 0x87,
0x56, 0xE0, 0xEF, 0x00, 0xC8, 0x17, 0x74, 0x56,
0x61, 0xE1, 0xD5, 0x9F, 0xE3, 0x8E, 0x75, 0x37
},
{
0x10, 0x85, 0xD7, 0x83, 0x07, 0xB1, 0xC4, 0xB0,
0x08, 0xC5, 0x7A, 0x2E, 0x7E, 0x5B, 0x23, 0x46,
0x58, 0xA0, 0xA8, 0x2E, 0x4F, 0xF1, 0xE4, 0xAA,
0xAC, 0x72, 0xB3, 0x12, 0xFD, 0xA0, 0xFE, 0x27,
0xD2, 0x33, 0xBC, 0x5B, 0x10, 0xE9, 0xCC, 0x17,
0xFD, 0xC7, 0x69, 0x7B, 0x54, 0x0C, 0x7D, 0x95,
0xEB, 0x21, 0x5A, 0x19, 0xA1, 0xA0, 0xE2, 0x0E,
0x1A, 0xBF, 0xA1, 0x26, 0xEF, 0xD5, 0x68, 0xC7
},
{
0x4E, 0x5C, 0x73, 0x4C, 0x7D, 0xDE, 0x01, 0x1D,
0x83, 0xEA, 0xC2, 0xB7, 0x34, 0x7B, 0x37, 0x35,
0x94, 0xF9, 0x2D, 0x70, 0x91, 0xB9, 0xCA, 0x34,
0xCB, 0x9C, 0x6F, 0x39, 0xBD, 0xF5, 0xA8, 0xD2,
0xF1, 0x34, 0x37, 0x9E, 0x16, 0xD8, 0x22, 0xF6,
0x52, 0x21, 0x70, 0xCC, 0xF2, 0xDD, 0xD5, 0x5C,
0x84, 0xB9, 0xE6, 0xC6, 0x4F, 0xC9, 0x27, 0xAC,
0x4C, 0xF8, 0xDF, 0xB2, 0xA1, 0x77, 0x01, 0xF2
},
{
0x69, 0x5D, 0x83, 0xBD, 0x99, 0x0A, 0x11, 0x17,
0xB3, 0xD0, 0xCE, 0x06, 0xCC, 0x88, 0x80, 0x27,
0xD1, 0x2A, 0x05, 0x4C, 0x26, 0x77, 0xFD, 0x82,
0xF0, 0xD4, 0xFB, 0xFC, 0x93, 0x57, 0x55, 0x23,
0xE7, 0x99, 0x1A, 0x5E, 0x35, 0xA3, 0x75, 0x2E,
0x9B, 0x70, 0xCE, 0x62, 0x99, 0x2E, 0x26, 0x8A,
0x87, 0x77, 0x44, 0xCD, 0xD4, 0x35, 0xF5, 0xF1,
0x30, 0x86, 0x9C, 0x9A, 0x20, 0x74, 0xB3, 0x38
},
{
0xA6, 0x21, 0x37, 0x43, 0x56, 0x8E, 0x3B, 0x31,
0x58, 0xB9, 0x18, 0x43, 0x01, 0xF3, 0x69, 0x08,
0x47, 0x55, 0x4C, 0x68, 0x45, 0x7C, 0xB4, 0x0F,
0xC9, 0xA4, 0xB8, 0xCF, 0xD8, 0xD4, 0xA1, 0x18,
0xC3, 0x01, 0xA0, 0x77, 0x37, 0xAE, 0xDA, 0x0F,
0x92, 0x9C, 0x68, 0x91, 0x3C, 0x5F, 0x51, 0xC8,
0x03, 0x94, 0xF5, 0x3B, 0xFF, 0x1C, 0x3E, 0x83,
0xB2, 0xE4, 0x0C, 0xA9, 0x7E, 0xBA, 0x9E, 0x15
},
{
0xD4, 0x44, 0xBF, 0xA2, 0x36, 0x2A, 0x96, 0xDF,
0x21, 0x3D, 0x07, 0x0E, 0x33, 0xFA, 0x84, 0x1F,
0x51, 0x33, 0x4E, 0x4E, 0x76, 0x86, 0x6B, 0x81,
0x39, 0xE8, 0xAF, 0x3B, 0xB3, 0x39, 0x8B, 0xE2,
0xDF, 0xAD, 0xDC, 0xBC, 0x56, 0xB9, 0x14, 0x6D,
0xE9, 0xF6, 0x81, 0x18, 0xDC, 0x58, 0x29, 0xE7,
0x4B, 0x0C, 0x28, 0xD7, 0x71, 0x19, 0x07, 0xB1,
0x21, 0xF9, 0x16, 0x1C, 0xB9, 0x2B, 0x69, 0xA9
},
{
0x14, 0x27, 0x09, 0xD6, 0x2E, 0x28, 0xFC, 0xCC,
0xD0, 0xAF, 0x97, 0xFA, 0xD0, 0xF8, 0x46, 0x5B,
0x97, 0x1E, 0x82, 0x20, 0x1D, 0xC5, 0x10, 0x70,
0xFA, 0xA0, 0x37, 0x2A, 0xA4, 0x3E, 0x92, 0x48,
0x4B, 0xE1, 0xC1, 0xE7, 0x3B, 0xA1, 0x09, 0x06,
0xD5, 0xD1, 0x85, 0x3D, 0xB6, 0xA4, 0x10, 0x6E,
0x0A, 0x7B, 0xF9, 0x80, 0x0D, 0x37, 0x3D, 0x6D,
0xEE, 0x2D, 0x46, 0xD6, 0x2E, 0xF2, 0xA4, 0x61
},
};
#endif
bird2-2.17.5/lib/blake2.h 0000664 0000000 0000000 00000007533 15211753245 0014704 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- BLAKE2 Hash Functions
*
* Based on the code from BLAKE2 reference source code package
*
* Copyright 2012, Samuel Neves
*
* You may use this under the terms of the CC0, the OpenSSL License, or the
* Apache Public License 2.0, at your option. The terms of these licenses
* can be found at:
*
* - CC0 1.0 Universal : https://creativecommons.org/publicdomain/zero/1.0
* - OpenSSL license : https://www.openssl.org/source/license.html
* - Apache 2.0 : https://www.apache.org/licenses/LICENSE-2.0
*
* More information about the BLAKE2 hash function can be found at
* https://blake2.net/ web.
*/
#ifndef _BIRD_BLAKE2_H_
#define _BIRD_BLAKE2_H_
#include "nest/bird.h"
enum blake2s_constant
{
BLAKE2S_BLOCKBYTES = 64,
BLAKE2S_OUTBYTES = 32,
BLAKE2S_KEYBYTES = 32,
BLAKE2S_SALTBYTES = 8,
BLAKE2S_PERSONALBYTES = 8,
};
enum blake2b_constant
{
BLAKE2B_BLOCKBYTES = 128,
BLAKE2B_OUTBYTES = 64,
BLAKE2B_KEYBYTES = 64,
BLAKE2B_SALTBYTES = 16,
BLAKE2B_PERSONALBYTES = 16,
};
#define BLAKE2S_SIZE 32 // BLAKE2S_OUTBYTES
#define BLAKE2S_BLOCK_SIZE 64 // BLAKE2S_BLOCKBYTES
#define BLAKE2S_256_SIZE 32
#define BLAKE2B_SIZE 64 // BLAKE2B_OUTBYTES
#define BLAKE2B_BLOCK_SIZE 128 // BLAKE2B_BLOCKBYTES
#define BLAKE2B_512_SIZE 64
struct blake2s_state
{
u32 h[8];
u32 t[2];
u32 f[2];
byte buf[BLAKE2S_BLOCK_SIZE];
uint buflen;
uint outlen;
u8 last_node;
};
struct blake2b_state
{
u64 h[8];
u64 t[2];
u64 f[2];
byte buf[BLAKE2B_BLOCK_SIZE];
uint buflen;
uint outlen;
u8 last_node;
};
struct blake2s_param
{
u8 digest_length; /* 1 */
u8 key_length; /* 2 */
u8 fanout; /* 3 */
u8 depth; /* 4 */
u32 leaf_length; /* 8 */
u32 node_offset; /* 12 */
u16 xof_length; /* 14 */
u8 node_depth; /* 15 */
u8 inner_length; /* 16 */
/* byte reserved[0]; */
byte salt[BLAKE2S_SALTBYTES]; /* 24 */
byte personal[BLAKE2S_PERSONALBYTES]; /* 32 */
} PACKED;
struct blake2b_param
{
u8 digest_length; /* 1 */
u8 key_length; /* 2 */
u8 fanout; /* 3 */
u8 depth; /* 4 */
u32 leaf_length; /* 8 */
u32 node_offset; /* 12 */
u32 xof_length; /* 16 */
u8 node_depth; /* 17 */
u8 inner_length; /* 18 */
byte reserved[14]; /* 32 */
byte salt[BLAKE2B_SALTBYTES]; /* 48 */
byte personal[BLAKE2B_PERSONALBYTES]; /* 64 */
} PACKED;
/* Streaming API */
int blake2s_init(struct blake2s_state *s, size_t outlen);
int blake2s_init_key(struct blake2s_state *s, size_t outlen, const void *key, size_t keylen);
int blake2s_init_param(struct blake2s_state *s, const struct blake2s_param *p);
int blake2s_update(struct blake2s_state *s, const void *in, size_t inlen);
int blake2s_final(struct blake2s_state *s, void *out, size_t outlen);
int blake2b_init(struct blake2b_state *s, size_t outlen);
int blake2b_init_key(struct blake2b_state *s, size_t outlen, const void *key, size_t keylen);
int blake2b_init_param(struct blake2b_state *s, const struct blake2b_param *p);
int blake2b_update(struct blake2b_state *s, const void *in, size_t inlen);
int blake2b_final(struct blake2b_state *s, void *out, size_t outlen);
/* Wrapper functions for MAC class */
struct mac_desc;
struct mac_context;
struct blake2s_context {
const struct mac_desc *type;
struct blake2s_state state;
byte buf[BLAKE2S_SIZE];
};
struct blake2b_context {
const struct mac_desc *type;
struct blake2b_state state;
byte buf[BLAKE2B_SIZE];
};
void blake2s_mac_init(struct mac_context *ctx, const byte *key, uint keylen);
void blake2s_mac_update(struct mac_context *ctx, const byte *data, uint datalen);
byte *blake2s_mac_final(struct mac_context *ctx);
void blake2b_mac_init(struct mac_context *ctx, const byte *key, uint keylen);
void blake2b_mac_update(struct mac_context *ctx, const byte *data, uint datalen);
byte *blake2b_mac_final(struct mac_context *ctx);
#endif /* _BIRD_BLAKE2_H_ */
bird2-2.17.5/lib/blake2b.c 0000664 0000000 0000000 00000017550 15211753245 0015041 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- BLAKE2b Hash Function
*
* Based on the code from BLAKE2 reference source code package
*
* Copyright 2012, Samuel Neves
*
* You may use this under the terms of the CC0, the OpenSSL License, or the
* Apache Public License 2.0, at your option. The terms of these licenses
* can be found at:
*
* - CC0 1.0 Universal : https://creativecommons.org/publicdomain/zero/1.0
* - OpenSSL license : https://www.openssl.org/source/license.html
* - Apache 2.0 : https://www.apache.org/licenses/LICENSE-2.0
*
* More information about the BLAKE2 hash function can be found at
* https://blake2.net/ web.
*/
#include "lib/mac.h"
#include "lib/blake2.h"
#include "lib/blake2-impl.h"
static const u64 blake2b_IV[8] =
{
U64(0x6a09e667f3bcc908),
U64(0xbb67ae8584caa73b),
U64(0x3c6ef372fe94f82b),
U64(0xa54ff53a5f1d36f1),
U64(0x510e527fade682d1),
U64(0x9b05688c2b3e6c1f),
U64(0x1f83d9abfb41bd6b),
U64(0x5be0cd19137e2179)
};
static const u8 blake2b_sigma[12][16] =
{
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
{ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
{ 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
{ 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
{ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
{ 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 },
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
};
STATIC_ASSERT(sizeof(struct blake2b_param) == BLAKE2B_OUTBYTES);
static inline void
blake2b_set_lastnode(struct blake2b_state *s)
{
s->f[1] = (u64) -1;
}
/* Some helper functions, not necessarily useful */
static inline int
blake2b_is_lastblock(const struct blake2b_state *s)
{
return s->f[0] != 0;
}
static inline void
blake2b_set_lastblock(struct blake2b_state *s)
{
if (s->last_node)
blake2b_set_lastnode(s);
s->f[0] = (u64) -1;
}
static inline void
blake2b_increment_counter(struct blake2b_state *s, const u64 inc)
{
s->t[0] += inc;
s->t[1] += (s->t[0] < inc);
}
static void
blake2b_init0(struct blake2b_state *s)
{
memset(s, 0, sizeof(struct blake2b_state));
for (uint i = 0; i < 8; ++i)
s->h[i] = blake2b_IV[i];
}
/* init xors IV with input parameter block */
int
blake2b_init_param(struct blake2b_state *s, const struct blake2b_param *p)
{
const byte *pb = (const void *) p;
blake2b_init0(s);
/* IV XOR ParamBlock */
for (uint i = 0; i < 8; ++i)
s->h[i] ^= load64(pb + sizeof(s->h[i]) * i);
s->outlen = p->digest_length;
return 0;
}
int
blake2b_init(struct blake2b_state *s, size_t outlen)
{
struct blake2b_param p[1];
if (!outlen || (outlen > BLAKE2B_OUTBYTES))
return -1;
p->digest_length = (uint8_t) outlen;
p->key_length = 0;
p->fanout = 1;
p->depth = 1;
store32(&p->leaf_length, 0);
store32(&p->node_offset, 0);
store32(&p->xof_length, 0);
p->node_depth = 0;
p->inner_length = 0;
memset(p->reserved, 0, sizeof(p->reserved));
memset(p->salt, 0, sizeof(p->salt));
memset(p->personal, 0, sizeof(p->personal));
return blake2b_init_param(s, p);
}
int
blake2b_init_key(struct blake2b_state *s, size_t outlen, const void *key, size_t keylen)
{
struct blake2b_param p[1];
if (!outlen || (outlen > BLAKE2B_OUTBYTES))
return -1;
if (!key || !keylen || (keylen > BLAKE2B_KEYBYTES))
return -1;
p->digest_length = (uint8_t) outlen;
p->key_length = (uint8_t) keylen;
p->fanout = 1;
p->depth = 1;
store32(&p->leaf_length, 0);
store32(&p->node_offset, 0);
store32(&p->xof_length, 0);
p->node_depth = 0;
p->inner_length = 0;
memset(p->reserved, 0, sizeof(p->reserved));
memset(p->salt, 0, sizeof(p->salt));
memset(p->personal, 0, sizeof(p->personal));
if (blake2b_init_param(s, p) < 0)
return -1;
{
byte block[BLAKE2B_BLOCKBYTES];
memset(block, 0, BLAKE2B_BLOCKBYTES);
memcpy(block, key, keylen);
blake2b_update(s, block, BLAKE2B_BLOCKBYTES);
secure_zero_memory(block, BLAKE2B_BLOCKBYTES); /* Burn the key from stack */
}
return 0;
}
#define G(r,i,a,b,c,d) \
do { \
a = a + b + m[blake2b_sigma[r][2*i+0]]; \
d = rotr64(d ^ a, 32); \
c = c + d; \
b = rotr64(b ^ c, 24); \
a = a + b + m[blake2b_sigma[r][2*i+1]]; \
d = rotr64(d ^ a, 16); \
c = c + d; \
b = rotr64(b ^ c, 63); \
} while(0)
#define ROUND(r) \
do { \
G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \
G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \
G(r,2,v[ 2],v[ 6],v[10],v[14]); \
G(r,3,v[ 3],v[ 7],v[11],v[15]); \
G(r,4,v[ 0],v[ 5],v[10],v[15]); \
G(r,5,v[ 1],v[ 6],v[11],v[12]); \
G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \
G(r,7,v[ 3],v[ 4],v[ 9],v[14]); \
} while(0)
static void
blake2b_compress(struct blake2b_state *s, const byte block[BLAKE2B_BLOCKBYTES])
{
u64 m[16];
u64 v[16];
uint i;
for (i = 0; i < 16; ++i)
m[i] = load64(block + i * sizeof(m[i]));
for (i = 0; i < 8; ++i)
v[i] = s->h[i];
v[ 8] = blake2b_IV[0];
v[ 9] = blake2b_IV[1];
v[10] = blake2b_IV[2];
v[11] = blake2b_IV[3];
v[12] = blake2b_IV[4] ^ s->t[0];
v[13] = blake2b_IV[5] ^ s->t[1];
v[14] = blake2b_IV[6] ^ s->f[0];
v[15] = blake2b_IV[7] ^ s->f[1];
ROUND(0);
ROUND(1);
ROUND(2);
ROUND(3);
ROUND(4);
ROUND(5);
ROUND(6);
ROUND(7);
ROUND(8);
ROUND(9);
ROUND(10);
ROUND(11);
for (i = 0; i < 8; ++i)
s->h[i] = s->h[i] ^ v[i] ^ v[i + 8];
}
#undef G
#undef ROUND
int
blake2b_update(struct blake2b_state *s, const void *pin, size_t inlen)
{
const byte *in = pin;
if (inlen > 0)
{
size_t left = s->buflen;
size_t fill = BLAKE2B_BLOCKBYTES - left;
if (inlen > fill)
{
s->buflen = 0;
memcpy(s->buf + left, in, fill); /* Fill buffer */
blake2b_increment_counter(s, BLAKE2B_BLOCKBYTES);
blake2b_compress(s, s->buf); /* Compress */
in += fill; inlen -= fill;
while (inlen > BLAKE2B_BLOCKBYTES)
{
blake2b_increment_counter(s, BLAKE2B_BLOCKBYTES);
blake2b_compress(s, in);
in += BLAKE2B_BLOCKBYTES;
inlen -= BLAKE2B_BLOCKBYTES;
}
}
memcpy(s->buf + s->buflen, in, inlen);
s->buflen += inlen;
}
return 0;
}
int
blake2b_final(struct blake2b_state *s, void *out, size_t outlen)
{
byte buffer[BLAKE2B_OUTBYTES] = {0};
if (!out || (outlen < s->outlen))
return -1;
if (blake2b_is_lastblock(s))
return -1;
blake2b_increment_counter(s, s->buflen);
blake2b_set_lastblock(s);
memset(s->buf + s->buflen, 0, BLAKE2B_BLOCKBYTES - s->buflen); /* Padding */
blake2b_compress(s, s->buf);
/* Output full hash to temp buffer */
for (uint i = 0; i < 8; ++i)
store64(buffer + sizeof(s->h[i]) * i, s->h[i]);
memcpy(out, buffer, s->outlen);
secure_zero_memory(buffer, sizeof(buffer));
return 0;
}
void
blake2b_mac_init(struct mac_context *mac, const byte *key, uint keylen)
{
struct blake2b_context *ctx = (void *) mac;
blake2b_init_key(&ctx->state, mac_get_length(mac), key, keylen);
}
void
blake2b_mac_update(struct mac_context *mac, const byte *buf, uint len)
{
struct blake2b_context *ctx = (void *) mac;
blake2b_update(&ctx->state, buf, len);
}
byte *
blake2b_mac_final(struct mac_context *mac)
{
struct blake2b_context *ctx = (void *) mac;
blake2b_final(&ctx->state, ctx->buf, mac_get_length(mac));
return ctx->buf;
}
bird2-2.17.5/lib/blake2s.c 0000664 0000000 0000000 00000017236 15211753245 0015063 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- BLAKE2s Hash Function
*
* Based on the code from BLAKE2 reference source code package
*
* Copyright 2012, Samuel Neves
*
* You may use this under the terms of the CC0, the OpenSSL License, or the
* Apache Public License 2.0, at your option. The terms of these licenses
* can be found at:
*
* - CC0 1.0 Universal : https://creativecommons.org/publicdomain/zero/1.0
* - OpenSSL license : https://www.openssl.org/source/license.html
* - Apache 2.0 : https://www.apache.org/licenses/LICENSE-2.0
*
* More information about the BLAKE2 hash function can be found at
* https://blake2.net/ web.
*/
#include "lib/mac.h"
#include "lib/blake2.h"
#include "lib/blake2-impl.h"
static const u32 blake2s_IV[8] =
{
0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
};
static const u8 blake2s_sigma[10][16] =
{
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
{ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
{ 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
{ 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
{ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
{ 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 },
};
STATIC_ASSERT(sizeof(struct blake2s_param) == BLAKE2S_OUTBYTES);
static inline void
blake2s_set_lastnode(struct blake2s_state *s)
{
s->f[1] = (u32) -1;
}
/* Some helper functions, not necessarily useful */
static inline int
blake2s_is_lastblock(const struct blake2s_state *s)
{
return s->f[0] != 0;
}
static inline void
blake2s_set_lastblock(struct blake2s_state *s)
{
if (s->last_node)
blake2s_set_lastnode(s);
s->f[0] = (u32) -1;
}
static inline void
blake2s_increment_counter(struct blake2s_state *s, const u32 inc)
{
s->t[0] += inc;
s->t[1] += (s->t[0] < inc);
}
static void
blake2s_init0(struct blake2s_state *s)
{
memset(s, 0, sizeof(struct blake2s_state));
for (uint i = 0; i < 8; ++i)
s->h[i] = blake2s_IV[i];
}
/* init2 xors IV with input parameter block */
int
blake2s_init_param(struct blake2s_state *s, const struct blake2s_param *p)
{
const byte *pb = (const void *) p;
blake2s_init0(s);
/* IV XOR ParamBlock */
for (uint i = 0; i < 8; ++i)
s->h[i] ^= load32(&pb[i * 4]);
s->outlen = p->digest_length;
return 0;
}
/* Sequential blake2s initialization */
int
blake2s_init(struct blake2s_state *s, size_t outlen)
{
struct blake2s_param p[1];
/* Move interval verification here? */
if (!outlen || (outlen > BLAKE2S_OUTBYTES))
return -1;
p->digest_length = (uint8_t) outlen;
p->key_length = 0;
p->fanout = 1;
p->depth = 1;
store32(&p->leaf_length, 0);
store32(&p->node_offset, 0);
store16(&p->xof_length, 0);
p->node_depth = 0;
p->inner_length = 0;
/* memset(p->reserved, 0, sizeof(p->reserved)); */
memset(p->salt, 0, sizeof(p->salt));
memset(p->personal, 0, sizeof(p->personal));
return blake2s_init_param(s, p);
}
int
blake2s_init_key(struct blake2s_state *s, size_t outlen, const void *key, size_t keylen)
{
struct blake2s_param p[1];
if (!outlen || (outlen > BLAKE2S_OUTBYTES))
return -1;
if (!key || !keylen || (keylen > BLAKE2S_KEYBYTES))
return -1;
p->digest_length = (uint8_t) outlen;
p->key_length = (uint8_t) keylen;
p->fanout = 1;
p->depth = 1;
store32(&p->leaf_length, 0);
store32(&p->node_offset, 0);
store16(&p->xof_length, 0);
p->node_depth = 0;
p->inner_length = 0;
/* memset(p->reserved, 0, sizeof(p->reserved)); */
memset(p->salt, 0, sizeof(p->salt));
memset(p->personal, 0, sizeof(p->personal));
if (blake2s_init_param(s, p) < 0)
return -1;
{
byte block[BLAKE2S_BLOCKBYTES];
memset(block, 0, BLAKE2S_BLOCKBYTES);
memcpy(block, key, keylen);
blake2s_update(s, block, BLAKE2S_BLOCKBYTES);
secure_zero_memory(block, BLAKE2S_BLOCKBYTES); /* Burn the key from stack */
}
return 0;
}
#define G(r,i,a,b,c,d) \
do { \
a = a + b + m[blake2s_sigma[r][2*i+0]]; \
d = rotr32(d ^ a, 16); \
c = c + d; \
b = rotr32(b ^ c, 12); \
a = a + b + m[blake2s_sigma[r][2*i+1]]; \
d = rotr32(d ^ a, 8); \
c = c + d; \
b = rotr32(b ^ c, 7); \
} while(0)
#define ROUND(r) \
do { \
G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \
G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \
G(r,2,v[ 2],v[ 6],v[10],v[14]); \
G(r,3,v[ 3],v[ 7],v[11],v[15]); \
G(r,4,v[ 0],v[ 5],v[10],v[15]); \
G(r,5,v[ 1],v[ 6],v[11],v[12]); \
G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \
G(r,7,v[ 3],v[ 4],v[ 9],v[14]); \
} while(0)
static void
blake2s_compress(struct blake2s_state *s, const byte in[BLAKE2S_BLOCKBYTES])
{
u32 m[16];
u32 v[16];
uint i;
for (i = 0; i < 16; ++i)
m[i] = load32(in + i * sizeof(m[i]));
for (i = 0; i < 8; ++i)
v[i] = s->h[i];
v[ 8] = blake2s_IV[0];
v[ 9] = blake2s_IV[1];
v[10] = blake2s_IV[2];
v[11] = blake2s_IV[3];
v[12] = s->t[0] ^ blake2s_IV[4];
v[13] = s->t[1] ^ blake2s_IV[5];
v[14] = s->f[0] ^ blake2s_IV[6];
v[15] = s->f[1] ^ blake2s_IV[7];
ROUND(0);
ROUND(1);
ROUND(2);
ROUND(3);
ROUND(4);
ROUND(5);
ROUND(6);
ROUND(7);
ROUND(8);
ROUND(9);
for (i = 0; i < 8; ++i)
s->h[i] = s->h[i] ^ v[i] ^ v[i + 8];
}
#undef G
#undef ROUND
int
blake2s_update(struct blake2s_state *s, const void *pin, size_t inlen)
{
const byte *in = pin;
if (inlen > 0)
{
size_t left = s->buflen;
size_t fill = BLAKE2S_BLOCKBYTES - left;
if (inlen > fill)
{
s->buflen = 0;
memcpy(s->buf + left, in, fill); /* Fill buffer */
blake2s_increment_counter(s, BLAKE2S_BLOCKBYTES);
blake2s_compress(s, s->buf); /* Compress */
in += fill; inlen -= fill;
while (inlen > BLAKE2S_BLOCKBYTES)
{
blake2s_increment_counter(s, BLAKE2S_BLOCKBYTES);
blake2s_compress(s, in);
in += BLAKE2S_BLOCKBYTES;
inlen -= BLAKE2S_BLOCKBYTES;
}
}
memcpy(s->buf + s->buflen, in, inlen);
s->buflen += inlen;
}
return 0;
}
int
blake2s_final(struct blake2s_state *s, void *out, size_t outlen)
{
byte buffer[BLAKE2S_OUTBYTES] = {0};
if (!out || (outlen < s->outlen))
return -1;
if (blake2s_is_lastblock(s))
return -1;
blake2s_increment_counter(s, s->buflen);
blake2s_set_lastblock(s);
memset(s->buf + s->buflen, 0, BLAKE2S_BLOCKBYTES - s->buflen); /* Padding */
blake2s_compress(s, s->buf);
/* Output full hash to temp buffer */
for (uint i = 0; i < 8; ++i)
store32(buffer + sizeof(s->h[i]) * i, s->h[i]);
memcpy(out, buffer, outlen);
secure_zero_memory(buffer, sizeof(buffer));
return 0;
}
void
blake2s_mac_init(struct mac_context *mac, const byte *key, uint keylen)
{
struct blake2s_context *ctx = (void *) mac;
blake2s_init_key(&ctx->state, mac_get_length(mac), key, keylen);
}
void
blake2s_mac_update(struct mac_context *mac, const byte *data, uint datalen)
{
struct blake2s_context *ctx = (void *) mac;
blake2s_update(&ctx->state, data, datalen);
}
byte *
blake2s_mac_final(struct mac_context *mac)
{
struct blake2s_context *ctx = (void *) mac;
blake2s_final(&ctx->state, ctx->buf, mac_get_length(mac));
return ctx->buf;
}
bird2-2.17.5/lib/buffer.h 0000664 0000000 0000000 00000003140 15211753245 0015003 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Generic Buffer Structure
*
* (c) 2013 Ondrej Zajicek
* (c) 2013 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_BUFFER_H_
#define _BIRD_BUFFER_H_
#include "lib/resource.h"
#include "sysdep/config.h"
#define BUFFER_(type) struct { type *data; uint used, size; }
#define BUFFER_TYPE(v) typeof(* (v).data)
#define BUFFER_SIZE(v) ((v).size * sizeof(* (v).data))
#ifndef PARSER
#define BUFFER(type) BUFFER_(type)
#endif
#define BUFFER_INIT(v,pool,isize) \
({ \
(v).used = 0; \
(v).size = (isize); \
(v).data = mb_alloc(pool, BUFFER_SIZE(v)); \
})
#define BUFFER_SET(v,nsize) \
({ \
(v).used = (nsize); \
if ((v).used > (v).size) \
buffer_realloc((void **) &((v).data), &((v).size), (v).used, sizeof(* (v).data)); \
})
#define BUFFER_INC(v,step) \
({ \
uint _o = (v).used; \
BUFFER_SET(v, (v).used + (step)); \
(v).data + _o; \
})
#define BUFFER_DEC(v,step) ({ (v).used -= (step); })
#define BUFFER_PUSH(v) (*BUFFER_INC(v,1))
#define BUFFER_POP(v) BUFFER_DEC(v,1)
#define BUFFER_FLUSH(v) ({ (v).used = 0; })
#define BUFFER_EMPTY(v) ({ (v).used == 0; })
#define BUFFER_WALK(v,n) \
for (BUFFER_TYPE(v) *_n = (v).data, n; _n < ((v).data + (v).used) && (n = *_n, 1); _n++)
#define BUFFER_SHALLOW_COPY(dst, src) \
({ \
(dst).used = (src).used; \
(dst).size = (src).size; \
(dst).data = (src).data; \
})
#endif /* _BIRD_BUFFER_H_ */
bird2-2.17.5/lib/buffer_test.c 0000664 0000000 0000000 00000005720 15211753245 0016043 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Buffer Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include
#include "test/birdtest.h"
#include "lib/buffer.h"
#define MAX_NUM 33
typedef BUFFER(int) buffer_int;
static int expected[MAX_NUM];
static buffer_int buf;
static struct pool *buffer_pool;
static void
show_buf(buffer_int *b)
{
uint i;
bt_debug(".used = %d, .size = %d\n", b->used, b->size);
for (i = 0; i < b->used; i++)
bt_debug(" .data[%3u] = %-16d expected %-16d %s\n", i, b->data[i], expected[i], (b->data[i] == expected[i] ? "OK" : "FAIL!"));
}
static void
fill_expected_array(void)
{
int i;
for (i = 0; i < MAX_NUM; i++)
expected[i] = bt_random();
}
static void
init_buffer(void)
{
buffer_pool = &root_pool;
BUFFER_INIT(buf, buffer_pool, MAX_NUM);
}
static int
is_buffer_as_expected(buffer_int *b)
{
show_buf(b);
int i;
for (i = 0; i < MAX_NUM; i++)
bt_assert(b->data[i] == expected[i]);
return 1;
}
static int
t_buffer_push(void)
{
int i;
init_buffer();
fill_expected_array();
for (i = 0; i < MAX_NUM; i++)
BUFFER_PUSH(buf) = expected[i];
is_buffer_as_expected(&buf);
return 1;
}
static int
t_buffer_pop(void)
{
int i;
init_buffer();
fill_expected_array();
/* POP a half of elements */
for (i = 0; i < MAX_NUM; i++)
BUFFER_PUSH(buf) = expected[i];
for (i = MAX_NUM-1; i >= MAX_NUM/2; i--)
BUFFER_POP(buf);
for (i = MAX_NUM/2; i < MAX_NUM; i++)
BUFFER_PUSH(buf) = expected[i] = bt_random();
is_buffer_as_expected(&buf);
/* POP all of elements */
for (i = MAX_NUM-1; i >= 0; i--)
BUFFER_POP(buf);
bt_assert(buf.used == 0);
for (i = 0; i < MAX_NUM; i++)
BUFFER_PUSH(buf) = expected[i];
is_buffer_as_expected(&buf);
return 1;
}
static int
t_buffer_resize(void)
{
int i;
init_buffer();
BUFFER_INIT(buf, buffer_pool, 0);
fill_expected_array();
for (i = 0; i < MAX_NUM; i++)
BUFFER_PUSH(buf) = expected[i];
is_buffer_as_expected(&buf);
bt_assert(buf.size >= MAX_NUM);
return 1;
}
static int
t_buffer_flush(void)
{
int i;
init_buffer();
fill_expected_array();
for (i = 0; i < MAX_NUM; i++)
BUFFER_PUSH(buf) = expected[i];
BUFFER_FLUSH(buf);
bt_assert(buf.used == 0);
return 1;
}
static int
t_buffer_walk(void)
{
int i;
init_buffer();
fill_expected_array();
for (i = 0; i < MAX_NUM; i++)
BUFFER_PUSH(buf) = expected[i];
i = 0;
BUFFER_WALK(buf, v)
bt_assert(v == expected[i++]);
bt_assert(i == MAX_NUM);
return 1;
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_buffer_push, "Pushing new elements");
bt_test_suite(t_buffer_pop, "Fill whole buffer (PUSH), a half of elements POP and PUSH new elements");
bt_test_suite(t_buffer_resize, "Init a small buffer and try overfill");
bt_test_suite(t_buffer_flush, "Fill and flush all elements");
bt_test_suite(t_buffer_walk, "Fill and walk through buffer");
return bt_exit_value();
}
bird2-2.17.5/lib/checksum.c 0000664 0000000 0000000 00000004622 15211753245 0015335 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- IP One-Complement Checksum
*
* (c) 1999--2000 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
/**
* DOC: Miscellaneous functions.
*/
#include
#include "nest/bird.h"
#include "checksum.h"
static inline u32
add32(u32 sum, u32 x)
{
u32 z = sum + x;
// return z + (z < sum);
/* add carry */
if (z < x)
z++;
return z;
}
static u16
ipsum_calc_block(u32 *buf, uint len, u16 isum)
{
/*
* A few simple facts about the IP checksum (see RFC 1071 for detailed
* discussion):
*
* o It's associative and commutative.
* o It's byte order independent.
* o It's word size independent.
*
* This gives us a neat 32-bits-at-a-time algorithm which respects
* usual alignment requirements and is reasonably fast.
*/
ASSERT(!(len % 4));
if (!len)
return isum;
u32 *end = buf + (len >> 2);
u32 sum = isum;
while (buf < end)
sum = add32(sum, *buf++);
sum = (sum >> 16) + (sum & 0xffff); /* add high-16 to low-16 */
sum += (sum >> 16); /* add carry */
return sum;
}
static u16
ipsum_calc(void *frag, uint len, va_list args)
{
u16 sum = 0;
for(;;)
{
sum = ipsum_calc_block(frag, len, sum);
frag = va_arg(args, void *);
if (!frag)
break;
len = va_arg(args, uint);
}
return sum;
}
/**
* ipsum_verify - verify an IP checksum
* @frag: first packet fragment
* @len: length in bytes
*
* This function verifies whether a given fragmented packet
* has correct one's complement checksum as used by the IP
* protocol.
*
* It uses all the clever tricks described in RFC 1071 to speed
* up checksum calculation as much as possible.
*
* Result: 1 if the checksum is correct, 0 else.
*/
int
ipsum_verify(void *frag, uint len, ...)
{
va_list args;
u16 sum;
va_start(args, len);
sum = ipsum_calc(frag, len, args);
va_end(args);
return sum == 0xffff;
}
/**
* ipsum_calculate - compute an IP checksum
* @frag: first packet fragment
* @len: length in bytes
*
* This function calculates a one's complement checksum of a given fragmented
* packet.
*
* It uses all the clever tricks described in RFC 1071 to speed
* up checksum calculation as much as possible.
*/
u16
ipsum_calculate(void *frag, uint len, ...)
{
va_list args;
u16 sum;
va_start(args, len);
sum = ipsum_calc(frag, len, args);
va_end(args);
return 0xffff - sum;
}
bird2-2.17.5/lib/checksum.h 0000664 0000000 0000000 00000000656 15211753245 0015345 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- IP One-Complement Checksum
*
* (c) 1999 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_CHECKSUM_H_
#define _BIRD_CHECKSUM_H_
/*
* Both checksumming functions accept a vararg list of packet
* fragments finished by NULL pointer.
*/
int ipsum_verify(void *frag, uint len, ...);
u16 ipsum_calculate(void *frag, uint len, ...);
#endif
bird2-2.17.5/lib/checksum_test.c 0000664 0000000 0000000 00000003341 15211753245 0016371 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- IP One-Complement Checksum Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include
#include "test/birdtest.h"
#include "lib/checksum.h"
#define MAX_NUM 10000
static u16
ipsum_calculate_expected(u32 *a)
{
int i;
u32 sum = 0;
for(i = 0; i < MAX_NUM; i++)
{
sum += a[i] & 0xffff;
bt_debug("low) \t0x%08X \n", sum);
sum += a[i] >> 16;
bt_debug("high) \t0x%08X \n", sum);
u16 carry = sum >> 16;
sum = (sum & 0xffff) + carry;
bt_debug("carry) \t0x%08X \n\n", sum);
}
bt_debug("sum) \t0x%08X \n", sum);
sum = sum ^ 0xffff;
bt_debug("~sum) \t0x%08X \n", sum);
return sum;
}
static int
t_calculate(void)
{
u32 a[MAX_NUM];
int i;
for (i = 0; i < MAX_NUM; i++)
a[i] = bt_random();
u16 sum_calculated = ipsum_calculate(a, sizeof(a), NULL);
u16 sum_calculated_2 = ipsum_calculate(&a[0], sizeof(u32)*(MAX_NUM/2), &a[MAX_NUM/2], sizeof(u32)*(MAX_NUM - MAX_NUM/2), NULL);
bt_assert(sum_calculated == sum_calculated_2);
u16 sum_expected = ipsum_calculate_expected(a);
bt_debug("sum_calculated: %08X \n", sum_calculated);
bt_debug("sum_expected: %08X \n", sum_expected);
bt_assert(sum_calculated == sum_expected);
return 1;
}
static int
t_verify(void)
{
u32 a[MAX_NUM+1];
int i;
for (i = 0; i < MAX_NUM; i++)
a[i] = bt_random();
u16 sum = ipsum_calculate_expected(a);
a[MAX_NUM] = sum;
bt_assert(ipsum_verify(a, sizeof(a), NULL));
return 1;
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_calculate, "Checksum of pseudo-random data");
bt_test_suite(t_verify, "Verification of pseudo-random data.");
return bt_exit_value();
}
bird2-2.17.5/lib/event.c 0000664 0000000 0000000 00000010301 15211753245 0014643 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Event Processing
*
* (c) 1999 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
/**
* DOC: Events
*
* Events are there to keep track of deferred execution.
* Since BIRD is single-threaded, it requires long lasting tasks to be split to smaller
* parts, so that no module can monopolize the CPU. To split such a task, just create
* an &event resource, point it to the function you want to have called and call ev_schedule()
* to ask the core to run the event when nothing more important requires attention.
*
* You can also define your own event lists (the &event_list structure), enqueue your
* events in them and explicitly ask to run them.
*/
#include "nest/bird.h"
#include "lib/event.h"
event_list global_event_list;
event_list global_work_list;
inline void
ev_postpone(event *e)
{
if (ev_active(e))
{
rem_node(&e->n);
e->n.next = NULL;
}
}
static void
ev_dump(struct dump_request *dreq, resource *r)
{
event *e = (event *) r;
RDUMP("(code %p, data %p, %s)\n",
e->hook,
e->data,
e->n.next ? "scheduled" : "inactive");
}
static struct resclass ev_class = {
"Event",
sizeof(event),
(void (*)(resource *)) ev_postpone,
ev_dump,
NULL,
NULL
};
/**
* ev_new - create a new event
* @p: resource pool
*
* This function creates a new event resource. To use it,
* you need to fill the structure fields and call ev_schedule().
*/
event *
ev_new(pool *p)
{
event *e = ralloc(p, &ev_class);
return e;
}
/**
* ev_run - run an event
* @e: an event
*
* This function explicitly runs the event @e (calls its hook
* function) and removes it from an event list if it's linked to any.
*
* From the hook function, you can call ev_enqueue() or ev_schedule()
* to re-add the event.
*/
inline void
ev_run(event *e)
{
ev_postpone(e);
e->hook(e->data);
}
/**
* ev_enqueue - enqueue an event
* @l: an event list
* @e: an event
*
* ev_enqueue() stores the event @e to the specified event
* list @l which can be run by calling ev_run_list().
*/
inline void
ev_enqueue(event_list *l, event *e)
{
ev_postpone(e);
add_tail(l, &e->n);
}
/**
* ev_schedule - schedule an event
* @e: an event
*
* This function schedules an event by enqueueing it to a system-wide
* event list which is run by the platform dependent code whenever
* appropriate.
*/
void
ev_schedule(event *e)
{
ev_enqueue(&global_event_list, e);
}
/**
* ev_schedule_work - schedule a work-event.
* @e: an event
*
* This function schedules an event by enqueueing it to a system-wide work-event
* list which is run by the platform dependent code whenever appropriate. This
* is designated for work-events instead of regular events. They are executed
* less often in order to not clog I/O loop.
*/
void
ev_schedule_work(event *e)
{
if (!ev_active(e))
add_tail(&global_work_list, &e->n);
}
void io_log_event(void *hook, void *data);
/**
* ev_run_list - run an event list
* @l: an event list
*
* This function calls ev_run() for all events enqueued in the list @l.
*/
int
ev_run_list(event_list *l)
{
node *n;
list tmp_list;
init_list(&tmp_list);
add_tail_list(&tmp_list, l);
init_list(l);
WALK_LIST_FIRST(n, tmp_list)
{
event *e = SKIP_BACK(event, n, n);
/* This is ugly hack, we want to log just events executed from the main I/O loop */
if ((l == &global_event_list) || (l == &global_work_list))
io_log_event(e->hook, e->data);
ev_run(e);
tmp_flush();
}
return !EMPTY_LIST(*l);
}
int
ev_run_list_limited(event_list *l, uint limit)
{
node *n;
list tmp_list;
init_list(&tmp_list);
add_tail_list(&tmp_list, l);
init_list(l);
WALK_LIST_FIRST(n, tmp_list)
{
event *e = SKIP_BACK(event, n, n);
if (!limit)
break;
/* This is ugly hack, we want to log just events executed from the main I/O loop */
if ((l == &global_event_list) || (l == &global_work_list))
io_log_event(e->hook, e->data);
ev_run(e);
tmp_flush();
limit--;
}
if (!EMPTY_LIST(tmp_list))
{
/* Attach new items after the unprocessed old items */
add_tail_list(&tmp_list, l);
init_list(l);
add_tail_list(l, &tmp_list);
}
return !EMPTY_LIST(*l);
}
bird2-2.17.5/lib/event.h 0000664 0000000 0000000 00000001710 15211753245 0014654 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Event Processing
*
* (c) 1999 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_EVENT_H_
#define _BIRD_EVENT_H_
#include "lib/resource.h"
typedef struct event {
resource r;
void (*hook)(void *);
void *data;
node n; /* Internal link */
} event;
typedef list event_list;
extern event_list global_event_list;
extern event_list global_work_list;
event *ev_new(pool *);
void ev_run(event *);
#define ev_init_list(el) init_list(el)
void ev_enqueue(event_list *, event *);
void ev_schedule(event *);
void ev_schedule_work(event *);
void ev_postpone(event *);
int ev_run_list(event_list *);
int ev_run_list_limited(event_list *, uint);
static inline int
ev_active(event *e)
{
return e->n.next != NULL;
}
static inline event*
ev_new_init(pool *p, void (*hook)(void *), void *data)
{
event *e = ev_new(p);
e->hook = hook;
e->data = data;
return e;
}
#endif
bird2-2.17.5/lib/event_test.c 0000664 0000000 0000000 00000003325 15211753245 0015712 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Event Processing Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "lib/net.h"
#include "lib/event.h"
#include "conf/conf.h"
#include "nest/locks.h"
#include "sysdep/unix/unix.h"
#include "nest/iface.h"
#include "nest/route.h"
#define MAX_NUM 4
int event_check_points[MAX_NUM];
#define event_hook_body(num) \
do { \
bt_debug("Event Hook " #num "\n"); \
event_check_points[num] = 1; \
bt_assert_msg(event_check_points[num-1], "Events should be run in right order"); \
} while (0)
static void event_hook_1(void *data UNUSED) { event_hook_body(1); }
static void event_hook_2(void *data UNUSED) { event_hook_body(2); }
static void event_hook_3(void *data UNUSED) { event_hook_body(3); }
#define schedule_event(num) \
do { \
struct event *event_##num = ev_new(&root_pool); \
event_##num->hook = event_hook_##num; \
ev_schedule(event_##num); \
} while (0)
static void
init_event_check_points(void)
{
int i;
event_check_points[0] = 1;
for (i = 1; i < MAX_NUM; i++)
event_check_points[i] = 0;
}
static int
t_ev_run_list(void)
{
int i;
olock_init();
timer_init();
io_init();
rt_init();
if_init();
// roa_init();
config_init();
config = config_alloc("");
init_event_check_points();
schedule_event(1);
schedule_event(2);
schedule_event(3);
ev_run_list(&global_event_list);
for (i = 1; i < MAX_NUM; i++)
bt_assert(event_check_points[i]);
return 1;
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_ev_run_list, "Schedule and run 3 events in right order.");
return bt_exit_value();
}
bird2-2.17.5/lib/fletcher16.h 0000664 0000000 0000000 00000012333 15211753245 0015501 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Fletcher-16 checksum
*
* (c) 2015 Ondrej Zajicek
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
/**
* DOC: Fletcher-16 checksum
*
* Fletcher-16 checksum is a position-dependent checksum algorithm used for
* error-detection e.g. in OSPF LSAs.
*
* To generate Fletcher-16 checksum, zero the checksum field in data, initialize
* the context by fletcher16_init(), process the data by fletcher16_update(),
* compute the checksum value by fletcher16_final() and store it to the checksum
* field in data by put_u16() (or other means involving htons() conversion).
*
* To verify Fletcher-16 checksum, initialize the context by fletcher16_init(),
* process the data by fletcher16_update(), compute a passing checksum by
* fletcher16_compute() and check if it is zero.
*/
#ifndef _BIRD_FLETCHER16_H_
#define _BIRD_FLETCHER16_H_
#include "nest/bird.h"
struct fletcher16_context
{
int c0, c1;
};
/**
* fletcher16_init - initialize Fletcher-16 context
* @ctx: the context
*/
static inline void
fletcher16_init(struct fletcher16_context *ctx)
{
ctx->c0 = ctx->c1 = 0;
}
/**
* fletcher16_update - process data to Fletcher-16 context
* @ctx: the context
* @buf: data buffer
* @len: data length
*
* fletcher16_update() reads data from the buffer @buf and updates passing sums
* in the context @ctx. It may be used multiple times for multiple blocks of
* checksummed data.
*/
static inline void
fletcher16_update(struct fletcher16_context *ctx, const u8* buf, int len)
{
/*
* The Fletcher-16 sum is essentially a sequence of
* ctx->c1 += ctx->c0 += *buf++, modulo 255.
*
* In the inner loop, we eliminate modulo operation and we do some loop
* unrolling. MODX is the maximal number of steps that can be done without
* modulo before overflow, see RFC 1008 for details. We use a bit smaller
* value to cover for initial steps due to loop unrolling.
*/
#define MODX 4096
int blen, i;
blen = len % 4;
len -= blen;
for (i = 0; i < blen; i++)
ctx->c1 += ctx->c0 += *buf++;
do {
blen = MIN(len, MODX);
len -= blen;
for (i = 0; i < blen; i += 4)
{
ctx->c1 += ctx->c0 += *buf++;
ctx->c1 += ctx->c0 += *buf++;
ctx->c1 += ctx->c0 += *buf++;
ctx->c1 += ctx->c0 += *buf++;
}
ctx->c0 %= 255;
ctx->c1 %= 255;
} while (len);
}
/**
* fletcher16_update_n32 - process data to Fletcher-16 context, with endianity adjustment
* @ctx: the context
* @buf: data buffer
* @len: data length
*
* fletcher16_update_n32() works like fletcher16_update(), except it applies
* 32-bit host/network endianity swap to the data before they are processed.
* I.e., it assumes that the data is a sequence of u32 that must be converted by
* ntohl() or htonl() before processing. The @buf need not to be aligned, but
* its length (@len) must be multiple of 4. Note that on big endian systems the
* host endianity is the same as the network endianity, therefore there is no
* endianity swap.
*/
static inline void
fletcher16_update_n32(struct fletcher16_context *ctx, const u8* buf, int len)
{
/* See fletcher16_update() for details */
int blen, i;
do {
blen = MIN(len, MODX);
len -= blen;
for (i = 0; i < blen; i += 4)
{
#ifdef CPU_BIG_ENDIAN
ctx->c1 += ctx->c0 += *buf++;
ctx->c1 += ctx->c0 += *buf++;
ctx->c1 += ctx->c0 += *buf++;
ctx->c1 += ctx->c0 += *buf++;
#else
ctx->c1 += ctx->c0 += buf[3];
ctx->c1 += ctx->c0 += buf[2];
ctx->c1 += ctx->c0 += buf[1];
ctx->c1 += ctx->c0 += buf[0];
buf += 4;
#endif
}
ctx->c0 %= 255;
ctx->c1 %= 255;
} while (len);
}
/**
* fletcher16_final - compute final Fletcher-16 checksum value
* @ctx: the context
* @len: total data length
* @pos: offset in data where the checksum will be stored
*
* fletcher16_final() computes the final checksum value and returns it.
* The caller is responsible for storing it in the appropriate position.
* The checksum value depends on @len and @pos, but only their difference
* (i.e. the offset from the end) is significant.
*
* The checksum value is represented as u16, although it is defined as two
* consecutive bytes. We treat them as one u16 in big endian / network order.
* I.e., the returned value is in the form that would be returned by get_u16()
* from the checksum field in the data buffer, therefore the caller should use
* put_u16() or an explicit host-to-network conversion when storing it to the
* checksum field in the data buffer.
*
* Note that the returned checksum value is always nonzero.
*/
static inline u16
fletcher16_final(struct fletcher16_context *ctx, int len, int pos)
{
int x = ((len - pos - 1) * ctx->c0 - ctx->c1) % 255;
if (x <= 0)
x += 255;
int y = 510 - ctx->c0 - x;
if (y > 255)
y -= 255;
return (x << 8) | y;
}
/**
* fletcher16_compute - compute Fletcher-16 sum for verification
* @ctx: the context
*
* fletcher16_compute() returns a passing Fletcher-16 sum for processed data.
* If the data contains the proper Fletcher-16 checksum value, the returned
* value is zero.
*/
static inline u16
fletcher16_compute(struct fletcher16_context *ctx)
{
return (ctx->c0 << 8) | ctx->c1;
}
#endif
bird2-2.17.5/lib/fletcher16_test.c 0000664 0000000 0000000 00000011211 15211753245 0016525 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Fletcher-16 Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "lib/fletcher16.h"
static u16
straightforward_fletcher16_compute(const char *data)
{
int count = strlen(data);
u16 sum1 = 0;
u16 sum2 = 0;
int index;
for (index = 0; index < count; ++index)
{
sum1 = (sum1 + data[index]) % 255;
sum2 = (sum2 + sum1) % 255;
}
sum2 = (sum2 + sum1) % 255;
sum2 = (sum2 + sum1) % 255;
return (sum1 << 8) | sum2;
}
static u16
straightforward_fletcher16_checksum(const char *data)
{
u16 csum;
u16 c0,c1,x,y;
csum = straightforward_fletcher16_compute(data);
c0 = (csum >> 8) & 0xff;
c1 = csum & 0xff;
x = (255 + c0 - c1) % 255;
y = (510 - 2*c0 + c1) % 255;
if (!x) x = 255;
if (!y) y = 255;
return (x << 8) | y;
}
const u8 zero16[2] = {};
static int
test_fletcher16(void *out_, const void *in_, const void *expected_out_)
{
u16 *out = out_;
const char *in = in_;
const u16 *expected_out = expected_out_;
struct fletcher16_context ctxt;
fletcher16_init(&ctxt);
fletcher16_update(&ctxt, in, strlen(in));
fletcher16_update(&ctxt, zero16, 2);
*out = fletcher16_compute(&ctxt);
return *out == *expected_out;
}
static int
test_fletcher16_checksum(void *out_, const void *in_, const void *expected_out_)
{
u16 *out = out_;
const char *in = in_;
const u16 *expected_out = expected_out_;
struct fletcher16_context ctxt;
int len = strlen(in);
fletcher16_init(&ctxt);
fletcher16_update(&ctxt, in, len);
fletcher16_update(&ctxt, zero16, 2);
*out = fletcher16_final(&ctxt, len+2, len);
return *out == *expected_out;
}
static int
t_fletcher16_compute(void)
{
struct bt_pair test_vectors[] = {
{
.in = "\001\002",
.out = & ((const u16) { straightforward_fletcher16_compute("\001\002") }),
},
{
.in = "",
.out = & ((const u16) { straightforward_fletcher16_compute("") }),
},
{
.in = "a",
.out = & ((const u16) { straightforward_fletcher16_compute("a") }),
},
{
.in = "abcd",
.out = & ((const u16) { straightforward_fletcher16_compute("abcd") }),
},
{
.in = "message digest",
.out = & ((const u16) { straightforward_fletcher16_compute("message digest") }),
},
{
.in = "abcdefghijklmnopqrstuvwxyz",
.out = & ((const u16) { straightforward_fletcher16_compute("abcdefghijklmnopqrstuvwxyz") }),
},
{
.in = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
.out = & ((const u16) { straightforward_fletcher16_compute("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") }),
},
{
.in = "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
.out = & ((const u16) { straightforward_fletcher16_compute("12345678901234567890123456789012345678901234567890123456789012345678901234567890") }),
},
};
return bt_assert_batch(test_vectors, test_fletcher16, bt_fmt_str, bt_fmt_unsigned);
}
static int
t_fletcher16_checksum(void)
{
struct bt_pair test_vectors[] = {
{
.in = "\001\002",
.out = & ((const u16) { straightforward_fletcher16_checksum("\001\002") }),
},
{
.in = "",
.out = & ((const u16) { straightforward_fletcher16_checksum("") }),
},
{
.in = "a",
.out = & ((const u16) { straightforward_fletcher16_checksum("a") }),
},
{
.in = "abcd",
.out = & ((const u16) { straightforward_fletcher16_checksum("abcd") }),
},
{
.in = "message digest",
.out = & ((const u16) { straightforward_fletcher16_checksum("message digest") }),
},
{
.in = "abcdefghijklmnopqrstuvwxyz",
.out = & ((const u16) { straightforward_fletcher16_checksum("abcdefghijklmnopqrstuvwxyz") }),
},
{
.in = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
.out = & ((const u16) { straightforward_fletcher16_checksum("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") }),
},
{
.in = "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
.out = & ((const u16) { straightforward_fletcher16_checksum("12345678901234567890123456789012345678901234567890123456789012345678901234567890") }),
},
};
return bt_assert_batch(test_vectors, test_fletcher16_checksum, bt_fmt_str, bt_fmt_unsigned);
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_fletcher16_compute, "Fletcher-16 Compute Tests");
bt_test_suite(t_fletcher16_checksum, "Fletcher-16 Checksum Tests");
return bt_exit_value();
}
bird2-2.17.5/lib/flowspec.c 0000664 0000000 0000000 00000116167 15211753245 0015365 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Flow specification (RFC 8955)
*
* (c) 2016 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
/**
* DOC: Flow specification (flowspec)
*
* Flowspec are rules (RFC 8955) for firewalls disseminated using BGP protocol.
* The |flowspec.c| is a library for handling flowspec binary streams and
* flowspec data structures. You will find there functions for validation
* incoming flowspec binary streams, iterators for jumping over components,
* functions for handling a length and functions for formatting flowspec data
* structure into user-friendly text representation.
*
* In this library, you will find also flowspec builder. In |confbase.Y|, there
* are grammar's rules for parsing and building new flowspec data structure
* from BIRD's configuration files and from BIRD's command line interface.
* Finalize function will assemble final &net_addr_flow4 or &net_addr_flow6
* data structure.
*
* The data structures &net_addr_flow4 and &net_addr_flow6 are defined in
* |net.h| file. The attribute length is size of whole data structure plus
* binary stream representation of flowspec including a compressed encoded
* length of flowspec.
*
* Sometimes in code, it is used expression flowspec type, it should mean
* flowspec component type.
*/
#include
#include "nest/bird.h"
#include "lib/flowspec.h"
#include "conf/conf.h"
static const char* flow4_type_str[] = {
[FLOW_TYPE_DST_PREFIX] = "dst",
[FLOW_TYPE_SRC_PREFIX] = "src",
[FLOW_TYPE_IP_PROTOCOL] = "proto",
[FLOW_TYPE_PORT] = "port",
[FLOW_TYPE_DST_PORT] = "dport",
[FLOW_TYPE_SRC_PORT] = "sport",
[FLOW_TYPE_ICMP_TYPE] = "icmp type",
[FLOW_TYPE_ICMP_CODE] = "icmp code",
[FLOW_TYPE_TCP_FLAGS] = "tcp flags",
[FLOW_TYPE_PACKET_LENGTH] = "length",
[FLOW_TYPE_DSCP] = "dscp",
[FLOW_TYPE_FRAGMENT] = "fragment"
};
static const char* flow6_type_str[] = {
[FLOW_TYPE_DST_PREFIX] = "dst",
[FLOW_TYPE_SRC_PREFIX] = "src",
[FLOW_TYPE_NEXT_HEADER] = "next header",
[FLOW_TYPE_PORT] = "port",
[FLOW_TYPE_DST_PORT] = "dport",
[FLOW_TYPE_SRC_PORT] = "sport",
[FLOW_TYPE_ICMP_TYPE] = "icmp type",
[FLOW_TYPE_ICMP_CODE] = "icmp code",
[FLOW_TYPE_TCP_FLAGS] = "tcp flags",
[FLOW_TYPE_PACKET_LENGTH] = "length",
[FLOW_TYPE_DSCP] = "dscp",
[FLOW_TYPE_FRAGMENT] = "fragment",
[FLOW_TYPE_LABEL] = "label"
};
/**
* flow_type_str - get stringified flowspec name of component
* @type: flowspec component type
* @ipv6: IPv4/IPv6 decide flag, use zero for IPv4 and one for IPv6
*
* This function returns flowspec name of component @type in string.
*/
const char *
flow_type_str(enum flow_type type, int ipv6)
{
return ipv6 ? flow6_type_str[type] : flow4_type_str[type];
}
/*
* Length
*/
/**
* flow_write_length - write compressed length value
* @data: destination buffer to write
* @len: the value of the length (0 to 0xfff) for writing
*
* This function writes appropriate as (1- or 2-bytes) the value of @len into
* buffer @data. The function returns number of written bytes, thus 1 or 2 bytes.
*/
uint
flow_write_length(byte *data, u16 len)
{
if (len >= 0xf0)
{
put_u16(data, len | 0xf000);
return 2;
}
*data = len;
return 1;
}
inline static uint
get_value_length(const byte *op)
{
return (1 << ((*op & 0x30) >> 4));
}
/*
* Flowspec iterators
*/
static inline u8 num_op(const byte *op) { return (*op & 0x07); }
static inline int isset_and(const byte *op) { return ((*op & 0x40) == 0x40); }
static inline int isset_end(const byte *op) { return ((*op & 0x80) == 0x80); }
static const byte *
flow_first_part(const byte *data)
{
if (!data || flow_read_length(data) == 0)
return NULL;
/* It is allowed to encode the value of length less then 240 into 2-bytes too */
if ((data[0] & 0xf0) == 0xf0)
return data + 2;
return data + 1;
}
/**
* flow4_first_part - get position of the first flowspec component
* @f: flowspec data structure &net_addr_flow4
*
* This function return a position to the beginning of the first flowspec
* component in IPv4 flowspec @f.
*/
inline const byte *
flow4_first_part(const net_addr_flow4 *f)
{
return f ? flow_first_part(f->data) : NULL;
}
/**
* flow6_first_part - get position of the first flowspec component
* @f: flowspec data structure &net_addr_flow6
*
* This function return a position to the beginning of the first flowspec
* component in IPv6 flowspec @f.
*/
inline const byte *
flow6_first_part(const net_addr_flow6 *f)
{
return f ? flow_first_part(f->data) : NULL;
}
static const byte *
flow_next_part(const byte *pos, const byte *end, int ipv6)
{
switch (*pos++)
{
case FLOW_TYPE_DST_PREFIX:
case FLOW_TYPE_SRC_PREFIX:
{
uint pxlen = *pos++;
uint offset = ipv6 ? *pos++ : 0;
pos += BYTES(pxlen - offset);
break;
}
case FLOW_TYPE_IP_PROTOCOL: /* == FLOW_TYPE_NEXT_HEADER */
case FLOW_TYPE_PORT:
case FLOW_TYPE_DST_PORT:
case FLOW_TYPE_SRC_PORT:
case FLOW_TYPE_ICMP_TYPE:
case FLOW_TYPE_ICMP_CODE:
case FLOW_TYPE_TCP_FLAGS:
case FLOW_TYPE_PACKET_LENGTH:
case FLOW_TYPE_DSCP:
case FLOW_TYPE_FRAGMENT:
case FLOW_TYPE_LABEL:
{
/* Is this the end of list operator-value pair? */
uint last = 0;
while (!last)
{
last = isset_end(pos);
/* Value length of operator */
uint len = get_value_length(pos);
pos += 1+len;
}
break;
}
default:
return NULL;
}
return (pos < end) ? pos : NULL;
}
/**
* flow4_next_part - an iterator over flowspec components in flowspec binary stream
* @pos: the beginning of a previous or the first component in flowspec binary
* stream
* @end: the last valid byte in scanned flowspec binary stream
*
* This function returns a position to the beginning of the next component
* (to a component type byte) in flowspec binary stream or %NULL for the end.
*/
inline const byte *
flow4_next_part(const byte *pos, const byte *end)
{
return flow_next_part(pos, end, 0);
}
/**
* flow6_next_part - an iterator over flowspec components in flowspec binary stream
* @pos: the beginning of a previous or the first component in flowspec binary
* stream
* @end: the last valid byte in scanned flowspec binary stream
*
* This function returns a position to the beginning of the next component
* (to a component type byte) in flowspec binary stream or %NULL for the end.
*/
inline const byte *
flow6_next_part(const byte *pos, const byte *end)
{
return flow_next_part(pos, end, 1);
}
static const byte *
flow_get_part(const byte *data, uint dlen, uint type, int ipv6)
{
const byte *part;
for (part = flow_first_part(data);
part && (part[0] <= type);
part = flow_next_part(part, data+dlen, ipv6))
if (part[0] == type)
return part;
return NULL;
}
const byte *
flow4_get_part(const net_addr_flow4 *f, uint type)
{
return flow_get_part(f->data, f->length - sizeof(net_addr_flow4), type, 0);
}
const byte *
flow6_get_part(const net_addr_flow6 *f, uint type)
{
return flow_get_part(f->data, f->length - sizeof(net_addr_flow6), type, 1);
}
/*
* Flowspec accessors
*/
static inline ip4_addr
flow_read_ip4(const byte *px, uint pxlen)
{
ip4_addr ip = IP4_NONE;
memcpy(&ip, px, BYTES(pxlen));
return ip4_ntoh(ip);
}
ip4_addr
flow_read_ip4_part(const byte *part)
{
return flow_read_ip4(part + 2, part[1]);
}
static inline ip6_addr
flow_read_ip6(const byte *px, uint pxlen, uint pxoffset)
{
ip6_addr ip = IP6_NONE;
memcpy(&ip, px, BYTES(pxlen - pxoffset));
return ip6_shift_right(ip6_ntoh(ip), pxoffset);
}
ip6_addr
flow_read_ip6_part(const byte *part)
{
return flow_read_ip6(part + 3, part[1], part[2]);
}
static uint
get_value(const byte *val, u8 len)
{
switch (len)
{
case 1: return *val;
case 2: return get_u16(val);
case 4: return get_u32(val);
// No component may have length 8
// case 8: return get_u64(val);
}
return 0;
}
/*
* Flowspec validation
*/
static const char* flow_validated_state_str_[] = {
[FLOW_ST_UNKNOWN_COMPONENT] = "Unknown component",
[FLOW_ST_VALID] = "Valid",
[FLOW_ST_NOT_COMPLETE] = "Not complete",
[FLOW_ST_EXCEED_MAX_PREFIX_LENGTH] = "Exceed maximal prefix length",
[FLOW_ST_EXCEED_MAX_PREFIX_OFFSET] = "Exceed maximal prefix offset",
[FLOW_ST_EXCEED_MAX_VALUE_LENGTH] = "Exceed maximal value length",
[FLOW_ST_BAD_TYPE_ORDER] = "Bad component order",
[FLOW_ST_NONZERO_PADDING] = "Nonzero prefix padding",
[FLOW_ST_FIRST_AND_BIT_SET] = "The first AND-bit is set",
[FLOW_ST_ZERO_BIT_SET] = "Zero-bit is set",
[FLOW_ST_INVALID_TCP_FLAGS] = "Invalid TCP flags bitmask operand",
[FLOW_ST_INVALID_FRAGMENT] = "Invalid fragment bitmask operand",
};
/**
* flow_validated_state_str - return a textual description of validation process
* @code: validation result
*
* This function return well described validation state in string.
*/
const char *
flow_validated_state_str(enum flow_validated_state code)
{
return flow_validated_state_str_[code];
}
/* Maximum length of value fields, as mandated by RFC 8955 */
static const u8 flow_max_value_length[FLOW_TYPE_MAX] = {
[FLOW_TYPE_TCP_FLAGS] = 2,
[FLOW_TYPE_DSCP] = 1,
[FLOW_TYPE_FRAGMENT] = 1,
};
/* Maximum valid numeric values (in bytes), semantically */
static const u8 flow_max_valid_value[FLOW_TYPE_MAX] = {
[FLOW_TYPE_IP_PROTOCOL] = 1,
[FLOW_TYPE_PORT] = 2,
[FLOW_TYPE_DST_PORT] = 2,
[FLOW_TYPE_SRC_PORT] = 2,
[FLOW_TYPE_ICMP_TYPE] = 1,
[FLOW_TYPE_ICMP_CODE] = 1,
[FLOW_TYPE_PACKET_LENGTH] = 2,
[FLOW_TYPE_DSCP] = 1,
[FLOW_TYPE_LABEL] = 4,
};
/**
* flow_check_cf_bitmask_arg - check value/bitmask part of flowspec component
* @fb: flow builder instance
* @neg: negation operand
* @val: value from value/mask pair
* @mask: bitmap mask from value/mask pair
*
* This function checks value/bitmask pair. If some problem will appear, the
* function calls cf_error() function with a textual description of reason
* to failing of validation.
*/
void
flow_check_cf_bitmask_arg(struct flow_builder *fb, u8 neg, u32 val, u32 mask)
{
if (neg && !(val == 0 || val == mask))
cf_error("For negation, value must be zero or bitmask");
if ((fb->this_type == FLOW_TYPE_TCP_FLAGS) && (mask & ~0xfff))
cf_error("Invalid mask 0x%x, must not exceed 0xfff", mask);
u32 valid = fb->ipv6 ? 0x0e : 0x0f;
if ((fb->this_type == FLOW_TYPE_FRAGMENT) && (mask & ~valid))
cf_error("Invalid mask 0x%x, must not exceed 0x%x", mask, valid);
if (val & ~mask)
cf_error("Value 0x%x outside bitmask 0x%x", val, mask);
}
/**
* flow_check_cf_numeric_arg - check numeric argument of flowspec component
* @fb: flow builder instance
* @val: value
*
* This function checks the value of numeric argument to see whether it is in
* the range of component's type. If some problem will appear, the function
* calls cf_error() function with a textual description of reason to failing of
* validation.
*/
void
flow_check_cf_numeric_arg(struct flow_builder *fb, uint val)
{
enum flow_type t = fb->this_type;
uint max = flow_max_valid_value[t];
if (t == FLOW_TYPE_DSCP && val > 0x3f)
cf_error("%s value %u out of range (0-63)", flow_type_str(t, fb->ipv6), val);
if (max == 1 && (val > 0xff))
cf_error("%s value %u out of range (0-255)", flow_type_str(t, fb->ipv6), val);
if (max == 2 && (val > 0xffff))
cf_error("%s value %u out of range (0-65535)", flow_type_str(t, fb->ipv6), val);
}
/* Bitmask of padding bits in last byte of prefix */
static inline u8
flow_padding(uint n)
{
ASSUME(n % 8 != 0);
return (1 << (8 - n % 8)) - 1;
}
static enum flow_validated_state
flow_decode(byte *nlri, uint length, bool ipv6)
{
enum flow_type type = 0;
byte *pos = nlri;
byte *end = nlri + length;
while (pos < end)
{
/* Check increasing type ordering */
if (*pos <= type)
return FLOW_ST_BAD_TYPE_ORDER;
type = *pos++;
switch (type)
{
case FLOW_TYPE_DST_PREFIX:
case FLOW_TYPE_SRC_PREFIX:
{
uint pxlen, offset = 0;
if (!ipv6)
{
if (pos + 1 > end)
return FLOW_ST_NOT_COMPLETE;
pxlen = *pos++;
if (pxlen > IP4_MAX_PREFIX_LENGTH)
return FLOW_ST_EXCEED_MAX_PREFIX_LENGTH;
}
else
{
if (pos + 2 > end)
return FLOW_ST_NOT_COMPLETE;
pxlen = *pos++;
offset = *pos++;
if (pxlen > IP6_MAX_PREFIX_LENGTH)
return FLOW_ST_EXCEED_MAX_PREFIX_LENGTH;
if (offset > pxlen)
return FLOW_ST_EXCEED_MAX_PREFIX_OFFSET;
}
uint bits = pxlen - offset;
pos += BYTES(bits);
if (pos > end)
return FLOW_ST_NOT_COMPLETE;
/* Padding bits in the last byte MUST be 0 */
if (bits % 8)
pos[-1] &= ~flow_padding(bits);
break;
}
case FLOW_TYPE_LABEL:
if (!ipv6)
return FLOW_ST_UNKNOWN_COMPONENT;
/* fall through */
case FLOW_TYPE_IP_PROTOCOL: /* == FLOW_TYPE_NEXT_HEADER */
case FLOW_TYPE_PORT:
case FLOW_TYPE_DST_PORT:
case FLOW_TYPE_SRC_PORT:
case FLOW_TYPE_ICMP_TYPE:
case FLOW_TYPE_ICMP_CODE:
case FLOW_TYPE_TCP_FLAGS:
case FLOW_TYPE_PACKET_LENGTH:
case FLOW_TYPE_DSCP:
case FLOW_TYPE_FRAGMENT:
{
/*
* 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
* +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
* | e | a | len | 0 |lt |gt |eq | | e | a | len | 0 | 0 |not| m |
* +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
*
* Numeric operator Bitmask operator
*/
bool first = true;
bool last = false;
while (!last)
{
if (pos + 1 > end)
return FLOW_ST_NOT_COMPLETE;
uint len = get_value_length(pos);
/* Some component values MUST be encoded with limited length */
uint maxlen = flow_max_value_length[type];
if (maxlen && (len > maxlen))
return FLOW_ST_EXCEED_MAX_VALUE_LENGTH;
if (pos + 1 + len > end)
return FLOW_ST_NOT_COMPLETE;
/* In first operator of sequence, AND bit ... MUST be ignored during decoding */
if (first)
pos[0] &= ~0x40;
/* Zero field MUST be set to 0 on encoding and MUST be ignored during decoding */
pos[0] &= ~0x08;
/* Bitmask operator has additional zero field */
if (type == FLOW_TYPE_TCP_FLAGS || type == FLOW_TYPE_FRAGMENT)
pos[0] &= ~0x04;
/* Zero fields in highest nibble of TCP Flags bitmask operand */
if ((type == FLOW_TYPE_TCP_FLAGS) && (len == 2))
pos[1] &= ~0xf0;
/* Zero fields in fragment bitmask operand */
if ((type == FLOW_TYPE_FRAGMENT) && (len == 1))
pos[1] &= ipv6 ? ~0xf1 : ~0xf0;
/* Move to next operator */
first = false;
last = isset_end(pos);
pos += 1+len;
}
break;
}
default:
return FLOW_ST_UNKNOWN_COMPONENT;
}
}
if (pos != end)
return FLOW_ST_NOT_COMPLETE;
return FLOW_ST_VALID;
}
/**
* flow4_decode - decode incoming BGP IPv4 flowspec data stream
* @nlri: flowspec data stream without length header
* @len: length of @nlri
*
* This function checks syntatic correctness of binary flowspec. It returns
* %FLOW_ST_VALID, or some other %FLOW_ST_xxx state if the NLRI is malformed.
* If the NLRI is valid but not normalized (e.g. some zero bits are set), the
* flow4_decode() modify the datastream to normalize it.
*/
inline enum flow_validated_state
flow4_decode(byte *nlri, uint len)
{
return flow_decode(nlri, len, false);
}
/**
* flow6_decode - decode incoming BGP IPv6 flowspec data stream
* @nlri: flowspec data stream without length header
* @len: length of @nlri
*
* This function checks syntatic correctness of binary flowspec. It returns
* %FLOW_ST_VALID, or some other %FLOW_ST_xxx state if the NLRI is malformed.
* If the NLRI is valid but not normalized (e.g. some zero bits are set), the
* flow6_decode() modify the datastream to normalize it.
*/
inline enum flow_validated_state
flow6_decode(byte *nlri, uint len)
{
return flow_decode(nlri, len, true);
}
static enum flow_validated_state
flow_validate(const byte *nlri, uint len, bool ipv6)
{
enum flow_type type = 0;
const byte *pos = nlri;
const byte *end = nlri + len;
while (pos < end)
{
/* Check increasing type ordering */
if (*pos <= type)
return FLOW_ST_BAD_TYPE_ORDER;
type = *pos++;
switch (type)
{
case FLOW_TYPE_DST_PREFIX:
case FLOW_TYPE_SRC_PREFIX:
{
uint pxlen, offset = 0;
if (!ipv6)
{
if (pos + 1 > end)
return FLOW_ST_NOT_COMPLETE;
pxlen = *pos++;
if (pxlen > IP4_MAX_PREFIX_LENGTH)
return FLOW_ST_EXCEED_MAX_PREFIX_LENGTH;
}
else
{
if (pos + 2 > end)
return FLOW_ST_NOT_COMPLETE;
pxlen = *pos++;
offset = *pos++;
if (pxlen > IP6_MAX_PREFIX_LENGTH)
return FLOW_ST_EXCEED_MAX_PREFIX_LENGTH;
if (offset > pxlen)
return FLOW_ST_EXCEED_MAX_PREFIX_OFFSET;
}
uint bits = pxlen - offset;
pos += BYTES(bits);
if (pos > end)
return FLOW_ST_NOT_COMPLETE;
/* Padding bits in the last byte MUST be 0 */
if (bits % 8)
if (pos[-1] & flow_padding(bits))
return FLOW_ST_NONZERO_PADDING;
break;
}
case FLOW_TYPE_LABEL:
if (!ipv6)
return FLOW_ST_UNKNOWN_COMPONENT;
/* fall through */
case FLOW_TYPE_IP_PROTOCOL: /* == FLOW_TYPE_NEXT_HEADER */
case FLOW_TYPE_PORT:
case FLOW_TYPE_DST_PORT:
case FLOW_TYPE_SRC_PORT:
case FLOW_TYPE_ICMP_TYPE:
case FLOW_TYPE_ICMP_CODE:
case FLOW_TYPE_TCP_FLAGS:
case FLOW_TYPE_PACKET_LENGTH:
case FLOW_TYPE_DSCP:
case FLOW_TYPE_FRAGMENT:
{
/*
* 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
* +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
* | e | a | len | 0 |lt |gt |eq | | e | a | len | 0 | 0 |not| m |
* +---+---+---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+
*
* Numeric operator Bitmask operator
*/
bool first = true;
bool last = false;
while (!last)
{
if (pos + 1 > end)
return FLOW_ST_NOT_COMPLETE;
uint len = get_value_length(pos);
/* Some component values MUST be encoded with limited length */
uint maxlen = flow_max_value_length[type];
if (maxlen && (len > maxlen))
return FLOW_ST_EXCEED_MAX_VALUE_LENGTH;
if (pos + 1 + len > end)
return FLOW_ST_NOT_COMPLETE;
/* In first operator of sequence, AND bit ... MUST be ignored during decoding */
if (first && isset_and(pos))
return FLOW_ST_FIRST_AND_BIT_SET;
/* Zero field MUST be set to 0 on encoding and MUST be ignored during decoding */
if (pos[0] & 0x08)
return FLOW_ST_ZERO_BIT_SET;
/* Bitmask operator has additional zero field */
if (type == FLOW_TYPE_TCP_FLAGS || type == FLOW_TYPE_FRAGMENT)
if (pos[0] & 0x04)
return FLOW_ST_ZERO_BIT_SET;
/* Zero fields in highest nibble of TCP Flags bitmask operand */
if ((type == FLOW_TYPE_TCP_FLAGS) && (len == 2))
if (pos[1] & 0xf0)
return FLOW_ST_INVALID_TCP_FLAGS;
/* Zero fields in fragment bitmask operand */
if ((type == FLOW_TYPE_FRAGMENT) && (len == 1))
if (pos[1] & (ipv6 ? 0xf1 : 0xf0))
return FLOW_ST_INVALID_FRAGMENT;
/* Move to next operator */
first = false;
last = isset_end(pos);
pos += 1+len;
}
break;
}
default:
return FLOW_ST_UNKNOWN_COMPONENT;
}
}
if (pos != end)
return FLOW_ST_NOT_COMPLETE;
return FLOW_ST_VALID;
}
/**
* flow4_validate - check untrustworthy IPv4 flowspec data stream
* @nlri: flowspec data stream without length header
* @len: length of @nlri
*
* This function checks syntactic correctness of binary flowspec. It returns
* %FLOW_ST_VALID, or some other %FLOW_ST_xxx state if the NLRI is malformed
* or non-normalized.
*/
inline enum flow_validated_state
flow4_validate(const byte *nlri, uint len)
{
return flow_validate(nlri, len, false);
}
/**
* flow6_validate - check untrustworthy IPv6 flowspec data stream
* @nlri: flowspec binary stream without length header
* @len: length of @nlri
*
* This function checks syntactic correctness of binary flowspec. It returns
* %FLOW_ST_VALID, or some other %FLOW_ST_xxx state if the NLRI is malformed
* or non-normalized.
*/
inline enum flow_validated_state
flow6_validate(const byte *nlri, uint len)
{
return flow_validate(nlri, len, true);
}
/**
* flow4_validate_cf - validate flowspec data structure &net_addr_flow4 in parsing time
* @f: flowspec data structure &net_addr_flow4
*
* Check if @f is valid flowspec data structure. Can call cf_error() function
* with a textual description of reason to failing of validation.
*/
void
flow4_validate_cf(net_addr_flow4 *f)
{
enum flow_validated_state r = flow4_validate(flow4_first_part(f), flow_read_length(f->data));
if (r != FLOW_ST_VALID)
cf_error("Invalid flow route: %s", flow_validated_state_str(r));
}
/**
* flow6_validate_cf - validate flowspec data structure &net_addr_flow6 in parsing time
* @f: flowspec data structure &net_addr_flow6
*
* Check if @f is valid flowspec data structure. Can call cf_error() function
* with a textual description of reason to failing of validation.
*/
void
flow6_validate_cf(net_addr_flow6 *f)
{
enum flow_validated_state r = flow6_validate(flow6_first_part(f), flow_read_length(f->data));
if (r != FLOW_ST_VALID)
cf_error("Invalid flow route: %s", flow_validated_state_str(r));
}
/*
* Flowspec Builder
*/
/**
* flow_builder_init - constructor for flowspec builder instance
* @pool: memory pool
*
* This function prepares flowspec builder instance using memory pool @pool.
*/
struct flow_builder *
flow_builder_init(pool *pool)
{
struct flow_builder *fb = mb_allocz(pool, sizeof(struct flow_builder));
BUFFER_INIT(fb->data, pool, 4);
return fb;
}
static int
is_stackable_type(enum flow_type type)
{
switch (type)
{
case FLOW_TYPE_IP_PROTOCOL:
case FLOW_TYPE_PORT:
case FLOW_TYPE_DST_PORT:
case FLOW_TYPE_SRC_PORT:
case FLOW_TYPE_ICMP_TYPE:
case FLOW_TYPE_ICMP_CODE:
case FLOW_TYPE_TCP_FLAGS:
case FLOW_TYPE_PACKET_LENGTH:
case FLOW_TYPE_DSCP:
case FLOW_TYPE_FRAGMENT:
case FLOW_TYPE_LABEL:
return 1;
default:
/* The unknown components are not stack-able in default */
return 0;
}
}
static int
builder_add_prepare(struct flow_builder *fb)
{
if (fb->parts[fb->this_type].length)
{
if (fb->last_type != fb->this_type)
return 0;
if (!is_stackable_type(fb->this_type))
return 0;
}
else
{
fb->parts[fb->this_type].offset = fb->data.used;
}
return 1;
}
static void
builder_add_finish(struct flow_builder *fb)
{
fb->parts[fb->this_type].length = fb->data.used - fb->parts[fb->this_type].offset;
flow_builder_set_type(fb, fb->this_type);
}
static void
push_pfx_to_buffer(struct flow_builder *fb, u8 pxlen_bytes, byte *ip)
{
for (int i = 0; i < pxlen_bytes; i++)
BUFFER_PUSH(fb->data) = *ip++;
}
/**
* flow_builder4_add_pfx - add IPv4 prefix
* @fb: flowspec builder instance
* @n4: net address of type IPv4
*
* This function add IPv4 prefix into flowspec builder instance.
*/
int
flow_builder4_add_pfx(struct flow_builder *fb, const net_addr_ip4 *n4)
{
if (!builder_add_prepare(fb))
return 0;
ip4_addr ip4 = ip4_hton(n4->prefix);
BUFFER_PUSH(fb->data) = fb->this_type;
BUFFER_PUSH(fb->data) = n4->pxlen;
push_pfx_to_buffer(fb, BYTES(n4->pxlen), (byte *) &ip4);
builder_add_finish(fb);
return 1;
}
/**
* flow_builder6_add_pfx - add IPv6 prefix
* @fb: flowspec builder instance
* @n6: net address of type IPv4
* @pxoffset: prefix offset for @n6
*
* This function add IPv4 prefix into flowspec builder instance. This function
* should return 1 for successful adding, otherwise returns %0.
*/
int
flow_builder6_add_pfx(struct flow_builder *fb, const net_addr_ip6 *n6, u32 pxoffset)
{
if (!builder_add_prepare(fb))
return 0;
ip6_addr ip6 = ip6_hton(ip6_shift_left(n6->prefix, pxoffset));
BUFFER_PUSH(fb->data) = fb->this_type;
BUFFER_PUSH(fb->data) = n6->pxlen;
BUFFER_PUSH(fb->data) = pxoffset;
push_pfx_to_buffer(fb, BYTES(n6->pxlen - pxoffset), ((byte *) &ip6));
builder_add_finish(fb);
return 1;
}
/**
* flow_builder_add_op_val - add operator/value pair
* @fb: flowspec builder instance
* @op: operator
* @value: value
*
* This function add operator/value pair as a part of a flowspec component. It
* is required to set appropriate flowspec component type using function
* flow_builder_set_type(). This function should return 1 for successful
* adding, otherwise returns 0.
*/
int
flow_builder_add_op_val(struct flow_builder *fb, byte op, u32 value)
{
if (!builder_add_prepare(fb))
return 0;
if (fb->this_type == fb->last_type)
{
/* Remove the end-bit from last operand-value pair of the component */
fb->data.data[fb->last_op_offset] &= 0x7f;
}
else
{
BUFFER_PUSH(fb->data) = fb->this_type;
}
fb->last_op_offset = fb->data.used;
/* Set the end-bit for operand-value pair of the component */
op |= 0x80;
/* Label component values SHOULD be encoded as 4-octet quantities */
if ((value > 0xffff) || (fb->this_type == FLOW_TYPE_LABEL))
{
BUFFER_PUSH(fb->data) = op | 0x20;
put_u32(BUFFER_INC(fb->data, 4), value);
}
else if (value > 0xff)
{
BUFFER_PUSH(fb->data) = op | 0x10;
put_u16(BUFFER_INC(fb->data, 2), value);
}
else
{
BUFFER_PUSH(fb->data) = op;
BUFFER_PUSH(fb->data) = (u8) value;
}
builder_add_finish(fb);
return 1;
}
/**
* flow_builder_add_val_mask - add value/bitmask pair
* @fb: flowspec builder instance
* @op: operator
* @value: value
* @mask: bitmask
*
* It is required to set appropriate flowspec component type using function
* flow_builder_set_type(). Note that for negation, value must be zero or equal
* to bitmask.
*/
int
flow_builder_add_val_mask(struct flow_builder *fb, byte op, u32 value, u32 mask)
{
u32 a = value & mask;
u32 b = ~value & mask;
if (a)
{
flow_builder_add_op_val(fb, op ^ 0x01, a);
op |= FLOW_OP_AND;
}
if (b)
flow_builder_add_op_val(fb, op ^ 0x02, b);
return 1;
}
/**
* flow_builder_set_type - set type of next flowspec component
* @fb: flowspec builder instance
* @type: flowspec component type
*
* This function sets type of next flowspec component. It is necessary to call
* this function before each changing of adding flowspec component.
*/
void
flow_builder_set_type(struct flow_builder *fb, enum flow_type type)
{
fb->last_type = fb->this_type;
fb->this_type = type;
}
static void
builder_write_parts(struct flow_builder *fb, byte *buf)
{
for (int i = 1; i < FLOW_TYPE_MAX; i++)
{
if (fb->parts[i].length)
{
memcpy(buf, fb->data.data + fb->parts[i].offset, fb->parts[i].length);
buf += fb->parts[i].length;
}
}
}
/**
* flow_builder4_finalize - assemble final flowspec data structure &net_addr_flow4
* @fb: flowspec builder instance
* @lpool: linear memory pool
*
* This function returns final flowspec data structure &net_addr_flow4 allocated
* onto @lpool linear memory pool.
*/
net_addr_flow4 *
flow_builder4_finalize(struct flow_builder *fb, linpool *lpool)
{
uint data_len = fb->data.used + (fb->data.used < 0xf0 ? 1 : 2);
net_addr_flow4 *f = lp_alloc(lpool, sizeof(struct net_addr_flow4) + data_len);
ip4_addr prefix = IP4_NONE;
uint pxlen = 0;
if (fb->parts[FLOW_TYPE_DST_PREFIX].length)
{
byte *part = fb->data.data + fb->parts[FLOW_TYPE_DST_PREFIX].offset;
prefix = flow_read_ip4_part(part);
pxlen = flow_read_pxlen(part);
}
*f = NET_ADDR_FLOW4(prefix, pxlen, data_len);
builder_write_parts(fb, f->data + flow_write_length(f->data, fb->data.used));
return f;
}
/**
* flow_builder6_finalize - assemble final flowspec data structure &net_addr_flow6
* @fb: flowspec builder instance
* @lpool: linear memory pool for allocation of
*
* This function returns final flowspec data structure &net_addr_flow6 allocated
* onto @lpool linear memory pool.
*/
net_addr_flow6 *
flow_builder6_finalize(struct flow_builder *fb, linpool *lpool)
{
uint data_len = fb->data.used + (fb->data.used < 0xf0 ? 1 : 2);
net_addr_flow6 *n = lp_alloc(lpool, sizeof(net_addr_flow6) + data_len);
ip6_addr prefix = IP6_NONE;
uint pxlen = 0;
if (fb->parts[FLOW_TYPE_DST_PREFIX].length)
{
byte *part = fb->data.data + fb->parts[FLOW_TYPE_DST_PREFIX].offset;
prefix = flow_read_ip6_part(part);
pxlen = flow_read_pxlen(part);
}
*n = NET_ADDR_FLOW6(prefix, pxlen, data_len);
builder_write_parts(fb, n->data + flow_write_length(n->data, fb->data.used));
return n;
}
/**
* flow_builder_clear - flush flowspec builder instance for another flowspec creation
* @fb: flowspec builder instance
*
* This function flushes all data from builder but it maintains pre-allocated
* buffer space.
*/
void
flow_builder_clear(struct flow_builder *fb)
{
BUFFER(byte) data;
BUFFER_FLUSH(fb->data);
BUFFER_SHALLOW_COPY(data, fb->data);
memset(fb, 0, sizeof(struct flow_builder));
BUFFER_SHALLOW_COPY(fb->data, data);
}
/*
* Flowspec explication
*/
/**
* flow_explicate_buffer_size - return buffer size needed for explication
* @part: flowspec part to explicate
*
* This function computes and returns a required buffer size that has to be
* preallocated and passed to flow_explicate_part(). Note that it returns number
* of records, not number of bytes.
*/
uint
flow_explicate_buffer_size(const byte *part)
{
const byte *pos = part + 1;
uint first = 1;
uint len = 0;
while (1)
{
/*
* Conjunction sequences represent (mostly) one interval, do not count
* additional AND-ed operators. Ignore AND bit for the first operator.
*/
if (!isset_and(pos) || first)
len++;
/*
* The exception is that NEQ operator adds one more interval (by splitting
* one of intervals defined by other operators).
*/
if (num_op(pos) == FLOW_OP_NEQ)
len++;
if (isset_end(pos))
break;
first = 0;
pos = pos + 1 + get_value_length(pos);
}
return len;
}
static int flow_uint_cmp(const void *p1, const void *p2)
{ return uint_cmp(* (const uint *) p1, * (const uint *) p2); }
/**
* flow_explicate_part - compute explicit interval list from flowspec part
* @part: flowspec part to explicate
* @buf: pre-allocated buffer for result
*
* This function analyzes a flowspec part with numeric operators (e.g. port) and
* computes an explicit interval list of allowed values. The result is written
* to provided buffer @buf, which must have space for enough interval records as
* returned by flow_explicate_buffer_size(). The intervals are represented as
* two-sized arrays of lower and upper bound, both including. The return value
* is the number of intervals in the buffer.
*/
uint
flow_explicate_part(const byte *part, uint (*buf)[2])
{
/*
* The Flowspec numeric expression is almost in DNF form (as union of
* intersections), where each operator represents one elementary interval.
* The exception is NEQ operator, which represents union of two intervals,
* separated by the excluded value. Naive algorithm would be like:
*
* A <- empty set of intervals
* for each sequence of operators in conjunction
* {
* B <- empty set of intervals
* for each operator in the current sequence
* {
* C <- one or two elementary intervals from the current operator
* B <- intersection(B, C)
* }
* A <- union(A, B)
* }
*
* We simplify this by representing B just as one interval (vars lo, hi) and a
* list of excluded values. After the inner cycle, we expand that to a proper
* list of intervals that is added to existing ones from previous cycles.
* Finally, we sort and merge intersecting or touching intervals in A.
*
* The code handles up to 32bit values in numeric operators. Intervals are
* represented by lower and upper bound, both including. Intermediate values
* use s64 to simplify representation of excluding bounds for 0 and UINT32_MAX.
*/
const byte *pos = part + 1;
const s64 max = 0xffffffff;
s64 lo = 0;
s64 hi = max;
uint num = 0;
uint neqs = 0;
/* Step 1 - convert conjunction sequences to lists of intervals */
while (1)
{
uint op = num_op(pos);
uint len = get_value_length(pos);
s64 val = get_value(pos + 1, len);
uint last = isset_end(pos);
const byte *next_pos = pos + 1 + len;
/* Get a new interval from this operator */
s64 nlo = (op & FLOW_OP_LT) ? 0 : ((op & FLOW_OP_EQ) ? val : (val + 1));
s64 nhi = (op & FLOW_OP_GT) ? max : ((op & FLOW_OP_EQ) ? val : (val - 1));
/* Restrict current interval */
lo = MAX(lo, nlo);
hi = MIN(hi, nhi);
/* Store NEQs for later */
if (op == FLOW_OP_NEQ)
{
buf[num + neqs][0] = val;
buf[num + neqs][1] = 0;
neqs++;
}
/* End of conjunction sequence */
if (last || !isset_and(next_pos))
{
if (neqs)
{
/* Sort stored NEQs */
qsort(buf + num, neqs, 2 * sizeof(uint), flow_uint_cmp);
/* Dump stored NEQs as intervals */
uint base = num;
for (uint i = 0; i < neqs; i++)
{
val = buf[base + i][0];
if ((val < lo) || (val > hi))
continue;
if (val == lo)
{ lo++; continue; }
if (val == hi)
{ hi--; continue; }
buf[num][0] = lo;
buf[num][1] = val - 1;
num++;
lo = val + 1;
}
neqs = 0;
}
/* Save final interval */
if (lo <= hi)
{
buf[num][0] = lo;
buf[num][1] = hi;
num++;
}
lo = 0;
hi = max;
}
if (last)
break;
pos = next_pos;
}
if (num < 2)
return num;
/* Step 2 - Sort and merge list of intervals */
qsort(buf, num, 2 * sizeof(uint), flow_uint_cmp);
uint i = 0, j = 0;
while (i < num)
{
lo = buf[i][0];
hi = buf[i][1];
i++;
/* If intervals are intersecting or just touching, merge them */
while ((i < num) && ((s64) buf[i][0] <= (hi + 1)))
{
hi = MAX(hi, (s64) buf[i][1]);
i++;
}
buf[j][0] = lo;
buf[j][1] = hi;
j++;
}
return j;
}
/*
* Net Formatting
*/
/* Flowspec operators for [op, value]+ pairs */
static const char *
num_op_str(const byte *op)
{
switch (*op & 0x07)
{
case FLOW_OP_TRUE: return "true";
case FLOW_OP_EQ: return "=";
case FLOW_OP_GT: return ">";
case FLOW_OP_GEQ: return ">=";
case FLOW_OP_LT: return "<";
case FLOW_OP_LEQ: return "<=";
case FLOW_OP_NEQ: return "!=";
case FLOW_OP_FALSE: return "false";
}
return NULL;
}
static const char *
fragment_val_str(u8 val)
{
switch (val)
{
case 1: return "dont_fragment";
case 2: return "is_fragment";
case 4: return "first_fragment";
case 8: return "last_fragment";
}
return "???";
}
static void
net_format_flow_ip(buffer *b, const byte *part, int ipv6)
{
uint pxlen = part[1];
if (ipv6)
{
uint pxoffset = part[2];
if (pxoffset)
buffer_print(b, "%I6/%u offset %u; ", flow_read_ip6_part(part), pxlen, pxoffset);
else
buffer_print(b, "%I6/%u; ", flow_read_ip6_part(part), pxlen);
}
else
{
buffer_print(b, "%I4/%u; ", flow_read_ip4_part(part), pxlen);
}
}
static void
net_format_flow_num(buffer *b, const byte *part)
{
const byte *last_op = NULL;
const byte *op = part+1;
uint val;
uint len;
uint first = 1;
while (1)
{
if (!first)
{
/* XXX: I don't like this so complicated if-tree */
if (!isset_and(op) &&
((num_op( op) == FLOW_OP_EQ) || (num_op( op) == FLOW_OP_GEQ)) &&
((num_op(last_op) == FLOW_OP_EQ) || (num_op(last_op) == FLOW_OP_LEQ)))
{
b->pos--; /* Remove last char (it is a space) */
buffer_puts(b, ",");
}
else
{
buffer_puts(b, isset_and(op) ? "&& " : "|| ");
}
}
first = 0;
len = get_value_length(op);
val = get_value(op+1, len);
if (!isset_end(op) && !isset_and(op) && isset_and(op+1+len) &&
(num_op(op) == FLOW_OP_GEQ) && (num_op(op+1+len) == FLOW_OP_LEQ))
{
/* Display interval */
buffer_print(b, "%u..", val);
op += 1 + len;
len = get_value_length(op);
val = get_value(op+1, len);
buffer_print(b, "%u", val);
}
else if (num_op(op) == FLOW_OP_EQ)
{
buffer_print(b, "%u", val);
}
else
{
buffer_print(b, "%s %u", num_op_str(op), val);
}
if (isset_end(op))
{
buffer_puts(b, "; ");
break;
}
else
{
buffer_puts(b, " ");
}
last_op = op;
op += 1 + len;
}
}
static void
net_format_flow_bitmask(buffer *b, const byte *part)
{
const byte *op = part+1;
uint val;
uint len;
uint first = 1;
while (1)
{
if (!first)
buffer_puts(b, isset_and(op) ? "&& " : "|| ");
first = 0;
len = get_value_length(op);
val = get_value(op+1, len);
/*
* Not Match Show
* ------------------
* 0 0 !0/B
* 0 1 B/B
* 1 0 0/B
* 1 1 !B/B
*/
if ((*op & 0x3) == 0x3 || (*op & 0x3) == 0)
buffer_puts(b, "!");
if (*part == FLOW_TYPE_FRAGMENT && (val == 1 || val == 2 || val == 4 || val == 8))
buffer_print(b, "%s%s", ((*op & 0x1) ? "" : "!"), fragment_val_str(val));
else
buffer_print(b, "0x%x/0x%x", ((*op & 0x1) ? val : 0), val);
if (isset_end(op))
{
buffer_puts(b, "; ");
break;
}
else
{
buffer_puts(b, " ");
}
op += 1 + len;
}
}
static uint
net_format_flow(char *buf, uint blen, const byte *data, uint dlen, int ipv6)
{
buffer b = {
.start = buf,
.pos = buf,
.end = buf + blen,
};
const byte *part = flow_first_part(data);
*buf = 0;
if (ipv6)
buffer_puts(&b, "flow6 { ");
else
buffer_puts(&b, "flow4 { ");
while (part)
{
buffer_print(&b, "%s ", flow_type_str(*part, ipv6));
switch (*part)
{
case FLOW_TYPE_DST_PREFIX:
case FLOW_TYPE_SRC_PREFIX:
net_format_flow_ip(&b, part, ipv6);
break;
case FLOW_TYPE_IP_PROTOCOL: /* == FLOW_TYPE_NEXT_HEADER */
case FLOW_TYPE_PORT:
case FLOW_TYPE_DST_PORT:
case FLOW_TYPE_SRC_PORT:
case FLOW_TYPE_ICMP_TYPE:
case FLOW_TYPE_ICMP_CODE:
case FLOW_TYPE_PACKET_LENGTH:
case FLOW_TYPE_DSCP:
case FLOW_TYPE_LABEL:
net_format_flow_num(&b, part);
break;
case FLOW_TYPE_TCP_FLAGS:
case FLOW_TYPE_FRAGMENT:
net_format_flow_bitmask(&b, part);
break;
}
part = flow_next_part(part, data+dlen, ipv6);
}
buffer_puts(&b, "}");
if (b.pos == b.end)
{
b.pos = b.start + MIN(blen - 6, strlen(b.start));
buffer_puts(&b, " ...}");
}
return b.pos - b.start;
}
/**
* flow4_net_format - stringify flowspec data structure &net_addr_flow4
* @buf: pre-allocated buffer for writing a stringify net address flowspec
* @blen: free allocated space in @buf
* @f: flowspec data structure &net_addr_flow4 for stringify
*
* This function writes stringified @f into @buf. The function returns number
* of written chars. If final string is too large, the string will ends the with
* ' ...}' sequence and zero-terminator.
*/
uint
flow4_net_format(char *buf, uint blen, const net_addr_flow4 *f)
{
return net_format_flow(buf, blen, f->data, f->length - sizeof(net_addr_flow4), 0);
}
/**
* flow6_net_format - stringify flowspec data structure &net_addr_flow6
* @buf: pre-allocated buffer for writing a stringify net address flowspec
* @blen: free allocated space in @buf
* @f: flowspec data structure &net_addr_flow4 for stringify
*
* This function writes stringified @f into @buf. The function returns number
* of written chars. If final string is too large, the string will ends the with
* ' ...}' sequence and zero-terminator.
*/
uint
flow6_net_format(char *buf, uint blen, const net_addr_flow6 *f)
{
return net_format_flow(buf, blen, f->data, f->length - sizeof(net_addr_flow6), 1);
}
bird2-2.17.5/lib/flowspec.h 0000664 0000000 0000000 00000011535 15211753245 0015363 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Flow specification (RFC 8955)
*
* (c) 2016 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_FLOWSPEC_H_
#define _BIRD_FLOWSPEC_H_
#include "nest/bird.h"
#include "lib/buffer.h"
#include "lib/net.h"
/* Flow component operators */
#define FLOW_OP_FALSE 0x00 /* 0b000 */
#define FLOW_OP_EQ 0x01 /* 0b001 */
#define FLOW_OP_GT 0x02 /* 0b010 */
#define FLOW_OP_GEQ 0x03 /* 0b011 */
#define FLOW_OP_LT 0x04 /* 0b100 */
#define FLOW_OP_LEQ 0x05 /* 0b101 */
#define FLOW_OP_NEQ 0x06 /* 0b110 */
#define FLOW_OP_TRUE 0x07 /* 0b111 */
#define FLOW_OP_OR 0x00
#define FLOW_OP_AND 0x40
/* Types of components in flowspec */
enum flow_type {
FLOW_TYPE_DST_PREFIX = 1,
FLOW_TYPE_SRC_PREFIX = 2,
FLOW_TYPE_IP_PROTOCOL = 3,
FLOW_TYPE_NEXT_HEADER = 3, /* IPv6 */
FLOW_TYPE_PORT = 4,
FLOW_TYPE_DST_PORT = 5,
FLOW_TYPE_SRC_PORT = 6,
FLOW_TYPE_ICMP_TYPE = 7,
FLOW_TYPE_ICMP_CODE = 8,
FLOW_TYPE_TCP_FLAGS = 9,
FLOW_TYPE_PACKET_LENGTH = 10,
FLOW_TYPE_DSCP = 11, /* DiffServ Code Point */
FLOW_TYPE_FRAGMENT = 12,
FLOW_TYPE_LABEL = 13, /* IPv6 */
FLOW_TYPE_MAX
};
const char *flow_type_str(enum flow_type type, int ipv6);
/*
* Length
*/
uint flow_write_length(byte *data, u16 len);
static inline u16 flow_hdr_length(const byte *data)
{ return ((*data & 0xf0) == 0xf0) ? 2 : 1; }
static inline u16 flow_read_length(const byte *data)
{ return ((*data & 0xf0) == 0xf0) ? get_u16(data) & 0x0fff : *data; }
static inline u16 flow4_get_length(const net_addr_flow4 *f)
{ return f->length - sizeof(net_addr_flow4); }
static inline u16 flow6_get_length(const net_addr_flow6 *f)
{ return f->length - sizeof(net_addr_flow6); }
static inline void flow4_set_length(net_addr_flow4 *f, u16 len)
{ f->length = sizeof(net_addr_flow4) + flow_write_length(f->data, len) + len; }
static inline void flow6_set_length(net_addr_flow6 *f, u16 len)
{ f->length = sizeof(net_addr_flow6) + flow_write_length(f->data, len) + len; }
/*
* Iterators
*/
const byte *flow4_first_part(const net_addr_flow4 *f);
const byte *flow6_first_part(const net_addr_flow6 *f);
const byte *flow4_next_part(const byte *pos, const byte *end);
const byte *flow6_next_part(const byte *pos, const byte *end);
const byte *flow4_get_part(const net_addr_flow4 *f, uint type);
const byte *flow6_get_part(const net_addr_flow6 *f, uint type);
/*
* Flowspec accessors
*/
ip4_addr flow_read_ip4_part(const byte *part);
ip6_addr flow_read_ip6_part(const byte *part);
static inline int flow_read_pxlen(const byte *part) { return part[1]; }
/*
* Flowspec Builder
*/
/* A data structure for keep a state of flow builder */
struct flow_builder {
BUFFER_(byte) data;
enum flow_type this_type;
enum flow_type last_type;
u16 last_op_offset; /* Position of last operator in data.data */
int ipv6;
struct {
u16 offset; /* Beginning of a component */
u16 length; /* Length of a component */
} parts[FLOW_TYPE_MAX]; /* Indexing all components */
};
struct flow_builder *flow_builder_init(pool *pool);
void flow_builder_clear(struct flow_builder *fb);
void flow_builder_set_type(struct flow_builder *fb, enum flow_type p);
int flow_builder4_add_pfx(struct flow_builder *fb, const net_addr_ip4 *n4);
int flow_builder6_add_pfx(struct flow_builder *fb, const net_addr_ip6 *n6, u32 offset);
int flow_builder_add_op_val(struct flow_builder *fb, byte op, u32 value);
int flow_builder_add_val_mask(struct flow_builder *fb, byte op, u32 value, u32 mask);
net_addr_flow4 *flow_builder4_finalize(struct flow_builder *fb, linpool *lpool);
net_addr_flow6 *flow_builder6_finalize(struct flow_builder *fb, linpool *lpool);
/*
* Validation
*/
/* Results of validation Flow specification */
enum flow_validated_state {
FLOW_ST_UNKNOWN_COMPONENT,
FLOW_ST_VALID,
FLOW_ST_NOT_COMPLETE,
FLOW_ST_EXCEED_MAX_PREFIX_LENGTH,
FLOW_ST_EXCEED_MAX_PREFIX_OFFSET,
FLOW_ST_EXCEED_MAX_VALUE_LENGTH,
FLOW_ST_BAD_TYPE_ORDER,
FLOW_ST_NONZERO_PADDING,
FLOW_ST_FIRST_AND_BIT_SET,
FLOW_ST_ZERO_BIT_SET,
FLOW_ST_INVALID_TCP_FLAGS,
FLOW_ST_INVALID_FRAGMENT,
};
const char *flow_validated_state_str(enum flow_validated_state code);
enum flow_validated_state flow4_decode(byte *nlri, uint len);
enum flow_validated_state flow6_decode(byte *nlri, uint len);
enum flow_validated_state flow4_validate(const byte *nlri, uint len);
enum flow_validated_state flow6_validate(const byte *nlri, uint len);
void flow_check_cf_bitmask_arg(struct flow_builder *fb, u8 neg, u32 val, u32 mask);
void flow_check_cf_numeric_arg(struct flow_builder *fb, uint val);
void flow4_validate_cf(net_addr_flow4 *f);
void flow6_validate_cf(net_addr_flow6 *f);
/*
* Net Formatting
*/
uint flow4_net_format(char *buf, uint blen, const net_addr_flow4 *f);
uint flow6_net_format(char *buf, uint blen, const net_addr_flow6 *f);
#endif /* _BIRD_FLOWSPEC_H_ */
bird2-2.17.5/lib/flowspec_test.c 0000664 0000000 0000000 00000075563 15211753245 0016430 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Flow specification (RFC 8955) Tests
*
* (c) 2016 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "lib/flowspec.h"
#define NET_ADDR_FLOW4_(prefix,pxlen,nlri) \
({ \
uint _len = sizeof(nlri); \
net_addr_flow4 *_n = tmp_alloc(sizeof(net_addr_flow4) + _len); \
*_n = NET_ADDR_FLOW4(prefix, pxlen, _len); \
memcpy(_n->data, &(nlri), _len); \
if (_n->data[0] == 0) _n->data[0] = _len - 1; \
_n; \
})
#define NET_ADDR_FLOW4_NLRI(...) \
({ \
const byte _nlri[] = { __VA_ARGS__ }; \
NET_ADDR_FLOW4_(flow_read_ip4_part(_nlri + 1), _nlri[2], _nlri); \
})
#define NET_ADDR_FLOW6_(prefix,pxlen,nlri) \
({ \
uint _len = sizeof(nlri); \
net_addr_flow6 *_n = tmp_alloc(sizeof(net_addr_flow6) + _len); \
*_n = NET_ADDR_FLOW6(prefix, pxlen, _len); \
memcpy(_n->data, &(nlri), _len); \
if (_n->data[0] == 0) _n->data[0] = _len - 1; \
_n; \
})
#define NET_ADDR_FLOW6_NLRI(...) \
({ \
const byte _nlri[] = { __VA_ARGS__ }; \
NET_ADDR_FLOW6_(flow_read_ip6_part(_nlri + 1), _nlri[2], _nlri); \
})
static int
t_read_length(void)
{
byte data[] = { 0xcc, 0xcc, 0xcc };
for (uint expect = 0; expect < 0xf0; expect++)
{
*data = expect;
uint get = flow_read_length(data);
bt_assert_msg(get == expect, "Testing get length 0x%02x (get 0x%02x)", expect, get);
}
for (uint expect = 0; expect <= 0xfff; expect++)
{
put_u16(data, expect | 0xf000);
uint get = flow_read_length(data);
bt_assert_msg(get == expect, "Testing get length 0x%03x (get 0x%03x)", expect, get);
}
return 1;
}
static int
t_write_length(void)
{
byte data[] = { 0xcc, 0xcc, 0xcc };
for (uint expect = 0; expect <= 0xfff; expect++)
{
uint offset = flow_write_length(data, expect);
uint set = (expect < 0xf0) ? *data : (get_u16(data) & 0x0fff);
bt_assert_msg(set == expect, "Testing set length 0x%03x (set 0x%03x)", expect, set);
bt_assert(offset == (expect < 0xf0 ? 1 : 2));
}
return 1;
}
static int
t_first_part(void)
{
net_addr_flow4 *f = NET_ADDR_FLOW4_(IP4_NONE, 0, ((byte[]) { 0x00, 0x00, 0xab }));
const byte *under240 = &f->data[1];
const byte *above240 = &f->data[2];
/* Case 0x00 0x00 */
f->data[0] = 0x00;
bt_assert(flow4_first_part(f) == NULL);
/* Case 0x01 0x00 */
f->data[0] = 0x01;
bt_assert(flow4_first_part(f) == under240);
/* Case 0xef 0x00 */
f->data[0] = 0xef;
bt_assert(flow4_first_part(f) == under240);
/* Case 0xf0 0x00 */
f->data[0] = 0xf0;
bt_assert(flow4_first_part(f) == NULL);
/* Case 0xf0 0x01 */
f->data[1] = 0x01;
bt_assert(flow4_first_part(f) == above240);
/* Case 0xff 0xff */
f->data[0] = 0xff;
f->data[1] = 0xff;
bt_assert(flow4_first_part(f) == above240);
return 1;
}
static int
t_iterators4(void)
{
const net_addr_flow4 *f = NET_ADDR_FLOW4_NLRI(
25, /* Length */
FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
FLOW_TYPE_SRC_PREFIX, 32, 10, 11, 12, 13,
FLOW_TYPE_IP_PROTOCOL, 0x81, 0x06,
FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
FLOW_TYPE_TCP_FLAGS, 0x80, 0x55,
);
const byte *start = f->data;
const byte *p1_dst_pfx = &f->data[1];
const byte *p2_src_pfx = &f->data[6];
const byte *p3_ip_proto = &f->data[12];
const byte *p4_port = &f->data[15];
const byte *p5_tcp_flags = &f->data[23];
const byte *end = &f->data[25];
bt_assert(flow_read_length(f->data) == (end-start));
bt_assert(flow4_first_part(f) == p1_dst_pfx);
bt_assert(flow4_next_part(p1_dst_pfx, end) == p2_src_pfx);
bt_assert(flow4_next_part(p2_src_pfx, end) == p3_ip_proto);
bt_assert(flow4_next_part(p3_ip_proto, end) == p4_port);
bt_assert(flow4_next_part(p4_port, end) == p5_tcp_flags);
bt_assert(flow4_next_part(p5_tcp_flags, end) == NULL);
return 1;
}
static int
t_iterators6(void)
{
const net_addr_flow6 *f = NET_ADDR_FLOW6_NLRI(
26, /* Length */
FLOW_TYPE_DST_PREFIX, 0x68, 0x40, 0x12, 0x34, 0x56, 0x78, 0x9a,
FLOW_TYPE_SRC_PREFIX, 0x08, 0x0, 0xc0,
FLOW_TYPE_NEXT_HEADER, 0x81, 0x06,
FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
FLOW_TYPE_LABEL, 0x80, 0x55,
);
const byte *start = f->data;
const byte *p1_dst_pfx = &f->data[1];
const byte *p2_src_pfx = &f->data[9];
const byte *p3_next_header = &f->data[13];
const byte *p4_port = &f->data[16];
const byte *p5_label = &f->data[24];
const byte *end = &f->data[26];
bt_assert(flow_read_length(f->data) == (end-start));
bt_assert(flow6_first_part(f) == p1_dst_pfx);
bt_assert(flow6_next_part(p1_dst_pfx, end) == p2_src_pfx);
bt_assert(flow6_next_part(p2_src_pfx, end) == p3_next_header);
bt_assert(flow6_next_part(p3_next_header, end) == p4_port);
bt_assert(flow6_next_part(p4_port, end) == p5_label);
bt_assert(flow6_next_part(p5_label, end) == NULL);
return 1;
}
static int
t_accessors4(void)
{
const net_addr_flow4 *f = NET_ADDR_FLOW4_NLRI(
25, /* Length */
FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
FLOW_TYPE_SRC_PREFIX, 32, 10, 11, 12, 13,
FLOW_TYPE_IP_PROTOCOL, 0x81, 0x06,
FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
FLOW_TYPE_TCP_FLAGS, 0x80, 0x55,
);
const byte *p1_dst_px = &f->data[1];
const ip4_addr p1_dst_addr = ip4_build(5,6,7,0);
const byte *p2_src_px = &f->data[6];
const ip4_addr p2_src_addr = ip4_build(10,11,12,13);
bt_assert(ip4_equal(flow_read_ip4_part(p1_dst_px), p1_dst_addr));
bt_assert(ip4_equal(flow_read_ip4_part(p2_src_px), p2_src_addr));
return 1;
}
static int
t_accessors6(void)
{
const net_addr_flow6 *f = NET_ADDR_FLOW6_NLRI(
26, /* Length */
FLOW_TYPE_DST_PREFIX, 0x68, 0x40, 0x12, 0x34, 0x56, 0x78, 0x9a,
FLOW_TYPE_SRC_PREFIX, 0x08, 0x0, 0xc0,
FLOW_TYPE_NEXT_HEADER, 0x81, 0x06,
FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
FLOW_TYPE_LABEL, 0x80, 0x55,
);
const byte *p1_dst_px = &f->data[1];
const ip6_addr p1_dst_addr = ip6_build(0,0,0x12345678,0x9a000000);
const byte *p2_src_px = &f->data[9];
const ip6_addr p2_src_addr = ip6_build(0xc0000000, 0, 0, 0);
bt_assert(ip6_equal(flow_read_ip6_part(p1_dst_px), p1_dst_addr));
bt_assert(ip6_equal(flow_read_ip6_part(p2_src_px), p2_src_addr));
return 1;
}
static int
t_validation4(void)
{
enum flow_validated_state res;
byte nlri1[] = {
FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
FLOW_TYPE_SRC_PREFIX, 32, 10, 11, 12, 13,
FLOW_TYPE_IP_PROTOCOL, 0x81, 0x06,
FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
FLOW_TYPE_TCP_FLAGS, 0x80, 0x55,
};
/* Empty NLRI */
res = flow4_validate(nlri1, 0);
bt_assert(res == FLOW_ST_VALID);
/* Valid / Not Complete testing */
uint valid_sizes[] = {5, 11, 14, 22, 25, 0};
uint valid_idx = 0;
for (uint size = 1; size <= sizeof(nlri1); size++)
{
res = flow4_validate(nlri1, size);
bt_debug("size %u, result: %s\n", size, flow_validated_state_str(res));
if (size == valid_sizes[valid_idx])
{
valid_idx++;
bt_assert(res == FLOW_ST_VALID);
}
else
{
bt_assert(res == FLOW_ST_NOT_COMPLETE);
}
}
/* Misc err tests */
struct tset {
enum flow_validated_state expect;
char *description;
u16 size;
byte *nlri;
};
#define TS(type, msg, data) ((struct tset) {type, msg, sizeof(data), (data)})
struct tset tset[] = {
TS(
FLOW_ST_EXCEED_MAX_PREFIX_LENGTH,
"33-length IPv4 prefix",
((byte []) {
FLOW_TYPE_DST_PREFIX, 33, 5, 6, 7, 8, 9
})
),
TS(
FLOW_ST_EXCEED_MAX_VALUE_LENGTH,
"DSCP of length 2",
((byte []) {
FLOW_TYPE_DSCP, 0x91, 00, 63,
})
),
TS(
FLOW_ST_BAD_TYPE_ORDER,
"Bad flowspec component type order",
((byte []) {
FLOW_TYPE_SRC_PREFIX, 32, 10, 11, 12, 13,
FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
})
),
TS(
FLOW_ST_BAD_TYPE_ORDER,
"Doubled destination prefix component",
((byte []) {
FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
})
),
TS(
FLOW_ST_UNKNOWN_COMPONENT,
"Unknown component of type number 14",
((byte []) {
FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
FLOW_TYPE_TCP_FLAGS, 0x80, 0x55,
14 /*something new*/, 0x80, 0x55,
})
),
TS(
FLOW_ST_UNKNOWN_COMPONENT,
"Label component in IPv4",
((byte []) {
FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
FLOW_TYPE_LABEL, 0xa0, 0, 0, 0, 0x55,
})
),
TS(
FLOW_ST_NONZERO_PADDING,
"Non-zero padding in prefix",
((byte []) {
FLOW_TYPE_DST_PREFIX, 20, 5, 6, 7,
})
),
TS(
FLOW_ST_FIRST_AND_BIT_SET,
"The first numeric operator has set the AND bit",
((byte []) {
FLOW_TYPE_PORT, 0x43, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
})
),
TS(
FLOW_ST_ZERO_BIT_SET,
"Set zero bit in operator to one (0x08)",
((byte []) {
FLOW_TYPE_IP_PROTOCOL, 0x89, 0x06,
})
),
TS(
FLOW_ST_ZERO_BIT_SET,
"Set zero bit in operator to one (0x04)",
((byte []) {
FLOW_TYPE_FRAGMENT, 0x84, 0x03,
})
),
TS(
FLOW_ST_INVALID_TCP_FLAGS,
"Set zero bit in operand to one (TCP flags)",
((byte []) {
FLOW_TYPE_TCP_FLAGS, 0x91, 0xff, 0x3a,
})
),
TS(
FLOW_ST_INVALID_FRAGMENT,
"Set zero bit in operand to one (fragment)",
((byte []) {
FLOW_TYPE_FRAGMENT, 0x81, 0xff,
})
),
};
#undef TS
for (uint tcase = 0; tcase < ARRAY_SIZE(tset); tcase++)
{
res = flow4_validate(tset[tcase].nlri, tset[tcase].size);
bt_assert_msg(res == tset[tcase].expect, "Assertion (%s == %s) %s", flow_validated_state_str(res), flow_validated_state_str(tset[tcase].expect), tset[tcase].description);
}
return 1;
}
static int
t_validation6(void)
{
enum flow_validated_state res;
byte nlri1[] = {
FLOW_TYPE_DST_PREFIX, 103, 61, 0x01, 0x12, 0x34, 0x56, 0x78, 0xc0,
FLOW_TYPE_SRC_PREFIX, 8, 0, 0xc0,
FLOW_TYPE_NEXT_HEADER, 0x81, 0x06,
FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
FLOW_TYPE_LABEL, 0x80, 0x55,
};
/* Isn't included destination prefix */
res = flow6_validate(nlri1, 0);
bt_assert(res == FLOW_ST_VALID);
/* Valid / Not Complete testing */
uint valid_sizes[] = {0, 9, 13, 16, 24, 27, 0};
uint valid_idx = 0;
for (uint size = 0; size <= sizeof(nlri1); size++)
{
res = flow6_validate(nlri1, size);
bt_debug("size %u, result: %s\n", size, flow_validated_state_str(res));
if (size == valid_sizes[valid_idx])
{
valid_idx++;
bt_assert(res == FLOW_ST_VALID);
}
else
{
bt_assert(res == FLOW_ST_NOT_COMPLETE);
}
}
/* Misc err tests */
struct tset {
enum flow_validated_state expect;
char *description;
u16 size;
byte *nlri;
};
#define TS(type, msg, data) ((struct tset) {type, msg, sizeof(data), (data)})
struct tset tset[] = {
TS(
FLOW_ST_EXCEED_MAX_PREFIX_LENGTH,
"129-length IPv6 prefix",
((byte []) {
FLOW_TYPE_DST_PREFIX, 129, 64, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
})
),
TS(
FLOW_ST_EXCEED_MAX_PREFIX_OFFSET,
"Prefix offset is higher than prefix length",
((byte []) {
FLOW_TYPE_DST_PREFIX, 48, 64, 0x40, 0x12, 0x34
})
),
TS(
FLOW_ST_EXCEED_MAX_VALUE_LENGTH,
"Fragment of length 2",
((byte []) {
FLOW_TYPE_FRAGMENT, 0x91, 00, 0x0f,
})
),
TS(
FLOW_ST_BAD_TYPE_ORDER,
"Bad flowspec component type order",
((byte []) {
FLOW_TYPE_NEXT_HEADER, 0x81, 0x06,
FLOW_TYPE_SRC_PREFIX, 8, 0, 0xc0,
})
),
TS(
FLOW_ST_BAD_TYPE_ORDER,
"Doubled destination prefix component",
((byte []) {
FLOW_TYPE_DST_PREFIX, 103, 61, 0x01, 0x12, 0x34, 0x56, 0x78, 0xc0,
FLOW_TYPE_DST_PREFIX, 103, 61, 0x01, 0x12, 0x34, 0x56, 0x78, 0xc0,
})
),
TS(
FLOW_ST_UNKNOWN_COMPONENT,
"Unknown component of type number 14",
((byte []) {
FLOW_TYPE_TCP_FLAGS, 0x80, 0x55,
14 /*something new*/, 0x80, 0x55,
})
),
TS(
FLOW_ST_VALID,
"Label component is well-known in IPv6",
((byte []) {
FLOW_TYPE_LABEL, 0xa0, 0, 0, 0, 0x55,
})
),
TS(
FLOW_ST_NONZERO_PADDING,
"Non-zero padding in prefix",
((byte []) {
FLOW_TYPE_DST_PREFIX, 44, 16, 0x40, 0x12, 0x34, 0x56,
})
),
TS(
FLOW_ST_FIRST_AND_BIT_SET,
"The first numeric operator has set the AND bit",
((byte []) {
FLOW_TYPE_PORT, 0x43, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90
})
),
TS(
FLOW_ST_ZERO_BIT_SET,
"Set zero bit in operator to one (0x08)",
((byte []) {
FLOW_TYPE_NEXT_HEADER, 0x89, 0x06
})
),
TS(
FLOW_ST_ZERO_BIT_SET,
"Set zero bit in operator to one (0x04)",
((byte []) {
FLOW_TYPE_FRAGMENT, 0x84, 0x03,
})
),
TS(
FLOW_ST_INVALID_TCP_FLAGS,
"Set zero bit in operand to one (TCP flags)",
((byte []) {
FLOW_TYPE_TCP_FLAGS, 0x91, 0xff, 0x3a,
})
),
TS(
FLOW_ST_INVALID_FRAGMENT,
"Set zero bit in operand to one (fragment)",
((byte []) {
FLOW_TYPE_FRAGMENT, 0x81, 0xff,
})
),
};
#undef TS
for (uint tcase = 0; tcase < ARRAY_SIZE(tset); tcase++)
{
res = flow6_validate(tset[tcase].nlri, tset[tcase].size);
bt_assert_msg(res == tset[tcase].expect, "Assertion (%s == %s) %s", flow_validated_state_str(res), flow_validated_state_str(tset[tcase].expect), tset[tcase].description);
}
return 1;
}
static int
t_decoding4(void)
{
enum flow_validated_state res;
byte nlri1[] = {
FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
FLOW_TYPE_SRC_PREFIX, 32, 10, 11, 12, 13,
FLOW_TYPE_IP_PROTOCOL, 0x81, 0x06,
FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
FLOW_TYPE_TCP_FLAGS, 0x80, 0x55,
};
/* Empty NLRI */
res = flow4_decode(nlri1, 0);
bt_assert(res == FLOW_ST_VALID);
/* Valid / Not Complete testing */
uint valid_sizes[] = {5, 11, 14, 22, 25, 0};
uint valid_idx = 0;
for (uint size = 1; size <= sizeof(nlri1); size++)
{
res = flow4_decode(nlri1, size);
bt_debug("size %u, result: %s\n", size, flow_validated_state_str(res));
if (size == valid_sizes[valid_idx])
{
valid_idx++;
bt_assert(res == FLOW_ST_VALID);
}
else
{
bt_assert(res == FLOW_ST_NOT_COMPLETE);
}
}
/* Misc err tests */
struct tset {
enum flow_validated_state expect;
char *description;
u16 size;
byte *nlri;
byte *result;
};
#define TS(type, msg, data, result) ((struct tset) {type, msg, sizeof(data), (data), (result)})
struct tset tset[] = {
TS(
FLOW_ST_EXCEED_MAX_PREFIX_LENGTH,
"33-length IPv4 prefix",
((byte []) {
FLOW_TYPE_DST_PREFIX, 33, 5, 6, 7, 8, 9
}),
NULL
),
TS(
FLOW_ST_EXCEED_MAX_VALUE_LENGTH,
"DSCP of length 2",
((byte []) {
FLOW_TYPE_DSCP, 0x91, 00, 63,
}),
NULL
),
TS(
FLOW_ST_BAD_TYPE_ORDER,
"Bad flowspec component type order",
((byte []) {
FLOW_TYPE_SRC_PREFIX, 32, 10, 11, 12, 13,
FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
}),
NULL
),
TS(
FLOW_ST_BAD_TYPE_ORDER,
"Doubled destination prefix component",
((byte []) {
FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
}),
NULL
),
TS(
FLOW_ST_UNKNOWN_COMPONENT,
"Unknown component of type number 14",
((byte []) {
FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
FLOW_TYPE_TCP_FLAGS, 0x80, 0x55,
14 /*something new*/, 0x80, 0x55,
}),
NULL
),
TS(
FLOW_ST_UNKNOWN_COMPONENT,
"Label component in IPv4",
((byte []) {
FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
FLOW_TYPE_LABEL, 0xa0, 0, 0, 0, 0x55,
}),
NULL
),
TS(
FLOW_ST_VALID,
"Non-zero padding in prefix",
((byte []) {
FLOW_TYPE_DST_PREFIX, 21, 5, 6, 0x7f,
FLOW_TYPE_SRC_PREFIX, 24, 5, 6, 0x7f,
}),
((byte []) {
FLOW_TYPE_DST_PREFIX, 21, 5, 6, 0x78,
FLOW_TYPE_SRC_PREFIX, 24, 5, 6, 0x7f,
})
),
TS(
FLOW_ST_VALID,
"The first numeric operator has set the AND bit",
((byte []) {
FLOW_TYPE_PORT, 0x43, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
}),
((byte []) {
FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
})
),
TS(
FLOW_ST_VALID,
"Set zero bit in operator to one",
((byte []) {
FLOW_TYPE_IP_PROTOCOL, 0x89, 0x06,
FLOW_TYPE_FRAGMENT, 0x84, 0x03,
}),
((byte []) {
FLOW_TYPE_IP_PROTOCOL, 0x81, 0x06,
FLOW_TYPE_FRAGMENT, 0x80, 0x03,
})
),
TS(
FLOW_ST_VALID,
"Set zero bit in operand to one",
((byte []) {
FLOW_TYPE_TCP_FLAGS, 0x91, 0xff, 0x3a,
FLOW_TYPE_FRAGMENT, 0x81, 0xff,
}),
((byte []) {
FLOW_TYPE_TCP_FLAGS, 0x91, 0x0f, 0x3a,
FLOW_TYPE_FRAGMENT, 0x81, 0x0f,
})
),
};
#undef TS
for (uint tcase = 0; tcase < ARRAY_SIZE(tset); tcase++)
{
res = flow4_decode(tset[tcase].nlri, tset[tcase].size);
bt_assert_msg(res == tset[tcase].expect, "Assertion (%s == %s) %s", flow_validated_state_str(res), flow_validated_state_str(tset[tcase].expect), tset[tcase].description);
if ((res == FLOW_ST_VALID) && (tset[tcase].expect == FLOW_ST_VALID))
{
int pos;
for (pos = 0; pos < tset[tcase].size; pos++)
if (tset[tcase].nlri[pos] != tset[tcase].result[pos])
break;
bool ok = (pos == tset[tcase].size);
bt_assert_msg(ok, "Assertion (pos %u: 0x%02x == 0x%02x) %s", pos, (ok ? 0 : tset[tcase].nlri[pos]), (ok ? 0 : tset[tcase].result[pos]), tset[tcase].description);
}
}
return 1;
}
static int
t_decoding6(void)
{
enum flow_validated_state res;
byte nlri1[] = {
FLOW_TYPE_DST_PREFIX, 103, 61, 0x01, 0x12, 0x34, 0x56, 0x78, 0xc0,
FLOW_TYPE_SRC_PREFIX, 8, 0, 0xc0,
FLOW_TYPE_NEXT_HEADER, 0x81, 0x06,
FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
FLOW_TYPE_LABEL, 0x80, 0x55,
};
/* Isn't included destination prefix */
res = flow6_decode(nlri1, 0);
bt_assert(res == FLOW_ST_VALID);
/* Valid / Not Complete testing */
uint valid_sizes[] = {0, 9, 13, 16, 24, 27, 0};
uint valid_idx = 0;
for (uint size = 0; size <= sizeof(nlri1); size++)
{
res = flow6_decode(nlri1, size);
bt_debug("size %u, result: %s\n", size, flow_validated_state_str(res));
if (size == valid_sizes[valid_idx])
{
valid_idx++;
bt_assert(res == FLOW_ST_VALID);
}
else
{
bt_assert(res == FLOW_ST_NOT_COMPLETE);
}
}
/* Misc err tests */
struct tset {
enum flow_validated_state expect;
char *description;
u16 size;
byte *nlri;
byte *result;
};
#define TS(type, msg, data, result) ((struct tset) {type, msg, sizeof(data), (data), (result)})
struct tset tset[] = {
TS(
FLOW_ST_EXCEED_MAX_PREFIX_LENGTH,
"129-length IPv6 prefix",
((byte []) {
FLOW_TYPE_DST_PREFIX, 129, 64, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
}),
NULL
),
TS(
FLOW_ST_EXCEED_MAX_PREFIX_OFFSET,
"Prefix offset is higher than prefix length",
((byte []) {
FLOW_TYPE_DST_PREFIX, 48, 64, 0x40, 0x12, 0x34
}),
NULL
),
TS(
FLOW_ST_EXCEED_MAX_VALUE_LENGTH,
"Fragment of length 2",
((byte []) {
FLOW_TYPE_FRAGMENT, 0x91, 00, 0x0f,
}),
NULL
),
TS(
FLOW_ST_BAD_TYPE_ORDER,
"Bad flowspec component type order",
((byte []) {
FLOW_TYPE_NEXT_HEADER, 0x81, 0x06,
FLOW_TYPE_SRC_PREFIX, 8, 0, 0xc0,
}),
NULL
),
TS(
FLOW_ST_BAD_TYPE_ORDER,
"Doubled destination prefix component",
((byte []) {
FLOW_TYPE_DST_PREFIX, 103, 61, 0x01, 0x12, 0x34, 0x56, 0x78, 0xc0,
FLOW_TYPE_DST_PREFIX, 103, 61, 0x01, 0x12, 0x34, 0x56, 0x78, 0xc0,
}),
NULL
),
TS(
FLOW_ST_UNKNOWN_COMPONENT,
"Unknown component of type number 14",
((byte []) {
FLOW_TYPE_TCP_FLAGS, 0x80, 0x55,
14 /*something new*/, 0x80, 0x55,
}),
NULL
),
TS(
FLOW_ST_VALID,
"Label component is well-known in IPv6",
((byte []) {
FLOW_TYPE_LABEL, 0xa0, 0, 0, 0, 0x55,
}),
((byte []) {
FLOW_TYPE_LABEL, 0xa0, 0, 0, 0, 0x55,
})
),
TS(
FLOW_ST_VALID,
"Non-zero padding in prefix",
((byte []) {
FLOW_TYPE_DST_PREFIX, 43, 16, 0x40, 0x12, 0x34, 0x7c,
}),
((byte []) {
FLOW_TYPE_DST_PREFIX, 43, 16, 0x40, 0x12, 0x34, 0x60,
})
),
TS(
FLOW_ST_VALID,
"The first numeric operator has set the AND bit",
((byte []) {
FLOW_TYPE_PORT, 0x43, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90
}),
((byte []) {
FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
})
),
TS(
FLOW_ST_VALID,
"Set zero bit in operator to one",
((byte []) {
FLOW_TYPE_NEXT_HEADER, 0x89, 0x06,
FLOW_TYPE_FRAGMENT, 0x84, 0x02,
}),
((byte []) {
FLOW_TYPE_IP_PROTOCOL, 0x81, 0x06,
FLOW_TYPE_FRAGMENT, 0x80, 0x02,
})
),
TS(
FLOW_ST_VALID,
"Set zero bit in operand to one",
((byte []) {
FLOW_TYPE_TCP_FLAGS, 0x91, 0xff, 0x3a,
FLOW_TYPE_FRAGMENT, 0x81, 0xff,
}),
((byte []) {
FLOW_TYPE_TCP_FLAGS, 0x91, 0x0f, 0x3a,
FLOW_TYPE_FRAGMENT, 0x81, 0x0e,
})
),
};
#undef TS
for (uint tcase = 0; tcase < ARRAY_SIZE(tset); tcase++)
{
res = flow6_decode(tset[tcase].nlri, tset[tcase].size);
bt_assert_msg(res == tset[tcase].expect, "Assertion (%s == %s) %s", flow_validated_state_str(res), flow_validated_state_str(tset[tcase].expect), tset[tcase].description);
if ((res == FLOW_ST_VALID) && (tset[tcase].expect == FLOW_ST_VALID))
{
int pos;
for (pos = 0; pos < tset[tcase].size; pos++)
if (tset[tcase].nlri[pos] != tset[tcase].result[pos])
break;
bool ok = (pos == tset[tcase].size);
bt_assert_msg(ok, "Assertion (pos %u: 0x%02x == 0x%02x) %s", pos, (ok ? 0 : tset[tcase].nlri[pos]), (ok ? 0 : tset[tcase].result[pos]), tset[tcase].description);
}
}
return 1;
}
/*
* Builder tests
*/
static int
t_builder4(void)
{
struct flow_builder *fb = flow_builder_init(&root_pool);
/* Expectation */
const net_addr_flow4 *expect = NET_ADDR_FLOW4_NLRI(
0,
FLOW_TYPE_DST_PREFIX, 24, 5, 6, 7,
FLOW_TYPE_SRC_PREFIX, 32, 10, 11, 12, 13,
FLOW_TYPE_IP_PROTOCOL, 0x80, 0x06,
FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
FLOW_TYPE_TCP_FLAGS, 0x80, 0x55,
);
/* Normal order */
net_addr_ip4 n1;
net_fill_ip4((net_addr *) &n1, ip4_build(5,6,7,0), 24);
flow_builder_set_type(fb, FLOW_TYPE_DST_PREFIX);
flow_builder4_add_pfx(fb, &n1);
net_addr_ip4 n2;
net_fill_ip4((net_addr *) &n2, ip4_build(10,11,12,13), 32);
flow_builder_set_type(fb, FLOW_TYPE_SRC_PREFIX);
flow_builder4_add_pfx(fb, &n2);
flow_builder_set_type(fb, FLOW_TYPE_IP_PROTOCOL);
flow_builder_add_op_val(fb, 0, 0x06);
flow_builder_set_type(fb, FLOW_TYPE_PORT);
flow_builder_add_op_val(fb, 0x03, 0x89);
flow_builder_add_op_val(fb, 0x45, 0x8b);
flow_builder_add_op_val(fb, 0x01, 0x1f90);
/* Try put a component twice time */
flow_builder_set_type(fb, FLOW_TYPE_IP_PROTOCOL);
flow_builder_add_op_val(fb, 0, 0x06);
flow_builder_set_type(fb, FLOW_TYPE_TCP_FLAGS);
flow_builder_add_op_val(fb, 0, 0x55);
net_addr_flow4 *res = flow_builder4_finalize(fb, tmp_linpool);
bt_assert(memcmp(res, expect, expect->length) == 0);
/* Reverse order */
flow_builder_clear(fb);
flow_builder_set_type(fb, FLOW_TYPE_TCP_FLAGS);
flow_builder_add_op_val(fb, 0, 0x55);
flow_builder_set_type(fb, FLOW_TYPE_PORT);
flow_builder_add_op_val(fb, 0x03, 0x89);
flow_builder_add_op_val(fb, 0x45, 0x8b);
flow_builder_add_op_val(fb, 0x01, 0x1f90);
flow_builder_set_type(fb, FLOW_TYPE_IP_PROTOCOL);
flow_builder_add_op_val(fb, 0, 0x06);
net_fill_ip4((net_addr *) &n2, ip4_build(10,11,12,13), 32);
flow_builder_set_type(fb, FLOW_TYPE_SRC_PREFIX);
flow_builder4_add_pfx(fb, &n2);
net_fill_ip4((net_addr *) &n1, ip4_build(5,6,7,0), 24);
flow_builder_set_type(fb, FLOW_TYPE_DST_PREFIX);
flow_builder4_add_pfx(fb, &n1);
bt_assert(memcmp(res, expect, expect->length) == 0);
return 1;
}
static int
t_builder6(void)
{
net_addr_ip6 ip;
struct flow_builder *fb = flow_builder_init(&root_pool);
fb->ipv6 = 1;
/* Expectation */
const net_addr_flow6 *expect = NET_ADDR_FLOW6_NLRI(
0,
FLOW_TYPE_DST_PREFIX, 103, 61, 0x22, 0x46, 0x8a, 0xcf, 0x13, 0x00,
FLOW_TYPE_SRC_PREFIX, 8, 0, 0xc0,
FLOW_TYPE_NEXT_HEADER, 0x80, 0x06,
FLOW_TYPE_PORT, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
FLOW_TYPE_LABEL, 0xa0, 0x00, 0x00, 0x00, 0x55,
);
/* Normal order */
net_fill_ip6((net_addr *) &ip, ip6_build(0, 1, 0x12345678, 0x98000000), 103);
flow_builder_set_type(fb, FLOW_TYPE_DST_PREFIX);
flow_builder6_add_pfx(fb, &ip, 61);
/* Try put a component twice time */
net_fill_ip6((net_addr *) &ip, ip6_build(0, 1, 0x12345678, 0x98000000), 103);
flow_builder_set_type(fb, FLOW_TYPE_DST_PREFIX);
bt_assert(flow_builder6_add_pfx(fb, &ip, 61) == 0);
net_fill_ip6((net_addr *) &ip, ip6_build(0xc0000000,0,0,0), 8);
flow_builder_set_type(fb, FLOW_TYPE_SRC_PREFIX);
flow_builder6_add_pfx(fb, &ip, 0);
flow_builder_set_type(fb, FLOW_TYPE_NEXT_HEADER);
flow_builder_add_op_val(fb, 0, 0x06);
flow_builder_set_type(fb, FLOW_TYPE_PORT);
flow_builder_add_op_val(fb, 0x03, 0x89);
flow_builder_add_op_val(fb, 0x45, 0x8b);
flow_builder_add_op_val(fb, 0x01, 0x1f90);
flow_builder_set_type(fb, FLOW_TYPE_LABEL);
flow_builder_add_op_val(fb, 0, 0x55);
net_addr_flow6 *res = flow_builder6_finalize(fb, tmp_linpool);
bt_assert(memcmp(res, expect, expect->length) == 0);
/* Reverse order */
flow_builder_clear(fb);
fb->ipv6 = 1;
flow_builder_set_type(fb, FLOW_TYPE_LABEL);
flow_builder_add_op_val(fb, 0, 0x55);
flow_builder_set_type(fb, FLOW_TYPE_PORT);
flow_builder_add_op_val(fb, 0x03, 0x89);
flow_builder_add_op_val(fb, 0x45, 0x8b);
flow_builder_add_op_val(fb, 0x01, 0x1f90);
flow_builder_set_type(fb, FLOW_TYPE_NEXT_HEADER);
flow_builder_add_op_val(fb, 0, 0x06);
net_fill_ip6((net_addr *) &ip, ip6_build(0xc0000000,0,0,0), 8);
flow_builder_set_type(fb, FLOW_TYPE_SRC_PREFIX);
flow_builder6_add_pfx(fb, &ip, 0);
net_fill_ip6((net_addr *) &ip, ip6_build(0, 1, 0x12345678, 0x98000000), 103);
flow_builder_set_type(fb, FLOW_TYPE_DST_PREFIX);
flow_builder6_add_pfx(fb, &ip, 61);
res = flow_builder6_finalize(fb, tmp_linpool);
bt_assert(memcmp(res, expect, expect->length) == 0);
return 1;
}
static int
t_formatting4(void)
{
const net_addr_flow4 *input[4];
const char *expect[4];
expect[0] = "flow4 { dst 10.0.0.0/8; proto 23; dport > 24 && < 30 || 40..50,60..70,80 && >= 90; sport > 24 && < 30 || 40,50,60..70,80; icmp type 80; icmp code 90; tcp flags 0x3/0x3 && 0x0/0xc; length 0..65535; dscp 63; fragment dont_fragment || !is_fragment; }";
input[0] = NET_ADDR_FLOW4_NLRI(
0,
FLOW_TYPE_DST_PREFIX, 0x08, 10,
FLOW_TYPE_IP_PROTOCOL, 0x81, 23,
FLOW_TYPE_DST_PORT, 0x02, 24, 0x44, 30, 0x03, 40, 0x45, 50, 0x03, 60, 0x45, 70, 0x01, 80, 0xc3, 90,
FLOW_TYPE_SRC_PORT, 0x02, 24, 0x44, 0x1e, 0x01, 0x28, 0x01, 0x32, 0x03, 0x3c, 0x45, 0x46, 0x81, 0x50,
FLOW_TYPE_ICMP_TYPE, 0x81, 0x50,
FLOW_TYPE_ICMP_CODE, 0x81, 0x5a,
FLOW_TYPE_TCP_FLAGS, 0x01, 0x03, 0xc2, 0x0c,
FLOW_TYPE_PACKET_LENGTH, 0x03, 0, 0xd5, 0xff, 0xff,
FLOW_TYPE_DSCP, 0x81, 63,
FLOW_TYPE_FRAGMENT, 0x01, 0x01, 0x82, 0x02,
);
/* RFC 8955 4.3.1 Example 1 */
expect[1] = "flow4 { dst 192.0.2.0/24; proto 6; port 25; }";
input[1] = NET_ADDR_FLOW4_NLRI(
0x0b,
0x01, 0x18, 0xc0, 0x00, 0x02,
0x03, 0x81, 0x06,
0x04, 0x81, 0x19,
);
/* RFC 8955 4.3.2 Example 2 */
expect[2] = "flow4 { dst 192.0.2.0/24; src 203.0.113.0/24; port 137..139,8080; }";
input[2] = NET_ADDR_FLOW4_NLRI(
0x12,
0x01, 0x18, 0xc0, 0x00, 0x02,
0x02, 0x18, 0xcb, 0x00, 0x71,
0x04, 0x03, 0x89, 0x45, 0x8b, 0x91, 0x1f, 0x90,
);
/* RFC 8955 4.3.3 Example 3 */
expect[3] = "flow4 { dst 192.0.2.1/32; fragment !0x0/0x5; }";
input[3] = NET_ADDR_FLOW4_NLRI(
0x09,
0x01, 0x20, 0xc0, 0x00, 0x02, 0x01,
0x0c, 0x80, 0x05,
);
/* Run the tests */
for (uint i = 0; i < ARRAY_SIZE(input); i++)
{
char buf[1024];
uint len = flow4_net_format(buf, sizeof(buf), input[i]);
bt_debug(" expect: '%s',\n output: '%s'\n", expect[i], buf);
bt_assert(!strcmp(buf, expect[i]));
bt_assert(len == strlen(expect[i]));
}
return 1;
}
static int
t_formatting6(void)
{
const net_addr_flow6 *input[3];
const char *expect[3];
// (ip6_build(0, 1, 0x12345678, 0x98000000), 103, nlri0);
expect[0] = "flow6 { dst ::1:1234:5678:9800:0/103 offset 61; src c000::/8; next header 6; port 20..40,273; label < 500000; }";
input[0] = NET_ADDR_FLOW6_NLRI(
0,
FLOW_TYPE_DST_PREFIX, 103, 61, 0x22, 0x46, 0x8a, 0xcf, 0x13, 0x00,
FLOW_TYPE_SRC_PREFIX, 8, 0, 0xc0,
FLOW_TYPE_NEXT_HEADER, 0x81, 0x06,
FLOW_TYPE_PORT, 0x03, 20, 0x45, 40, 0x91, 0x01, 0x11,
FLOW_TYPE_LABEL, 0xa4, 0x00, 0x07, 0xa1, 0x20,
);
/* RFC 8956 3.8.1 Example 1 */
expect[1] = "flow6 { dst 2001:db8::/32; src ::1234:5678:9a00:0/104 offset 64; next header 6; }";
input[1] = NET_ADDR_FLOW6_(ip6_build(0x20010db8, 0, 0, 0), 32, ((const byte[]) {
0x12,
0x01, 0x20, 0x00, 0x20, 0x01, 0x0d, 0xb8,
0x02, 0x68, 0x40, 0x12, 0x34, 0x56, 0x78, 0x9a,
0x03, 0x81, 0x06,
}));
/* RFC 8956 3.8.2 Example 2 */
expect[2] = "flow6 { dst 2001:db8::/32; src ::1234:5678:9a00:0/104 offset 65; }";
input[2] = NET_ADDR_FLOW6_(ip6_build(0x20010db8, 0, 0, 0), 32, ((const byte[]) {
0x0f,
0x01, 0x20, 0x00, 0x20, 0x01, 0x0d, 0xb8,
0x02, 0x68, 0x41, 0x24, 0x68, 0xac, 0xf1, 0x34,
}));
/* Run the tests */
for (uint i = 0; i < ARRAY_SIZE(input); i++)
{
char buf[1024];
uint len = flow6_net_format(buf, sizeof(buf), input[i]);
bt_debug(" expect: '%s',\n output: '%s'\n", expect[i], buf);
bt_assert(!strcmp(buf, expect[i]));
bt_assert(len == strlen(expect[i]));
}
return 1;
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_read_length, "Testing get NLRI length");
bt_test_suite(t_write_length, "Testing set NLRI length");
bt_test_suite(t_first_part, "Searching first part in net_addr_flow");
bt_test_suite(t_iterators4, "Testing iterators (IPv4)");
bt_test_suite(t_iterators6, "Testing iterators (IPv6)");
bt_test_suite(t_accessors4, "Testing accessors (IPv4)");
bt_test_suite(t_accessors6, "Testing accessors (IPv6)");
bt_test_suite(t_validation4, "Testing validation (IPv4)");
bt_test_suite(t_validation6, "Testing validation (IPv6)");
bt_test_suite(t_decoding4, "Testing decoding (IPv4)");
bt_test_suite(t_decoding6, "Testing decoding (IPv6)");
bt_test_suite(t_builder4, "Inserting components into existing Flow Specification (IPv4)");
bt_test_suite(t_builder6, "Inserting components into existing Flow Specification (IPv6)");
bt_test_suite(t_formatting4, "Formatting Flow Specification (IPv4) into text representation");
bt_test_suite(t_formatting6, "Formatting Flow Specification (IPv6) into text representation");
return bt_exit_value();
}
bird2-2.17.5/lib/hash.h 0000664 0000000 0000000 00000015060 15211753245 0014461 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Generic Hash Table
*
* (c) 2013 Ondrej Zajicek
* (c) 2013 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_HASH_H_
#define _BIRD_HASH_H_
#define HASH(type) struct { type **data; uint count, order; }
#define HASH_TYPE(v) typeof(** (v).data)
#define HASH_SIZE(v) (1U << (v).order)
#define HASH_EQ(v,id,k1,k2...) (id##_EQ(k1, k2))
#define HASH_FN(v,id,key...) ((u32) (id##_FN(key)) >> (32 - (v).order))
#define HASH_INIT(v,pool,init_order) \
({ \
(v).count = 0; \
(v).order = (init_order); \
(v).data = mb_allocz(pool, HASH_SIZE(v) * sizeof(* (v).data)); \
})
#define HASH_FREE(v) \
({ \
mb_free((v).data); \
(v) = (typeof(v)){ }; \
})
#define HASH_FIND(v,id,key...) \
({ \
u32 _h = HASH_FN(v, id, key); \
HASH_TYPE(v) *_n = (v).data[_h]; \
while (_n && !HASH_EQ(v, id, id##_KEY(_n), key)) \
_n = id##_NEXT(_n); \
_n; \
})
#define HASH_INSERT(v,id,node) \
({ \
u32 _h = HASH_FN(v, id, id##_KEY((node))); \
HASH_TYPE(v) **_nn = (v).data + _h; \
id##_NEXT(node) = *_nn; \
*_nn = node; \
(v).count++; \
})
#define HASH_DO_REMOVE(v,id,_nn) \
({ \
*_nn = id##_NEXT((*_nn)); \
(v).count--; \
})
#define HASH_DELETE(v,id,key...) \
({ \
u32 _h = HASH_FN(v, id, key); \
HASH_TYPE(v) *_n, **_nn = (v).data + _h; \
\
while ((*_nn) && !HASH_EQ(v, id, id##_KEY((*_nn)), key)) \
_nn = &(id##_NEXT((*_nn))); \
\
if (_n = *_nn) \
HASH_DO_REMOVE(v,id,_nn); \
_n; \
})
#define HASH_REMOVE(v,id,node) \
({ \
u32 _h = HASH_FN(v, id, id##_KEY((node))); \
HASH_TYPE(v) *_n, **_nn = (v).data + _h; \
\
while ((*_nn) && (*_nn != (node))) \
_nn = &(id##_NEXT((*_nn))); \
\
if (_n = *_nn) \
HASH_DO_REMOVE(v,id,_nn); \
_n; \
})
#define HASH_REHASH(v,id,pool,step) \
({ \
HASH_TYPE(v) *_n, *_n2, **_od; \
uint _i, _os; \
\
_os = HASH_SIZE(v); \
_od = (v).data; \
(v).count = 0; \
(v).order += (step); \
(v).data = mb_allocz(pool, HASH_SIZE(v) * sizeof(* (v).data)); \
\
for (_i = 0; _i < _os; _i++) \
for (_n = _od[_i]; _n && (_n2 = id##_NEXT(_n), 1); _n = _n2) \
HASH_INSERT(v, id, _n); \
\
mb_free(_od); \
})
#define REHASH_LO_MARK(a,b,c,d,e,f) a
#define REHASH_HI_MARK(a,b,c,d,e,f) b
#define REHASH_LO_STEP(a,b,c,d,e,f) c
#define REHASH_HI_STEP(a,b,c,d,e,f) d
#define REHASH_LO_BOUND(a,b,c,d,e,f) e
#define REHASH_HI_BOUND(a,b,c,d,e,f) f
#define HASH_DEFINE_REHASH_FN(id,type) \
static void id##_REHASH(void *v, pool *p, int step) \
{ HASH_REHASH(* (HASH(type) *) v, id, p, step); }
#define HASH_MAY_STEP_UP(v,id,pool) HASH_MAY_STEP_UP_(v,pool, id##_REHASH, id##_PARAMS)
#define HASH_MAY_STEP_DOWN(v,id,pool) HASH_MAY_STEP_DOWN_(v,pool, id##_REHASH, id##_PARAMS)
#define HASH_MAY_RESIZE_DOWN(v,id,pool) HASH_MAY_RESIZE_DOWN_(v,pool, id##_REHASH, id##_PARAMS)
#define HASH_MAY_STEP_UP_(v,pool,rehash_fn,args) \
({ \
if (((v).count > (HASH_SIZE(v) REHASH_HI_MARK(args))) && \
((v).order < (REHASH_HI_BOUND(args)))) \
rehash_fn(&(v), pool, REHASH_HI_STEP(args)); \
})
#define HASH_MAY_STEP_DOWN_(v,pool,rehash_fn,args) \
({ \
if (((v).count < (HASH_SIZE(v) REHASH_LO_MARK(args))) && \
((v).order > (REHASH_LO_BOUND(args)))) \
rehash_fn(&(v), pool, -(REHASH_LO_STEP(args))); \
})
#define HASH_MAY_RESIZE_DOWN_(v,pool,rehash_fn,args) \
({ \
uint _o = (v).order; \
while (((v).count < ((1U << _o) REHASH_LO_MARK(args))) && \
(_o > (REHASH_LO_BOUND(args)))) \
_o -= (REHASH_LO_STEP(args)); \
if (_o < (v).order) \
rehash_fn(&(v), pool, _o - (v).order); \
})
#define HASH_INSERT2(v,id,pool,node) \
({ \
HASH_INSERT(v, id, node); \
HASH_MAY_STEP_UP(v, id, pool); \
})
#define HASH_DELETE2(v,id,pool,key...) \
({ \
HASH_TYPE(v) *_n = HASH_DELETE(v, id, key); \
if (_n) HASH_MAY_STEP_DOWN(v, id, pool); \
_n; \
})
#define HASH_REMOVE2(v,id,pool,node) \
({ \
HASH_TYPE(v) *_n = HASH_REMOVE(v, id, node); \
if (_n) HASH_MAY_STEP_DOWN(v, id, pool); \
_n; \
})
#define HASH_WALK(v,next,n) \
do { \
HASH_TYPE(v) *n; \
uint _i; \
uint _s = HASH_SIZE(v); \
for (_i = 0; _i < _s; _i++) \
for (n = (v).data[_i]; n; n = n->next)
#define HASH_WALK_END } while (0)
#define HASH_WALK_DELSAFE(v,next,n) \
do { \
HASH_TYPE(v) *n, *_next; \
uint _i; \
uint _s = HASH_SIZE(v); \
for (_i = 0; _i < _s; _i++) \
for (n = (v).data[_i]; n && (_next = n->next, 1); n = _next)
#define HASH_WALK_DELSAFE_END } while (0)
#define HASH_WALK_FILTER(v,next,n,nn) \
do { \
HASH_TYPE(v) *n, **nn; \
uint _i; \
uint _s = HASH_SIZE(v); \
for (_i = 0; _i < _s; _i++) \
for (nn = (v).data + _i; n = *nn; (*nn == n) ? (nn = &n->next) : NULL)
#define HASH_WALK_FILTER_END } while (0)
static inline void
mem_hash_init(u64 *h)
{
*h = 0x001047d54778bcafULL;
}
static inline void
mem_hash_mix(u64 *h, const void *p, uint s)
{
const u64 multiplier = 0xb38bc09a61202731ULL;
const char *pp = p;
uint i;
for (i=0; i> 32) ^ (*h & 0xffffffff));
}
static inline uint
mem_hash(const void *p, uint s)
{
static u64 h;
mem_hash_init(&h);
mem_hash_mix(&h, p, s);
return mem_hash_value(&h);
}
static inline uint
ptr_hash(const void *ptr)
{
uintptr_t p = (uintptr_t) ptr;
return p ^ (p << 8) ^ (p >> 16);
}
#endif
bird2-2.17.5/lib/hash_test.c 0000664 0000000 0000000 00000013030 15211753245 0015506 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Hash Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#undef LOCAL_DEBUG
#include "test/birdtest.h"
#include "lib/hash.h"
struct test_node {
struct test_node *next; /* Hash chain */
u32 key;
};
#define TEST_KEY(n) n->key
#define TEST_NEXT(n) n->next
#define TEST_EQ(n1,n2) n1 == n2
#define TEST_FN(n) (n) ^ u32_hash((n))
#define TEST_ORDER 13
#define TEST_PARAMS /TEST_ORDER, *2, 2, 2, TEST_ORDER, 20
#define TEST_REHASH test_rehash
HASH_DEFINE_REHASH_FN(TEST, struct test_node);
HASH(struct test_node) hash;
struct pool *my_pool;
#define MAX_NUM (1 << TEST_ORDER)
struct test_node nodes[MAX_NUM];
static void
print_rate_of_fulfilment(void)
{
int i;
int num_stacked_items = 0;
for (i = 0; i < MAX_NUM; i++)
if (!hash.data[i])
num_stacked_items++;
double percent_stacked_items = ((double)num_stacked_items/(double)MAX_NUM)*100.;
bt_debug("%d (%.2f %%) chained of %d hashes \n", num_stacked_items, percent_stacked_items, MAX_NUM);
}
#ifdef LOCAL_DEBUG
static void
dump_nodes(void)
{
int i;
for (i = 0; i < MAX_NUM; i++)
bt_debug("nodes[%3d] is at address %14p has .key %3d, .next %14p \n", i, &nodes[i], nodes[i].key, nodes[i].next);
}
#endif
static void
init_hash_(uint order)
{
my_pool = rp_new(&root_pool, "Test pool");
HASH_INIT(hash, my_pool, order);
int i;
for (i = 0; i < MAX_NUM; i++)
{
nodes[i].key = i;
nodes[i].next = NULL;
}
bt_debug("MAX_NUM %d \n", MAX_NUM);
}
static void
init_hash(void)
{
init_hash_(TEST_ORDER);
}
static void
validate_filled_hash(void)
{
int i;
struct test_node *node;
for (i = 0; i < MAX_NUM; i++)
{
node = HASH_FIND(hash, TEST, nodes[i].key);
bt_assert_msg(node->key == nodes[i].key, "Hash should be filled, to find (%p) the node[%d] (%p) with .key = %u, .next %p", node, i, &nodes[i], nodes[i].key, nodes[i].next);
}
print_rate_of_fulfilment();
}
static void
validate_empty_hash(void)
{
int i;
struct test_node *node;
for (i = 0; i < MAX_NUM; i++)
{
node = HASH_FIND(hash, TEST, nodes[i].key);
bt_assert_msg(node == NULL, "Hash should be empty, to find (%p) the node[%d] (%p) with .key %u, .next %p", node, i, &nodes[i], nodes[i].key, nodes[i].next);
}
}
static void
fill_hash(void)
{
int i;
struct test_node *node;
for (i = 0; i < MAX_NUM; i++)
{
nodes[i].key = i;
node = &nodes[i];
HASH_INSERT(hash, TEST, node);
}
}
static int
t_insert_find(void)
{
init_hash();
fill_hash();
validate_filled_hash();
return 1;
}
static int
t_insert_find_random(void)
{
init_hash();
int i;
struct test_node *node;
for (i = 0; i < MAX_NUM; i++)
{
nodes[i].key = bt_random();
node = &nodes[i];
HASH_INSERT(hash, TEST, node);
}
validate_filled_hash();
return 1;
}
static int
t_insert2_find(void)
{
init_hash_(1);
int i;
struct test_node *node;
for (i = 0; i < MAX_NUM; i++)
{
nodes[i].key = i;
node = &nodes[i];
HASH_INSERT2(hash, TEST, my_pool, node);
}
bt_assert_msg(hash.order != 1, "The hash should auto-resize from order 2^1. The order of the hash is 2^%u.", hash.order);
validate_filled_hash();
return 1;
}
static int
t_walk(void)
{
init_hash();
fill_hash();
uint i;
uint check[MAX_NUM];
for (i = 0; i < MAX_NUM; i++)
check[i] = 0;
HASH_WALK(hash, next, n)
{
check[n->key]++;
}
HASH_WALK_END;
for (i = 0; i < MAX_NUM; i++)
bt_assert(check[i] == 1);
return 1;
}
static int
t_walk_delsafe_delete(void)
{
init_hash();
fill_hash();
HASH_WALK_DELSAFE(hash, next, n)
{
HASH_DELETE(hash, TEST, n->key);
}
HASH_WALK_DELSAFE_END;
validate_empty_hash();
return 1;
}
static int
t_walk_delsafe_remove(void)
{
init_hash();
fill_hash();
HASH_WALK_DELSAFE(hash, next, n)
{
HASH_REMOVE(hash, TEST, n);
}
HASH_WALK_DELSAFE_END;
validate_empty_hash();
return 1;
}
static int
t_walk_delsafe_delete2(void)
{
init_hash();
fill_hash();
HASH_WALK_DELSAFE(hash, next, n)
{
HASH_DELETE2(hash, TEST, my_pool, n->key);
}
HASH_WALK_DELSAFE_END;
validate_empty_hash();
return 1;
}
static int
t_walk_delsafe_remove2(void)
{
init_hash();
fill_hash();
HASH_WALK_DELSAFE(hash, next, n)
{
HASH_REMOVE2(hash, TEST, my_pool, n);
}
HASH_WALK_DELSAFE_END;
validate_empty_hash();
return 1;
}
static int
t_walk_filter(void)
{
init_hash();
fill_hash();
uint i;
uint check[MAX_NUM];
for (i = 0; i < MAX_NUM; i++)
check[i] = 0;
HASH_WALK_FILTER(hash, next, n, m)
{
bt_assert(n == *m);
check[n->key]++;
}
HASH_WALK_FILTER_END;
for (i = 0; i < MAX_NUM; i++)
bt_assert(check[i] == 1);
return 1;
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_insert_find, "HASH_INSERT and HASH_FIND");
bt_test_suite(t_insert_find_random, "HASH_INSERT pseudo-random keys and HASH_FIND");
bt_test_suite(t_insert2_find, "HASH_INSERT2 and HASH_FIND. HASH_INSERT2 is HASH_INSERT and a smart auto-resize function");
bt_test_suite(t_walk, "HASH_WALK");
bt_test_suite(t_walk_delsafe_delete, "HASH_WALK_DELSAFE and HASH_DELETE");
bt_test_suite(t_walk_delsafe_delete2, "HASH_WALK_DELSAFE and HASH_DELETE2. HASH_DELETE2 is HASH_DELETE and smart auto-resize function");
bt_test_suite(t_walk_delsafe_remove, "HASH_WALK_DELSAFE and HASH_REMOVE");
bt_test_suite(t_walk_delsafe_remove2, "HASH_WALK_DELSAFE and HASH_REMOVE2. HASH_REMOVE2 is HASH_REMOVE and smart auto-resize function");
bt_test_suite(t_walk_filter, "HASH_WALK_FILTER");
return bt_exit_value();
}
bird2-2.17.5/lib/heap.h 0000664 0000000 0000000 00000011564 15211753245 0014460 0 ustar 00root root 0000000 0000000 /*
* UCW Library -- Universal Heap Macros
*
* (c) 2001 Martin Mares
* (c) 2005 Tomas Valla
*
* This software may be freely distributed and used according to the terms
* of the GNU Lesser General Public License.
*/
/**
* [[intro]]
* Introduction
* ------------
*
* Binary heap is a simple data structure, which for example supports efficient insertions, deletions
* and access to the minimal inserted item. We define several macros for such operations.
* Note that because of simplicity of heaps, we have decided to define direct macros instead
* of a <> as for several other data structures in the Libucw.
*
* A heap is represented by a number of elements and by an array of values. Beware that we
* index this array from one, not from zero as do the standard C arrays.
*
* Most macros use these parameters:
*
* - @type - the type of elements
* - @num - a variable (signed or unsigned integer) with the number of elements
* - @heap - a C array of type @type; the heap is stored in `heap[1] .. heap[num]`; `heap[0]` is unused
* - @less - a callback to compare two element values; `less(x, y)` shall return a non-zero value iff @x is lower than @y
* - @swap - a callback to swap two array elements; `swap(heap, i, j, t)` must swap `heap[i]` with `heap[j]` with possible help of temporary variable @t (type @type).
*
* A valid heap must follow these rules:
*
* - `num >= 0`
* - `heap[i] >= heap[i / 2]` for each `i` in `[2, num]`
*
* The first element `heap[1]` is always lower or equal to all other elements.
*
* [[macros]]
* Macros
* ------
*/
/* For internal usage. */
#define HEAP_BUBBLE_DOWN_J(heap,num,less,swap) \
for (;;) \
{ \
_l = 2*_j; \
if (_l > num) \
break; \
if (less(heap[_j],heap[_l]) && (_l == num || less(heap[_j],heap[_l+1]))) \
break; \
if (_l != num && less(heap[_l+1],heap[_l])) \
_l++; \
swap(heap,_j,_l,x); \
_j = _l; \
}
/* For internal usage. */
#define HEAP_BUBBLE_UP_J(heap,num,less,swap) \
while (_j > 1) \
{ \
_u = _j/2; \
if (less(heap[_u], heap[_j])) \
break; \
swap(heap,_u,_j,x); \
_j = _u; \
}
/**
* Shuffle the unordered array @heap of @num elements to become a valid heap. The time complexity is linear.
**/
#define HEAP_INIT(heap,num,type,less,swap) \
do { \
uint _i = num; \
uint _j, _l; \
type x; \
while (_i >= 1) \
{ \
_j = _i; \
HEAP_BUBBLE_DOWN_J(heap,num,less,swap) \
_i--; \
} \
} while(0)
/**
* Delete the minimum element `heap[1]` in `O(log(n))` time.
* The removed value is moved just after the resulting heap (`heap[num + 1]`).
**/
#define HEAP_DELMIN(heap,num,type,less,swap) \
do { \
uint _j, _l; \
type x; \
swap(heap,1,num,x); \
num--; \
_j = 1; \
HEAP_BUBBLE_DOWN_J(heap,num,less,swap); \
} while(0)
/**
* Insert `heap[num]` in `O(log(n))` time. The value of @num must be increased before.
**/
#define HEAP_INSERT(heap,num,type,less,swap) \
do { \
uint _j, _u; \
type x; \
_j = num; \
HEAP_BUBBLE_UP_J(heap,num,less,swap); \
} while(0)
/**
* If you need to increase the value of `heap[pos]`, just do it and then call this macro to rebuild the heap.
* Only `heap[pos]` can be changed, the rest of the array must form a valid heap.
* The time complexity is `O(log(n))`.
**/
#define HEAP_INCREASE(heap,num,type,less,swap,pos) \
do { \
uint _j, _l; \
type x; \
_j = pos; \
HEAP_BUBBLE_DOWN_J(heap,num,less,swap); \
} while(0)
/**
* If you need to decrease the value of `heap[pos]`, just do it and then call this macro to rebuild the heap.
* Only `heap[pos]` can be changed, the rest of the array must form a valid heap.
* The time complexity is `O(log(n))`.
**/
#define HEAP_DECREASE(heap,num,type,less,swap,pos) \
do { \
uint _j, _u; \
type x; \
_j = pos; \
HEAP_BUBBLE_UP_J(heap,num,less,swap); \
} while(0)
/**
* Delete `heap[pos]` in `O(log(n))` time.
**/
#define HEAP_DELETE(heap,num,type,less,swap,pos) \
do { \
uint _j, _l, _u; \
type x; \
_j = pos; \
swap(heap,_j,num,x); \
num--; \
if (less(heap[_j], heap[num+1])) \
HEAP_BUBBLE_UP_J(heap,num,less,swap) \
else \
HEAP_BUBBLE_DOWN_J(heap,num,less,swap); \
} while(0)
/**
* Default swapping macro.
**/
#define HEAP_SWAP(heap,a,b,t) (t=heap[a], heap[a]=heap[b], heap[b]=t)
bird2-2.17.5/lib/heap_test.c 0000664 0000000 0000000 00000006520 15211753245 0015506 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Universal Heap Macros Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "sysdep/config.h"
#include "lib/heap.h"
#define MAX_NUM 1000
#define SPECIAL_KEY -3213
#define MY_CMP(x, y) ((x) < (y))
#define MY_HEAP_SWAP(heap,a,b,t) \
do { \
bt_debug("swap(%u %u) ", a, b); \
HEAP_SWAP(heap,a,b,t); \
} while(0)
static int heap[MAX_NUM+1];
static uint num;
/*
* A valid heap must follow these rules:
* - `num >= 0`
* - `heap[i] >= heap[i / 2]` for each `i` in `[2, num]`
*/
static int
is_heap_valid(int heap[], uint num)
{
uint i;
if (num > MAX_NUM)
return 0;
for (i = 2; i <= num; i++)
if (heap[i] < heap[i / 2])
return 0;
return 1;
}
static void
show_heap(void)
{
uint i;
bt_debug("\n");
bt_debug("numbers %u; ", num);
for (i = 0; i <= num; i++)
bt_debug("%d ", heap[i]);
bt_debug(is_heap_valid(heap, num) ? "OK" : "NON-VALID HEAP!");
bt_debug("\n");
}
static void
init_heap(void)
{
uint i;
num = 0;
heap[0] = SPECIAL_KEY; /* heap[0] should be unused */
for (i = 1; i <= MAX_NUM; i++)
heap[i] = 0;
}
static int
t_heap_insert(void)
{
uint i;
init_heap();
for (i = MAX_NUM; i >= 1; i--)
{
bt_debug("ins %u at pos %u ", i, MAX_NUM - i);
heap[MAX_NUM - i + 1] = i;
HEAP_INSERT(heap, ++num, int, MY_CMP, MY_HEAP_SWAP);
show_heap();
bt_assert(is_heap_valid(heap, num));
}
return 1;
}
static int
t_heap_increase_decrease(void)
{
uint i;
t_heap_insert();
for (i = 1; i <= MAX_NUM; i++)
{
if ((int)i > heap[i])
{
bt_debug("inc %u ", i);
heap[i] = i;
HEAP_INCREASE(heap, num, int, MY_CMP, MY_HEAP_SWAP, i);
}
else if ((int)i < heap[i])
{
bt_debug("dec %u ", i);
heap[i] = i;
HEAP_INCREASE(heap, num, int, MY_CMP, MY_HEAP_SWAP, i);
}
show_heap();
bt_assert(is_heap_valid(heap, num));
}
return 1;
}
static int
t_heap_delete(void)
{
uint i;
t_heap_insert();
for (i = 1; i <= num; i++)
{
bt_debug("del at pos %u ", i);
HEAP_DELETE(heap, num, int, MY_CMP, MY_HEAP_SWAP, i);
show_heap();
bt_assert(is_heap_valid(heap, num));
}
return 1;
}
static int
t_heap_0(void)
{
init_heap();
t_heap_insert();
t_heap_increase_decrease();
t_heap_delete();
return heap[0] == SPECIAL_KEY;
}
static int
t_heap_insert_random(void)
{
int i, j;
int expected[MAX_NUM+1];
init_heap();
for (i = 1; i <= MAX_NUM; i++)
{
heap[i] = expected[i] = bt_random();
HEAP_INSERT(heap, ++num, int, MY_CMP, MY_HEAP_SWAP);
show_heap();
bt_assert(is_heap_valid(heap, num));
}
for (i = 1; i <= MAX_NUM; i++)
for (j = 1; j <= MAX_NUM; j++)
if(expected[i] == heap[j])
break;
else if (j == MAX_NUM)
{
show_heap();
bt_abort_msg("Did not find a number %d in heap.", expected[i]);
}
return 1;
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_heap_insert, "Inserting a descending sequence of numbers (the worst case)");
bt_test_suite(t_heap_insert_random, "Inserting pseudo-random numbers");
bt_test_suite(t_heap_increase_decrease, "Increasing/Decreasing");
bt_test_suite(t_heap_delete, "Deleting");
bt_test_suite(t_heap_0, "Is a heap[0] really unused?");
return bt_exit_value();
}
bird2-2.17.5/lib/idm.c 0000664 0000000 0000000 00000002507 15211753245 0014304 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- ID Map
*
* (c) 2013--2015 Ondrej Zajicek
* (c) 2013--2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include
#include "nest/bird.h"
#include "lib/idm.h"
#include "lib/resource.h"
#include "lib/string.h"
void
idm_init(struct idm *m, pool *p, uint size)
{
m->pos = 0;
m->used = 1;
m->size = size;
m->data = mb_allocz(p, m->size * sizeof(u32));
/* ID 0 is reserved */
m->data[0] = 1;
}
static inline int u32_cto(uint x) { return ffs(~x) - 1; }
u32
idm_alloc(struct idm *m)
{
uint i, j;
for (i = m->pos; i < m->size; i++)
if (m->data[i] != 0xffffffff)
goto found;
/* If we are at least 7/8 full, expand */
if (m->used > (m->size * 28))
{
m->size *= 2;
m->data = mb_realloc(m->data, m->size * sizeof(u32));
memset(m->data + i, 0, (m->size - i) * sizeof(u32));
goto found;
}
for (i = 0; i < m->pos; i++)
if (m->data[i] != 0xffffffff)
goto found;
ASSERT(0);
found:
ASSERT(i < 0x8000000);
m->pos = i;
j = u32_cto(m->data[i]);
m->data[i] |= (1 << j);
m->used++;
return 32 * i + j;
}
void
idm_free(struct idm *m, u32 id)
{
uint i = id / 32;
uint j = id % 32;
ASSERT((i < m->size) && (m->data[i] & (1 << j)));
m->data[i] &= ~(1 << j);
m->used--;
}
bird2-2.17.5/lib/idm.h 0000664 0000000 0000000 00000000664 15211753245 0014313 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- ID Map
*
* (c) 2013--2015 Ondrej Zajicek
* (c) 2013--2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_IDM_H_
#define _BIRD_IDM_H_
struct idm
{
u32 *data;
u32 pos;
u32 used;
u32 size;
};
void idm_init(struct idm *m, pool *p, uint size);
u32 idm_alloc(struct idm *m);
void idm_free(struct idm *m, u32 id);
#endif
bird2-2.17.5/lib/ip.c 0000664 0000000 0000000 00000045551 15211753245 0014151 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- IP address functions
*
* (c) 1998--2000 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
/**
* DOC: IP addresses
*
* BIRD uses its own abstraction of IP address in order to share the same
* code for both IPv4 and IPv6. IP addresses are represented as entities
* of type &ip_addr which are never to be treated as numbers and instead
* they must be manipulated using the following functions and macros.
*/
#include
#include "nest/bird.h"
#include "lib/ip.h"
int
ip6_compare(ip6_addr a, ip6_addr b)
{
int i;
for (i=0; i<4; i++)
if (a.addr[i] > b.addr[i])
return 1;
else if (a.addr[i] < b.addr[i])
return -1;
return 0;
}
ip6_addr
ip6_mkmask(uint n)
{
ip6_addr a;
int i;
for (i=0; i<4; i++)
{
if (!n)
a.addr[i] = 0;
else if (n >= 32)
{
a.addr[i] = ~0;
n -= 32;
}
else
{
a.addr[i] = u32_mkmask(n);
n = 0;
}
}
return a;
}
uint
ip6_masklen(ip6_addr *a)
{
int i, j, n;
for (i=0, n=0; i<4; i++, n+=32)
if (a->addr[i] != ~0U)
{
j = u32_masklen(a->addr[i]);
if (j == 255)
return j;
n += j;
while (++i < 4)
if (a->addr[i])
return 255;
break;
}
return n;
}
int
ip4_classify(ip4_addr ad)
{
u32 a = _I(ad);
u32 b = a >> 24U;
if (b < 0xe0)
{
if (b == 0x00) /* 0.0.0.0/8 This network */
return IADDR_INVALID;
if (b == 0x7f) /* 127.0.0.0/8 Loopback address */
return IADDR_HOST | SCOPE_HOST;
if ((b == 0x0a) || /* 10.0.0.0/8 Private range */
((a & 0xffff0000) == 0xc0a80000) || /* 192.168.0.0/16 Private range */
((a & 0xfff00000) == 0xac100000)) /* 172.16.0.0/12 Private range */
return IADDR_HOST | SCOPE_SITE;
return IADDR_HOST | SCOPE_UNIVERSE;
}
if (b < 0xf0) /* 224.0.0.0/4 Multicast address */
return IADDR_MULTICAST | SCOPE_UNIVERSE;
if (a == 0xffffffff) /* 255.255.255.255 Broadcast address */
return IADDR_BROADCAST | SCOPE_LINK;
return IADDR_HOST | SCOPE_SITE; /* 240.0.0.0/4 Reserved / private */
}
int
ip6_classify(ip6_addr *a)
{
u32 x = a->addr[0];
if ((x & 0xe0000000) == 0x20000000) /* 2000::/3 Aggregatable Global Unicast Address */
return IADDR_HOST | SCOPE_UNIVERSE;
if ((x & 0xffc00000) == 0xfe800000) /* fe80::/10 Link-Local Address */
return IADDR_HOST | SCOPE_LINK;
if ((x & 0xffc00000) == 0xfec00000) /* fec0::/10 Site-Local Address */
return IADDR_HOST | SCOPE_SITE;
if ((x & 0xfe000000) == 0xfc000000) /* fc00::/7 Unique Local Unicast Address (RFC 4193) */
return IADDR_HOST | SCOPE_SITE;
if ((x & 0xff000000) == 0xff000000) /* ff00::/8 Multicast Address */
{
uint scope = (x >> 16) & 0x0f;
switch (scope)
{
case 1: return IADDR_MULTICAST | SCOPE_HOST;
case 2: return IADDR_MULTICAST | SCOPE_LINK;
case 5: return IADDR_MULTICAST | SCOPE_SITE;
case 8: return IADDR_MULTICAST | SCOPE_ORGANIZATION;
case 14: return IADDR_MULTICAST | SCOPE_UNIVERSE;
default: return IADDR_MULTICAST | SCOPE_UNDEFINED;
}
}
if (!x && !a->addr[1])
{
u32 a2 = a->addr[2];
u32 a3 = a->addr[3];
if (a2 == 0 && a3 == 1)
return IADDR_HOST | SCOPE_HOST; /* Loopback address */
if (a2 == 0)
return ip4_classify(_MI4(a3)); /* IPv4 compatible addresses */
if (a2 == 0xffff)
return ip4_classify(_MI4(a3)); /* IPv4 mapped addresses */
return IADDR_INVALID;
}
return IADDR_HOST | SCOPE_UNDEFINED;
}
/*
* IPv6 bit shifting
*/
ip6_addr
ip6_shift_left(ip6_addr a, uint bits)
{
if (bits == 0)
return a;
if (bits > 127)
return IP6_NONE;
int words = bits / 32;
int rem = bits % 32;
for (int i = 0; i < 3 - words; i++)
a.addr[i] = (a.addr[i + words] << rem) |
(rem ? (a.addr[i + words + 1] >> (32 - rem)) : 0);
a.addr[3 - words] = a.addr[3] << rem;
memset(&a.addr[4 - words], 0, words * 4);
return a;
}
ip6_addr
ip6_shift_right(ip6_addr a, uint bits)
{
if (bits == 0)
return a;
if (bits > 127)
return IP6_NONE;
int words = bits / 32;
int rem = bits % 32;
for (int i = 3; i > words; i--)
a.addr[i] = (a.addr[i - words] >> rem) |
(rem ? (a.addr[i - words - 1] << (32 - rem)) : 0);
a.addr[words] = a.addr[0] >> rem;
memset(&a.addr[0], 0, words * 4);
return a;
}
static const char numbers[] = {
'0', 0, 0, 0, '1', 0, 0, 0, '2', 0, 0, 0, '3', 0, 0, 0, '4', 0, 0, 0, '5', 0, 0, 0, '6', 0, 0, 0, '7', 0, 0, 0,
'8', 0, 0, 0, '9', 0, 0, 0, '1', '0', 0, 0, '1', '1', 0, 0, '1', '2', 0, 0, '1', '3', 0, 0, '1', '4', 0, 0, '1', '5', 0, 0,
'1', '6', 0, 0, '1', '7', 0, 0, '1', '8', 0, 0, '1', '9', 0, 0, '2', '0', 0, 0, '2', '1', 0, 0, '2', '2', 0, 0, '2', '3', 0, 0,
'2', '4', 0, 0, '2', '5', 0, 0, '2', '6', 0, 0, '2', '7', 0, 0, '2', '8', 0, 0, '2', '9', 0, 0, '3', '0', 0, 0, '3', '1', 0, 0,
'3', '2', 0, 0, '3', '3', 0, 0, '3', '4', 0, 0, '3', '5', 0, 0, '3', '6', 0, 0, '3', '7', 0, 0, '3', '8', 0, 0, '3', '9', 0, 0,
'4', '0', 0, 0, '4', '1', 0, 0, '4', '2', 0, 0, '4', '3', 0, 0, '4', '4', 0, 0, '4', '5', 0, 0, '4', '6', 0, 0, '4', '7', 0, 0,
'4', '8', 0, 0, '4', '9', 0, 0, '5', '0', 0, 0, '5', '1', 0, 0, '5', '2', 0, 0, '5', '3', 0, 0, '5', '4', 0, 0, '5', '5', 0, 0,
'5', '6', 0, 0, '5', '7', 0, 0, '5', '8', 0, 0, '5', '9', 0, 0, '6', '0', 0, 0, '6', '1', 0, 0, '6', '2', 0, 0, '6', '3', 0, 0,
'6', '4', 0, 0, '6', '5', 0, 0, '6', '6', 0, 0, '6', '7', 0, 0, '6', '8', 0, 0, '6', '9', 0, 0, '7', '0', 0, 0, '7', '1', 0, 0,
'7', '2', 0, 0, '7', '3', 0, 0, '7', '4', 0, 0, '7', '5', 0, 0, '7', '6', 0, 0, '7', '7', 0, 0, '7', '8', 0, 0, '7', '9', 0, 0,
'8', '0', 0, 0, '8', '1', 0, 0, '8', '2', 0, 0, '8', '3', 0, 0, '8', '4', 0, 0, '8', '5', 0, 0, '8', '6', 0, 0, '8', '7', 0, 0,
'8', '8', 0, 0, '8', '9', 0, 0, '9', '0', 0, 0, '9', '1', 0, 0, '9', '2', 0, 0, '9', '3', 0, 0, '9', '4', 0, 0, '9', '5', 0, 0,
'9', '6', 0, 0, '9', '7', 0, 0, '9', '8', 0, 0, '9', '9', 0, 0, '1', '0', '0', 0, '1', '0', '1', 0, '1', '0', '2', 0, '1', '0', '3', 0,
'1', '0', '4', 0, '1', '0', '5', 0, '1', '0', '6', 0, '1', '0', '7', 0, '1', '0', '8', 0, '1', '0', '9', 0, '1', '1', '0', 0, '1', '1', '1', 0,
'1', '1', '2', 0, '1', '1', '3', 0, '1', '1', '4', 0, '1', '1', '5', 0, '1', '1', '6', 0, '1', '1', '7', 0, '1', '1', '8', 0, '1', '1', '9', 0,
'1', '2', '0', 0, '1', '2', '1', 0, '1', '2', '2', 0, '1', '2', '3', 0, '1', '2', '4', 0, '1', '2', '5', 0, '1', '2', '6', 0, '1', '2', '7', 0,
'1', '2', '8', 0, '1', '2', '9', 0, '1', '3', '0', 0, '1', '3', '1', 0, '1', '3', '2', 0, '1', '3', '3', 0, '1', '3', '4', 0, '1', '3', '5', 0,
'1', '3', '6', 0, '1', '3', '7', 0, '1', '3', '8', 0, '1', '3', '9', 0, '1', '4', '0', 0, '1', '4', '1', 0, '1', '4', '2', 0, '1', '4', '3', 0,
'1', '4', '4', 0, '1', '4', '5', 0, '1', '4', '6', 0, '1', '4', '7', 0, '1', '4', '8', 0, '1', '4', '9', 0, '1', '5', '0', 0, '1', '5', '1', 0,
'1', '5', '2', 0, '1', '5', '3', 0, '1', '5', '4', 0, '1', '5', '5', 0, '1', '5', '6', 0, '1', '5', '7', 0, '1', '5', '8', 0, '1', '5', '9', 0,
'1', '6', '0', 0, '1', '6', '1', 0, '1', '6', '2', 0, '1', '6', '3', 0, '1', '6', '4', 0, '1', '6', '5', 0, '1', '6', '6', 0, '1', '6', '7', 0,
'1', '6', '8', 0, '1', '6', '9', 0, '1', '7', '0', 0, '1', '7', '1', 0, '1', '7', '2', 0, '1', '7', '3', 0, '1', '7', '4', 0, '1', '7', '5', 0,
'1', '7', '6', 0, '1', '7', '7', 0, '1', '7', '8', 0, '1', '7', '9', 0, '1', '8', '0', 0, '1', '8', '1', 0, '1', '8', '2', 0, '1', '8', '3', 0,
'1', '8', '4', 0, '1', '8', '5', 0, '1', '8', '6', 0, '1', '8', '7', 0, '1', '8', '8', 0, '1', '8', '9', 0, '1', '9', '0', 0, '1', '9', '1', 0,
'1', '9', '2', 0, '1', '9', '3', 0, '1', '9', '4', 0, '1', '9', '5', 0, '1', '9', '6', 0, '1', '9', '7', 0, '1', '9', '8', 0, '1', '9', '9', 0,
'2', '0', '0', 0, '2', '0', '1', 0, '2', '0', '2', 0, '2', '0', '3', 0, '2', '0', '4', 0, '2', '0', '5', 0, '2', '0', '6', 0, '2', '0', '7', 0,
'2', '0', '8', 0, '2', '0', '9', 0, '2', '1', '0', 0, '2', '1', '1', 0, '2', '1', '2', 0, '2', '1', '3', 0, '2', '1', '4', 0, '2', '1', '5', 0,
'2', '1', '6', 0, '2', '1', '7', 0, '2', '1', '8', 0, '2', '1', '9', 0, '2', '2', '0', 0, '2', '2', '1', 0, '2', '2', '2', 0, '2', '2', '3', 0,
'2', '2', '4', 0, '2', '2', '5', 0, '2', '2', '6', 0, '2', '2', '7', 0, '2', '2', '8', 0, '2', '2', '9', 0, '2', '3', '0', 0, '2', '3', '1', 0,
'2', '3', '2', 0, '2', '3', '3', 0, '2', '3', '4', 0, '2', '3', '5', 0, '2', '3', '6', 0, '2', '3', '7', 0, '2', '3', '8', 0, '2', '3', '9', 0,
'2', '4', '0', 0, '2', '4', '1', 0, '2', '4', '2', 0, '2', '4', '3', 0, '2', '4', '4', 0, '2', '4', '5', 0, '2', '4', '6', 0, '2', '4', '7', 0,
'2', '4', '8', 0, '2', '4', '9', 0, '2', '5', '0', 0, '2', '5', '1', 0, '2', '5', '2', 0, '2', '5', '3', 0, '2', '5', '4', 0, '2', '5', '5', 0,
};
static inline char *
print_u8(char *s, u8 n)
{
memcpy(s, numbers + n * 4, 4);
return s + 1 + (n >= 10) + (n >= 100);
}
char *
ip4_ntop(ip4_addr a, char *b)
{
u32 x = _I(a);
b = print_u8(b, (x >> 24) & 0xff);
*b++ = '.';
b = print_u8(b, (x >> 16) & 0xff);
*b++ = '.';
b = print_u8(b, (x >> 8) & 0xff);
*b++ = '.';
b = print_u8(b, x & 0xff);
return b;
}
char *
ip4_px_ntop(ip4_addr a, int len, char *b)
{
u32 x = _I(a);
b = print_u8(b, (x >> 24) & 0xff);
*b++ = '.';
b = print_u8(b, (x >> 16) & 0xff);
*b++ = '.';
b = print_u8(b, (x >> 8) & 0xff);
*b++ = '.';
b = print_u8(b, x & 0xff);
*b++ = '/';
b = print_u8(b, len & 0xff);
return b;
}
/*
* Conversion of IPv6 address to presentation format and vice versa.
* Heavily inspired by routines written by Paul Vixie for the BIND project
* and of course by RFC 2373.
*/
char *
ip6_ntop(ip6_addr a, char *b)
{
u16 words[8];
int bestpos, bestlen, curpos, curlen, i;
/* First of all, preprocess the address and find the longest run of zeros */
bestlen = bestpos = curpos = curlen = 0;
for (i=0; i<8; i++)
{
u32 x = a.addr[i/2];
words[i] = ((i%2) ? x : (x >> 16)) & 0xffff;
if (words[i])
curlen = 0;
else
{
if (!curlen)
curpos = i;
curlen++;
if (curlen > bestlen)
{
bestpos = curpos;
bestlen = curlen;
}
}
}
if (bestlen < 2)
bestpos = -1;
/* Is it an encapsulated IPv4 address? */
if (!bestpos && ((bestlen == 5 && a.addr[2] == 0xffff) || (bestlen == 6)))
{
u32 x = a.addr[3];
b += bsprintf(b, "::%s%d.%d.%d.%d",
a.addr[2] ? "ffff:" : "",
(x >> 24) & 0xff,
(x >> 16) & 0xff,
(x >> 8) & 0xff,
x & 0xff);
return b;
}
/* Normal IPv6 formatting, compress the largest sequence of zeros */
for (i=0; i<8; i++)
{
if (i == bestpos)
{
i += bestlen - 1;
*b++ = ':';
if (i == 7)
*b++ = ':';
}
else
{
if (i)
*b++ = ':';
b += bsprintf(b, "%x", words[i]);
}
}
*b = 0;
return b;
}
int
ip4_pton(const char *a, ip4_addr *o)
{
int i;
unsigned long int l;
u32 ia = 0;
i=4;
while (i--)
{
char *d, *c = strchr(a, '.');
if (!c != !i)
return 0;
l = bstrtoul10(a, &d);
if (((d != c) && *d) || (l > 255))
return 0;
ia = (ia << 8) | l;
if (c)
c++;
a = c;
}
*o = ip4_from_u32(ia);
return 1;
}
int
ip6_pton(const char *a, ip6_addr *o)
{
u16 words[8];
int i, j, k, l, hfil;
const char *start;
if (!a[0]) /* Empty string check */
return 0;
if (a[0] == ':') /* Leading :: */
{
if (a[1] != ':')
return 0;
a++;
}
hfil = -1;
i = 0;
while (*a)
{
if (*a == ':') /* :: */
{
if (hfil >= 0)
return 0;
hfil = i;
a++;
continue;
}
j = 0;
l = 0;
start = a;
for (;;)
{
if (*a >= '0' && *a <= '9')
k = *a++ - '0';
else if (*a >= 'A' && *a <= 'F')
k = *a++ - 'A' + 10;
else if (*a >= 'a' && *a <= 'f')
k = *a++ - 'a' + 10;
else
break;
j = (j << 4) + k;
if (j >= 0x10000 || ++l > 4)
return 0;
}
if (*a == ':' && a[1])
a++;
else if (*a == '.' && (i == 6 || (i < 6 && hfil >= 0)))
{ /* Embedded IPv4 address */
ip4_addr x;
if (!ip4_pton(start, &x))
return 0;
words[i++] = _I(x) >> 16;
words[i++] = _I(x);
break;
}
else if (*a)
return 0;
if (i >= 8)
return 0;
words[i++] = j;
}
/* Replace :: with an appropriate number of zeros */
if (hfil >= 0)
{
j = 8 - i;
for (i=7; i-j >= hfil; i--)
words[i] = words[i-j];
for (; i>=hfil; i--)
words[i] = 0;
}
else if (i != 8) /* Incomplete address */
return 0;
/* Convert the address to ip6_addr format */
for (i=0; i<4; i++)
o->addr[i] = (words[2*i] << 16) | words[2*i+1];
return 1;
}
/**
* ip_scope_text - get textual representation of address scope
* @scope: scope (%SCOPE_xxx)
*
* Returns a pointer to a textual name of the scope given.
*/
char *
ip_scope_text(uint scope)
{
static char *scope_table[] = { "host", "link", "site", "org", "univ", "undef" };
if (scope > SCOPE_UNDEFINED)
return "?";
else
return scope_table[scope];
}
ip4_addr
ip4_class_mask(ip4_addr ad)
{
u32 m, a = _I(ad);
if (a == 0x00000000)
m = 0x00000000;
else if (a < 0x80000000)
m = 0xff000000;
else if (a < 0xc0000000)
m = 0xffff0000;
else
m = 0xffffff00;
if (a & ~m)
m = 0xffffffff;
return _MI4(m);
}
#if 0
/**
* ipa_equal - compare two IP addresses for equality
* @x: IP address
* @y: IP address
*
* ipa_equal() returns 1 if @x and @y represent the same IP address, else 0.
*/
int ipa_equal(ip_addr x, ip_addr y) { DUMMY }
/**
* ipa_nonzero - test if an IP address is defined
* @x: IP address
*
* ipa_nonzero returns 1 if @x is a defined IP address (not all bits are zero),
* else 0.
*
* The undefined all-zero address is reachable as a |IPA_NONE| macro.
*/
int ipa_nonzero(ip_addr x) { DUMMY }
/**
* ipa_and - compute bitwise and of two IP addresses
* @x: IP address
* @y: IP address
*
* This function returns a bitwise and of @x and @y. It's primarily
* used for network masking.
*/
ip_addr ipa_and(ip_addr x, ip_addr y) { DUMMY }
/**
* ipa_or - compute bitwise or of two IP addresses
* @x: IP address
* @y: IP address
*
* This function returns a bitwise or of @x and @y.
*/
ip_addr ipa_or(ip_addr x, ip_addr y) { DUMMY }
/**
* ipa_xor - compute bitwise xor of two IP addresses
* @x: IP address
* @y: IP address
*
* This function returns a bitwise xor of @x and @y.
*/
ip_addr ipa_xor(ip_addr x, ip_addr y) { DUMMY }
/**
* ipa_not - compute bitwise negation of two IP addresses
* @x: IP address
*
* This function returns a bitwise negation of @x.
*/
ip_addr ipa_not(ip_addr x) { DUMMY }
/**
* ipa_mkmask - create a netmask
* @x: prefix length
*
* This function returns an &ip_addr corresponding of a netmask
* of an address prefix of size @x.
*/
ip_addr ipa_mkmask(int x) { DUMMY }
/**
* ipa_masklen - calculate netmask length
* @x: IP address
*
* This function checks whether @x represents a valid netmask and
* returns the size of the associate network prefix or -1 for invalid
* mask.
*/
int ipa_masklen(ip_addr x) { DUMMY }
/**
* ipa_hash - hash IP addresses
* @x: IP address
*
* ipa_hash() returns a 16-bit hash value of the IP address @x.
*/
int ipa_hash(ip_addr x) { DUMMY }
/**
* ipa_hton - convert IP address to network order
* @x: IP address
*
* Converts the IP address @x to the network byte order.
*
* Beware, this is a macro and it alters the argument!
*/
void ipa_hton(ip_addr x) { DUMMY }
/**
* ipa_ntoh - convert IP address to host order
* @x: IP address
*
* Converts the IP address @x from the network byte order.
*
* Beware, this is a macro and it alters the argument!
*/
void ipa_ntoh(ip_addr x) { DUMMY }
/**
* ipa_classify - classify an IP address
* @x: IP address
*
* ipa_classify() returns an address class of @x, that is a bitwise or
* of address type (%IADDR_INVALID, %IADDR_HOST, %IADDR_BROADCAST, %IADDR_MULTICAST)
* with address scope (%SCOPE_HOST to %SCOPE_UNIVERSE) or -1 (%IADDR_INVALID)
* for an invalid address.
*/
int ipa_classify(ip_addr x) { DUMMY }
/**
* ip4_class_mask - guess netmask according to address class
* @x: IPv4 address
*
* This function (available in IPv4 version only) returns a
* network mask according to the address class of @x. Although
* classful addressing is nowadays obsolete, there still live
* routing protocols transferring no prefix lengths nor netmasks
* and this function could be useful to them.
*/
ip4_addr ip4_class_mask(ip4_addr x) { DUMMY }
/**
* ipa_from_u32 - convert IPv4 address to an integer
* @x: IP address
*
* This function takes an IPv4 address and returns its numeric
* representation.
*/
u32 ipa_from_u32(ip_addr x) { DUMMY }
/**
* ipa_to_u32 - convert integer to IPv4 address
* @x: a 32-bit integer
*
* ipa_to_u32() takes a numeric representation of an IPv4 address
* and converts it to the corresponding &ip_addr.
*/
ip_addr ipa_to_u32(u32 x) { DUMMY }
/**
* ipa_compare - compare two IP addresses for order
* @x: IP address
* @y: IP address
*
* The ipa_compare() function takes two IP addresses and returns
* -1 if @x is less than @y in canonical ordering (lexicographical
* order of the bit strings), 1 if @x is greater than @y and 0
* if they are the same.
*/
int ipa_compare(ip_addr x, ip_addr y) { DUMMY }
/**
* ipa_build6 - build an IPv6 address from parts
* @a1: part #1
* @a2: part #2
* @a3: part #3
* @a4: part #4
*
* ipa_build() takes @a1 to @a4 and assembles them to a single IPv6
* address. It's used for example when a protocol wants to bind its
* socket to a hard-wired multicast address.
*/
ip_addr ipa_build6(u32 a1, u32 a2, u32 a3, u32 a4) { DUMMY }
/**
* ip_ntop - convert IP address to textual representation
* @a: IP address
* @buf: buffer of size at least %STD_ADDRESS_P_LENGTH
*
* This function takes an IP address and creates its textual
* representation for presenting to the user.
*/
char *ip_ntop(ip_addr a, char *buf) { DUMMY }
/**
* ip_ntox - convert IP address to hexadecimal representation
* @a: IP address
* @buf: buffer of size at least %STD_ADDRESS_P_LENGTH
*
* This function takes an IP address and creates its hexadecimal
* textual representation. Primary use: debugging dumps.
*/
char *ip_ntox(ip_addr a, char *buf) { DUMMY }
/**
* ip_pton - parse textual representation of IP address
* @a: textual representation
* @o: where to put the resulting address
*
* This function parses a textual IP address representation and
* stores the decoded address to a variable pointed to by @o.
* Returns 0 if a parse error has occurred, else 0.
*/
int ip_pton(char *a, ip_addr *o) { DUMMY }
#endif
bird2-2.17.5/lib/ip.h 0000664 0000000 0000000 00000032073 15211753245 0014151 0 ustar 00root root 0000000 0000000 /*
* BIRD Internet Routing Daemon -- The Internet Protocol
*
* (c) 1998 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_IP_H_
#define _BIRD_IP_H_
#include "sysdep/unix/endian.h"
#include "lib/string.h"
#include "lib/bitops.h"
#include "lib/unaligned.h"
#define IP4_ALL_NODES ipa_build4(224, 0, 0, 1)
#define IP4_ALL_ROUTERS ipa_build4(224, 0, 0, 2)
#define IP4_OSPF_ALL_ROUTERS ipa_build4(224, 0, 0, 5)
#define IP4_OSPF_DES_ROUTERS ipa_build4(224, 0, 0, 6)
#define IP4_RIP_ROUTERS ipa_build4(224, 0, 0, 9)
#define IP6_ALL_NODES ipa_build6(0xFF020000, 0, 0, 1)
#define IP6_ALL_ROUTERS ipa_build6(0xFF020000, 0, 0, 2)
#define IP6_OSPF_ALL_ROUTERS ipa_build6(0xFF020000, 0, 0, 5)
#define IP6_OSPF_DES_ROUTERS ipa_build6(0xFF020000, 0, 0, 6)
#define IP6_RIP_ROUTERS ipa_build6(0xFF020000, 0, 0, 9)
#define IP6_BABEL_ROUTERS ipa_build6(0xFF020000, 0, 0, 0x00010006)
#define IP4_NONE _MI4(0)
#define IP6_NONE _MI6(0,0,0,0)
#define IP4_MAX_PREFIX_LENGTH 32
#define IP6_MAX_PREFIX_LENGTH 128
#define IP4_MAX_TEXT_LENGTH 15 /* "255.255.255.255" */
#define IP6_MAX_TEXT_LENGTH 39 /* "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" */
#define IPA_MAX_TEXT_LENGTH 39
#define IP4_MIN_MTU 576
#define IP6_MIN_MTU 1280
#define IP_PREC_INTERNET_CONTROL 0xc0
#define IP4_HEADER_LENGTH 20
#define IP6_HEADER_LENGTH 40
#define UDP_HEADER_LENGTH 8
#define MPLS_NULL 3
/* IANA Address Family Numbers */
/* https://www.iana.org/assignments/address-family-numbers/address-family-numbers.xhtml */
/* Would use AF_ prefix, but that collides with POSIX address family numbers */
#define AFI_IPV4 1
#define AFI_IPV6 2
#ifdef DEBUGGING
typedef struct ip4_addr {
u32 addr;
} ip4_addr;
#define _MI4(x) ((struct ip4_addr) { x })
#define _I(x) (x).addr
#else
typedef u32 ip4_addr;
#define _MI4(x) ((u32) (x))
#define _I(x) (x)
#endif
typedef struct ip6_addr {
u32 addr[4];
} ip6_addr;
#define _MI6(a,b,c,d) ((struct ip6_addr) {{ a, b, c, d }})
#define _I0(a) ((a).addr[0])
#define _I1(a) ((a).addr[1])
#define _I2(a) ((a).addr[2])
#define _I3(a) ((a).addr[3])
/* Structure ip_addr may contain both IPv4 and IPv6 addresses */
typedef ip6_addr ip_addr;
#define IPA_NONE IP6_NONE
#define ipa_from_ip4(x) _MI6(0,0,0xffff,_I(x))
#define ipa_from_ip6(x) x
#define ipa_from_u32(x) ipa_from_ip4(ip4_from_u32(x))
#define ipa_to_ip4(x) _MI4(_I3(x))
#define ipa_to_ip6(x) x
#define ipa_to_u32(x) ip4_to_u32(ipa_to_ip4(x))
#define ipa_is_ip4(a) ip6_is_v4mapped(a)
#define ipa_is_ip6(a) (! ip6_is_v4mapped(a))
#define IPA_NONE4 ipa_from_ip4(IP4_NONE)
#define IPA_NONE6 ipa_from_ip6(IP6_NONE)
/*
* Public constructors
*/
#define ip4_from_u32(x) _MI4(x)
#define ip4_to_u32(x) _I(x)
#define ip4_build(a,b,c,d) _MI4(((a) << 24) | ((b) << 16) | ((c) << 8) | (d))
#define ip6_build(a,b,c,d) _MI6(a,b,c,d)
#define ipa_build4(a,b,c,d) ipa_from_ip4(ip4_build(a,b,c,d))
#define ipa_build6(a,b,c,d) ipa_from_ip6(ip6_build(a,b,c,d))
/*
* Basic algebraic functions
*/
static inline int ip4_equal(ip4_addr a, ip4_addr b)
{ return _I(a) == _I(b); }
static inline int ip4_zero(ip4_addr a)
{ return _I(a) == 0; }
static inline int ip4_nonzero(ip4_addr a)
{ return _I(a) != 0; }
static inline ip4_addr ip4_and(ip4_addr a, ip4_addr b)
{ return _MI4(_I(a) & _I(b)); }
static inline ip4_addr ip4_or(ip4_addr a, ip4_addr b)
{ return _MI4(_I(a) | _I(b)); }
static inline ip4_addr ip4_xor(ip4_addr a, ip4_addr b)
{ return _MI4(_I(a) ^ _I(b)); }
static inline ip4_addr ip4_not(ip4_addr a)
{ return _MI4(~_I(a)); }
static inline int ip6_equal(ip6_addr a, ip6_addr b)
{ return _I0(a) == _I0(b) && _I1(a) == _I1(b) && _I2(a) == _I2(b) && _I3(a) == _I3(b); }
static inline int ip6_zero(ip6_addr a)
{ return !_I0(a) && !_I1(a) && !_I2(a) && !_I3(a); }
static inline int ip6_nonzero(ip6_addr a)
{ return _I0(a) || _I1(a) || _I2(a) || _I3(a); }
static inline ip6_addr ip6_and(ip6_addr a, ip6_addr b)
{ return _MI6(_I0(a) & _I0(b), _I1(a) & _I1(b), _I2(a) & _I2(b), _I3(a) & _I3(b)); }
static inline ip6_addr ip6_or(ip6_addr a, ip6_addr b)
{ return _MI6(_I0(a) | _I0(b), _I1(a) | _I1(b), _I2(a) | _I2(b), _I3(a) | _I3(b)); }
static inline ip6_addr ip6_xor(ip6_addr a, ip6_addr b)
{ return _MI6(_I0(a) ^ _I0(b), _I1(a) ^ _I1(b), _I2(a) ^ _I2(b), _I3(a) ^ _I3(b)); }
static inline ip6_addr ip6_not(ip6_addr a)
{ return _MI6(~_I0(a), ~_I1(a), ~_I2(a), ~_I3(a)); }
#define ipa_equal(x,y) ip6_equal(x,y)
#define ipa_zero(x) ip6_zero(x)
#define ipa_nonzero(x) ip6_nonzero(x)
#define ipa_and(x,y) ip6_and(x,y)
#define ipa_or(x,y) ip6_or(x,y)
#define ipa_xor(x,y) ip6_xor(x,y)
#define ipa_not(x) ip6_not(x)
/* Compare addresses when zero address works like a wildcard */
static inline int ipa_equal_wildcard(ip_addr x, ip_addr y)
{ return ipa_zero(x) || ipa_zero(y) || ipa_equal(x, y); }
/*
* A zero address is either a token for invalid/unused, or the prefix of default
* routes. These functions should be used in the second case, where both IPv4
* and IPv6 zero addresses should be checked.
*/
static inline int ipa_zero2(ip_addr a)
{ return !_I0(a) && !_I1(a) && ((_I2(a) == 0) || (_I2(a) == 0xffff)) && !_I3(a); }
static inline int ipa_nonzero2(ip_addr a)
{ return _I0(a) || _I1(a) || ((_I2(a) != 0) && (_I2(a) != 0xffff)) || _I3(a); }
/*
* Hash and compare functions
*/
static inline u64 ip4_hash0(ip4_addr a, u32 p, u64 acc)
{ return (acc + _I(a)) * p; }
static inline u32 ip4_hash(ip4_addr a)
{
// return hash_value(ip4_hash0(a, HASH_PARAM, 0));
/* For some reason, the old hash works slightly better */
return u32_hash(_I(a));
}
static inline u64 ip6_hash0(ip6_addr a, u32 p, u64 acc)
{
acc += _I0(a); acc *= p;
acc += _I1(a); acc *= p;
acc += _I2(a); acc *= p;
acc += _I3(a); acc *= p;
return acc;
}
static inline u32 ip6_hash(ip6_addr a)
{
// return hash_value(ip6_hash0(a, HASH_PARAM, 0));
/* Just use the expanded form */
u64 acc =
_I0(a) * HASH_PARAM4 +
_I1(a) * HASH_PARAM3 +
_I2(a) * HASH_PARAM2 +
_I3(a) * HASH_PARAM1;
return hash_value(acc);
}
static inline int ip4_compare(ip4_addr a, ip4_addr b)
{ return (_I(a) > _I(b)) - (_I(a) < _I(b)); }
int ip6_compare(ip6_addr a, ip6_addr b);
#define ipa_hash(x) ip6_hash(x)
#define ipa_compare(x,y) ip6_compare(x,y)
/*
* IP address classification
*/
/* Address class */
#define IADDR_INVALID -1
#define IADDR_SCOPE_MASK 0xfff
#define IADDR_HOST 0x1000
#define IADDR_BROADCAST 0x2000
#define IADDR_MULTICAST 0x4000
/* Address scope */
#define SCOPE_HOST 0
#define SCOPE_LINK 1
#define SCOPE_SITE 2
#define SCOPE_ORGANIZATION 3
#define SCOPE_UNIVERSE 4
#define SCOPE_UNDEFINED 5
int ip4_classify(ip4_addr ad);
int ip6_classify(ip6_addr *a);
static inline int ip6_is_link_local(ip6_addr a)
{ return (_I0(a) & 0xffc00000) == 0xfe800000; }
static inline int ip6_is_v4mapped(ip6_addr a)
{ return _I0(a) == 0 && _I1(a) == 0 && _I2(a) == 0xffff; }
#define ipa_classify(x) ip6_classify(&(x))
#define ipa_is_link_local(x) ip6_is_link_local(x)
static inline int ip4_is_unicast(ip4_addr a)
{ return _I(a) < 0xe0000000; }
/* XXXX remove */
static inline int ipa_classify_net(ip_addr a)
{ return ipa_zero2(a) ? (IADDR_HOST | SCOPE_UNIVERSE) : ipa_classify(a); }
/*
* Miscellaneous IP prefix manipulation
*/
static inline ip4_addr ip4_mkmask(uint n)
{ return _MI4(u32_mkmask(n)); }
static inline uint ip4_masklen(ip4_addr a)
{ return u32_masklen(_I(a)); }
ip6_addr ip6_mkmask(uint n);
uint ip6_masklen(ip6_addr *a);
/* ipX_pxlen() requires that x != y */
static inline uint ip4_pxlen(ip4_addr a, ip4_addr b)
{ return 31 - u32_log2(_I(a) ^ _I(b)); }
static inline uint ip6_pxlen(ip6_addr a, ip6_addr b)
{
int i = 0;
i += (a.addr[i] == b.addr[i]);
i += (a.addr[i] == b.addr[i]);
i += (a.addr[i] == b.addr[i]);
i += (a.addr[i] == b.addr[i]);
return 32 * i + 31 - u32_log2(a.addr[i] ^ b.addr[i]);
}
static inline int ip4_prefix_equal(ip4_addr a, ip4_addr b, uint n)
{
return (_I(a) ^ _I(b)) < ((u64) 1 << (32 - n));
}
static inline int ip6_prefix_equal(ip6_addr a, ip6_addr b, uint n)
{
uint n0 = n / 32;
uint n1 = n % 32;
return
((n0 <= 0) || (_I0(a) == _I0(b))) &&
((n0 <= 1) || (_I1(a) == _I1(b))) &&
((n0 <= 2) || (_I2(a) == _I2(b))) &&
((n0 <= 3) || (_I3(a) == _I3(b))) &&
(!n1 || ((a.addr[n0] ^ b.addr[n0]) < (1u << (32 - n1))));
}
static inline u32 ip4_getbit(ip4_addr a, uint pos)
{ return (_I(a) >> (31 - pos)) & 1; }
static inline u32 ip4_getbits(ip4_addr a, uint pos, uint n)
{ return (_I(a) >> ((32 - n) - pos)) & ((1u << n) - 1); }
static inline u32 ip6_getbit(ip6_addr a, uint pos)
{ return (a.addr[pos / 32] >> (31 - (pos % 32))) & 0x1; }
static inline u32 ip6_getbits(ip6_addr a, uint pos, uint n)
{ return (a.addr[pos / 32] >> ((32 - n) - (pos % 32))) & ((1u << n) - 1); }
static inline u32 ip4_setbit(ip4_addr *a, uint pos)
{ return _I(*a) |= (0x80000000 >> pos); }
static inline u32 ip6_setbit(ip6_addr *a, uint pos)
{ return a->addr[pos / 32] |= (0x80000000 >> (pos % 32)); }
static inline u32 ip4_clrbit(ip4_addr *a, uint pos)
{ return _I(*a) &= ~(0x80000000 >> pos); }
static inline u32 ip6_clrbit(ip6_addr *a, uint pos)
{ return a->addr[pos / 32] &= ~(0x80000000 >> (pos % 32)); }
static inline ip4_addr ip4_setbits(ip4_addr a, uint pos, uint val)
{ _I(a) |= val << (31 - pos); return a; }
static inline ip6_addr ip6_setbits(ip6_addr a, uint pos, uint val)
{ a.addr[pos / 32] |= val << (31 - pos % 32); return a; }
ip6_addr ip6_shift_left(ip6_addr a, uint bits);
ip6_addr ip6_shift_right(ip6_addr a, uint bits);
static inline ip4_addr ip4_opposite_m1(ip4_addr a)
{ return _MI4(_I(a) ^ 1); }
static inline ip4_addr ip4_opposite_m2(ip4_addr a)
{ return _MI4(_I(a) ^ 3); }
static inline ip6_addr ip6_opposite_m1(ip6_addr a)
{ return _MI6(_I0(a), _I1(a), _I2(a), _I3(a) ^ 1); }
static inline ip6_addr ip6_opposite_m2(ip6_addr a)
{ return _MI6(_I0(a), _I1(a), _I2(a), _I3(a) ^ 3); }
ip4_addr ip4_class_mask(ip4_addr ad);
#define ipa_opposite_m1(x) ip6_opposite_m1(x)
#define ipa_opposite_m2(x) ip6_opposite_m2(x)
/*
* Host/network order conversions
*/
static inline ip4_addr ip4_hton(ip4_addr a)
{ return _MI4(htonl(_I(a))); }
static inline ip4_addr ip4_ntoh(ip4_addr a)
{ return _MI4(ntohl(_I(a))); }
static inline ip6_addr ip6_hton(ip6_addr a)
{ return _MI6(htonl(_I0(a)), htonl(_I1(a)), htonl(_I2(a)), htonl(_I3(a))); }
static inline ip6_addr ip6_ntoh(ip6_addr a)
{ return _MI6(ntohl(_I0(a)), ntohl(_I1(a)), ntohl(_I2(a)), ntohl(_I3(a))); }
/*
* Unaligned data access (in network order)
*/
static inline ip4_addr get_ip4(const void *buf)
{
return _MI4(get_u32(buf));
}
static inline ip6_addr get_ip6(const void *buf)
{
ip6_addr a;
memcpy(&a, buf, 16);
return ip6_ntoh(a);
}
static inline void * put_ip4(void *buf, ip4_addr a)
{
put_u32(buf, _I(a));
return buf+4;
}
static inline void * put_ip6(void *buf, ip6_addr a)
{
a = ip6_hton(a);
memcpy(buf, &a, 16);
return buf+16;
}
/*
* Binary/text form conversions
*/
#define IP4_BUFFER_SIZE 16 /* Required buffer for ip4_ntop() */
#define IP4_PX_BUFFER_SIZE 20 /* Required buffer for ip4_ntop_px() */
char *ip4_ntop(ip4_addr a, char *b);
char *ip6_ntop(ip6_addr a, char *b);
char *ip4_px_ntop(ip4_addr a, int len, char *b);
static inline char * ip4_ntox(ip4_addr a, char *b)
{ return b + bsprintf(b, "%08x", _I(a)); }
static inline char * ip6_ntox(ip6_addr a, char *b)
{ return b + bsprintf(b, "%08x.%08x.%08x.%08x", _I0(a), _I1(a), _I2(a), _I3(a)); }
int ip4_pton(const char *a, ip4_addr *o);
int ip6_pton(const char *a, ip6_addr *o);
/*
* Miscellaneous
*/
char *ip_scope_text(uint);
/*
* MPLS labels
*/
#define MPLS_MAX_LABEL 0x100000
#define MPLS_MAX_LABEL_STACK 8
#define MPLS_MAX_LABEL_STRING MPLS_MAX_LABEL_STACK*12 + 5
typedef struct mpls_label_stack {
uint len;
u32 stack[MPLS_MAX_LABEL_STACK];
} mpls_label_stack;
static inline int ACCESS_READ(1, 2)
mpls_get(const char *buf, int buflen, u32 *stack)
{
for (int i=0; (i> 12;
if (s & 0x100)
return i+1;
}
return -1;
}
static inline int
mpls_put(char *buf, int len, u32 *stack)
{
for (int i=0; i> 32, .lo = val }; }
static inline u64 rd_to_u64(vpn_rd rd)
{ return (((u64) rd.hi) << 32) | rd.lo; }
static inline int rd_equal(vpn_rd a, vpn_rd b)
{ return a.hi == b.hi && a.lo == b.lo; }
static inline int rd_zero(vpn_rd a)
{ return !a.hi && !a.lo; }
static inline int rd_nonzero(vpn_rd a)
{ return a.hi || a.lo; }
static inline int rd_compare(vpn_rd a, vpn_rd b)
{ return uint_cmp(a.hi, b.hi) ?: uint_cmp(a.lo, b.lo); }
static inline u64 rd_hash0(vpn_rd rd, u32 p, u64 acc)
{ return u32_hash0(rd.hi, p, u32_hash0(rd.lo, p, acc)); }
static inline vpn_rd get_rd(const void *buf)
{ return (vpn_rd) { .hi = get_u32(buf), .lo = get_u32(buf + 4) }; }
static inline void * put_rd(void *buf, vpn_rd rd)
{
put_u32(buf, rd.hi);
put_u32(buf+4, rd.lo);
return buf+8;
}
#endif
bird2-2.17.5/lib/ip_test.c 0000664 0000000 0000000 00000023342 15211753245 0015202 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- IP address functions Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "lib/ip.h"
#define IP4_MAX_LEN 16
static int
test_ip4_pton(void *out_, const void *in_, const void *expected_out_)
{
ip_addr *out = out_;
const char *in = in_;
const ip_addr *expected_out = expected_out_;
ip4_addr ip4;
if (expected_out)
{
bt_assert(ip4_pton(in, &ip4));
*out = ipa_from_ip4(ip4);
return ipa_equal(*out, *expected_out);
}
else
return !ip4_pton(in, &ip4);
}
static int
test_ip6_pton(void *out_, const void *in_, const void *expected_out_)
{
ip_addr *out = out_;
const char *in = in_;
const ip_addr *expected_out = expected_out_;
if (expected_out)
{
bt_assert(ip6_pton(in, out));
return ipa_equal(*out, *expected_out);
}
else
return !ip6_pton(in, out);
}
static int
t_ip4_pton(void)
{
struct bt_pair test_vectors[] = {
{
.in = "192.168.1.128",
.out = & ipa_build4(192, 168, 1, 128),
},
{
.in = "255.255.255.255",
.out = & ipa_build4(255, 255, 255, 255),
},
{
.in = "0.0.0.0",
.out = & ipa_build4(0, 0, 0, 0),
},
};
return bt_assert_batch(test_vectors, test_ip4_pton, bt_fmt_str, bt_fmt_ipa);
}
static int
t_ip6_pton(void)
{
struct bt_pair test_vectors[] = {
{
.in = "2001:0db8:0000:0000:0000:0000:1428:57ab",
.out = & ipa_build6(0x20010DB8, 0x00000000, 0x00000000, 0x142857AB),
},
{
.in = "2001:0db8:0000:0000:0000::1428:57ab",
.out = & ipa_build6(0x20010DB8, 0x00000000, 0x00000000, 0x142857AB),
},
{
.in = "2001:0db8::1428:57ab",
.out = & ipa_build6(0x20010DB8, 0x00000000, 0x00000000, 0x142857AB),
},
{
.in = "2001:db8::1428:57ab",
.out = & ipa_build6(0x20010DB8, 0x00000000, 0x00000000, 0x142857AB),
},
{
.in = "::1",
.out = & ipa_build6(0x00000000, 0x00000000, 0x00000000, 0x00000001),
},
{
.in = "::",
.out = & ipa_build6(0x00000000, 0x00000000, 0x00000000, 0x00000000),
},
{
.in = "2605:2700:0:3::4713:93e3",
.out = & ipa_build6(0x26052700, 0x00000003, 0x00000000, 0x471393E3),
},
{
.in = "2605:2700:0:3:4713:93e3",
.out = NULL,
},
{
.in = "2",
.out = NULL,
},
};
return bt_assert_batch(test_vectors, test_ip6_pton, bt_fmt_str, bt_fmt_ipa);
}
static int
test_ipa_ntop(void *out_, const void *in_, const void *expected_out_)
{
char *out = out_;
const ip_addr *in = in_;
const char *expected_out = expected_out_;
if (ipa_is_ip4(*in))
ip4_ntop(ipa_to_ip4(*in), out);
else
ip6_ntop(ipa_to_ip6(*in), out);
int result = strncmp(out, expected_out, ipa_is_ip4(*in) ? IP4_MAX_TEXT_LENGTH : IP6_MAX_TEXT_LENGTH) == 0;
return result;
}
static int
t_ip4_ntop(void)
{
struct bt_pair test_vectors[] = {
{
.in = & ipa_build4(192, 168, 1, 128),
.out = "192.168.1.128",
},
{
.in = & ipa_build4(255, 255, 255, 255),
.out = "255.255.255.255",
},
{
.in = & ipa_build4(0, 0, 0, 1),
.out = "0.0.0.1",
},
};
return bt_assert_batch(test_vectors, test_ipa_ntop, bt_fmt_ipa, bt_fmt_str);
}
static int
t_ip6_ntop(void)
{
struct bt_pair test_vectors[] = {
{
.in = & ipa_build6(0x20010DB8, 0x00000000, 0x00000000, 0x142857AB),
.out = "2001:db8::1428:57ab",
},
{
.in = & ipa_build6(0x26052700, 0x00000003, 0x00000000, 0x471393E3),
.out = "2605:2700:0:3::4713:93e3",
},
};
return bt_assert_batch(test_vectors, test_ipa_ntop, bt_fmt_ipa, bt_fmt_str);
}
static int
t_ip4_prefix_equal(void)
{
bt_assert( ip4_prefix_equal(ip4_from_u32(0x12345678), ip4_from_u32(0x1234ffff), 16));
bt_assert(!ip4_prefix_equal(ip4_from_u32(0x12345678), ip4_from_u32(0x1234ffff), 17));
bt_assert( ip4_prefix_equal(ip4_from_u32(0x12345678), ip4_from_u32(0x12345000), 21));
bt_assert(!ip4_prefix_equal(ip4_from_u32(0x12345678), ip4_from_u32(0x12345000), 22));
bt_assert( ip4_prefix_equal(ip4_from_u32(0x00000000), ip4_from_u32(0xffffffff), 0));
bt_assert( ip4_prefix_equal(ip4_from_u32(0x12345678), ip4_from_u32(0x12345678), 0));
bt_assert( ip4_prefix_equal(ip4_from_u32(0x12345678), ip4_from_u32(0x12345678), 32));
bt_assert(!ip4_prefix_equal(ip4_from_u32(0x12345678), ip4_from_u32(0x12345679), 32));
bt_assert(!ip4_prefix_equal(ip4_from_u32(0x12345678), ip4_from_u32(0x92345678), 32));
return 1;
}
static int
t_ip6_prefix_equal(void)
{
bt_assert( ip6_prefix_equal(ip6_build(0x20010db8, 0x12345678, 0x10101010, 0x20202020),
ip6_build(0x20010db8, 0x1234ffff, 0xfefefefe, 0xdcdcdcdc),
48));
bt_assert(!ip6_prefix_equal(ip6_build(0x20010db8, 0x12345678, 0x10101010, 0x20202020),
ip6_build(0x20010db8, 0x1234ffff, 0xfefefefe, 0xdcdcdcdc),
49));
bt_assert(!ip6_prefix_equal(ip6_build(0x20010db8, 0x12345678, 0x10101010, 0x20202020),
ip6_build(0x20020db8, 0x12345678, 0xfefefefe, 0xdcdcdcdc),
48));
bt_assert( ip6_prefix_equal(ip6_build(0x20010db8, 0x12345678, 0x10101010, 0x20202020),
ip6_build(0x20010db8, 0x12345678, 0xfefefefe, 0xdcdcdcdc),
64));
bt_assert(!ip6_prefix_equal(ip6_build(0x20010db8, 0x12345678, 0x10101010, 0x20202020),
ip6_build(0x20010db8, 0x1234567e, 0xfefefefe, 0xdcdcdcdc),
64));
bt_assert( ip6_prefix_equal(ip6_build(0x20010db8, 0x12345678, 0x10101010, 0x20002020),
ip6_build(0x20010db8, 0x12345678, 0x10101010, 0x20202020),
106));
bt_assert(!ip6_prefix_equal(ip6_build(0x20010db8, 0x12345678, 0x10101010, 0x20002020),
ip6_build(0x20010db8, 0x12345678, 0x10101010, 0x20202020),
107));
bt_assert( ip6_prefix_equal(ip6_build(0xfeef0db8, 0x87654321, 0x10101010, 0x20202020),
ip6_build(0x20010db8, 0x12345678, 0xfefefefe, 0xdcdcdcdc),
0));
bt_assert( ip6_prefix_equal(ip6_build(0x20010db8, 0x12345678, 0x10101010, 0x20202020),
ip6_build(0x20010db8, 0x12345678, 0x10101010, 0x20202020),
128));
bt_assert(!ip6_prefix_equal(ip6_build(0x20010db8, 0x12345678, 0x10101010, 0x20202020),
ip6_build(0x20010db8, 0x12345678, 0x10101010, 0x20202021),
128));
return 1;
}
static int
t_ip6_shift_left(void)
{
ip6_addr a = ip6_build(0x8D0D8BDC, 0x1F04DB92, 0xE5117673, 0x70E54449);
struct { int n; ip6_addr val; } test_vectors[] = {
{ 0, ip6_build(0x8D0D8BDC, 0x1F04DB92, 0xE5117673, 0x70E54449) },
{ 9, ip6_build(0x1B17B83E, 0x09B725CA, 0x22ECE6E1, 0xCA889200) },
{ 18, ip6_build(0x2F707C13, 0x6E4B9445, 0xD9CDC395, 0x11240000) },
{ 27, ip6_build(0xE0F826DC, 0x97288BB3, 0x9B872A22, 0x48000000) },
{ 36, ip6_build(0xF04DB92E, 0x51176737, 0x0E544490, 0x00000000) },
{ 45, ip6_build(0x9B725CA2, 0x2ECE6E1C, 0xA8892000, 0x00000000) },
{ 54, ip6_build(0xE4B9445D, 0x9CDC3951, 0x12400000, 0x00000000) },
{ 63, ip6_build(0x7288BB39, 0xB872A224, 0x80000000, 0x00000000) },
{ 72, ip6_build(0x11767370, 0xE5444900, 0x00000000, 0x00000000) },
{ 81, ip6_build(0xECE6E1CA, 0x88920000, 0x00000000, 0x00000000) },
{ 90, ip6_build(0xCDC39511, 0x24000000, 0x00000000, 0x00000000) },
{ 99, ip6_build(0x872A2248, 0x00000000, 0x00000000, 0x00000000) },
{ 108, ip6_build(0x54449000, 0x00000000, 0x00000000, 0x00000000) },
{ 117, ip6_build(0x89200000, 0x00000000, 0x00000000, 0x00000000) },
{ 126, ip6_build(0x40000000, 0x00000000, 0x00000000, 0x00000000) },
{ 128, ip6_build(0x00000000, 0x00000000, 0x00000000, 0x00000000) },
};
for (uint i = 0; i < ARRAY_SIZE(test_vectors); i++)
bt_assert(ip6_equal(ip6_shift_left(a, test_vectors[i].n), test_vectors[i].val));
return 1;
}
static int
t_ip6_shift_right(void)
{
ip6_addr a = ip6_build(0x8D0D8BDC, 0x1F04DB92, 0xE5117673, 0x70E54449);
struct { int n; ip6_addr val; } test_vectors[] = {
{ 0, ip6_build(0x8D0D8BDC, 0x1F04DB92, 0xE5117673, 0x70E54449) },
{ 9, ip6_build(0x004686C5, 0xEE0F826D, 0xC97288BB, 0x39B872A2) },
{ 18, ip6_build(0x00002343, 0x62F707C1, 0x36E4B944, 0x5D9CDC39) },
{ 27, ip6_build(0x00000011, 0xA1B17B83, 0xE09B725C, 0xA22ECE6E) },
{ 36, ip6_build(0x00000000, 0x08D0D8BD, 0xC1F04DB9, 0x2E511767) },
{ 45, ip6_build(0x00000000, 0x0004686C, 0x5EE0F826, 0xDC97288B) },
{ 54, ip6_build(0x00000000, 0x00000234, 0x362F707C, 0x136E4B94) },
{ 63, ip6_build(0x00000000, 0x00000001, 0x1A1B17B8, 0x3E09B725) },
{ 72, ip6_build(0x00000000, 0x00000000, 0x008D0D8B, 0xDC1F04DB) },
{ 81, ip6_build(0x00000000, 0x00000000, 0x00004686, 0xC5EE0F82) },
{ 90, ip6_build(0x00000000, 0x00000000, 0x00000023, 0x4362F707) },
{ 99, ip6_build(0x00000000, 0x00000000, 0x00000000, 0x11A1B17B) },
{ 108, ip6_build(0x00000000, 0x00000000, 0x00000000, 0x0008D0D8) },
{ 117, ip6_build(0x00000000, 0x00000000, 0x00000000, 0x00000468) },
{ 126, ip6_build(0x00000000, 0x00000000, 0x00000000, 0x00000002) },
{ 128, ip6_build(0x00000000, 0x00000000, 0x00000000, 0x00000000) },
};
for (uint i = 0; i < ARRAY_SIZE(test_vectors); i++)
bt_assert(ip6_equal(ip6_shift_right(a, test_vectors[i].n), test_vectors[i].val));
return 1;
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_ip4_pton, "Converting IPv4 string to ip4_addr struct");
bt_test_suite(t_ip6_pton, "Converting IPv6 string to ip6_addr struct");
bt_test_suite(t_ip4_ntop, "Converting ip4_addr struct to IPv4 string");
bt_test_suite(t_ip6_ntop, "Converting ip6_addr struct to IPv6 string");
bt_test_suite(t_ip4_prefix_equal, "Testing ip4_prefix_equal()");
bt_test_suite(t_ip6_prefix_equal, "Testing ip6_prefix_equal()");
bt_test_suite(t_ip6_shift_left, "Testing ip6_shift_left()");
bt_test_suite(t_ip6_shift_right, "Testing ip6_shift_right()");
return bt_exit_value();
}
bird2-2.17.5/lib/lists.c 0000664 0000000 0000000 00000010631 15211753245 0014666 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Linked Lists
*
* (c) 1998 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
/**
* DOC: Linked lists
*
* The BIRD library provides a set of functions for operating on linked
* lists. The lists are internally represented as standard doubly linked
* lists with synthetic head and tail which makes all the basic operations
* run in constant time and contain no extra end-of-list checks. Each list
* is described by a &list structure, nodes can have any format as long
* as they start with a &node structure. If you want your nodes to belong
* to multiple lists at once, you can embed multiple &node structures in them
* and use the SKIP_BACK() macro to calculate a pointer to the start of the
* structure from a &node pointer, but beware of obscurity.
*
* There also exist safe linked lists (&slist, &snode and all functions
* being prefixed with |s_|) which support asynchronous walking very
* similar to that used in the &fib structure.
*/
#define _BIRD_LISTS_C_
#include "nest/bird.h"
#include "lib/lists.h"
LIST_INLINE int
check_list(list *l, node *n)
{
if (!l)
{
ASSERT_DIE(n);
ASSERT_DIE(n->prev);
do { n = n->prev; } while (n->prev);
l = SKIP_BACK(list, head_node, n);
}
int seen = 0;
ASSERT_DIE(l->null == NULL);
ASSERT_DIE(l->head != NULL);
ASSERT_DIE(l->tail != NULL);
node *prev = &l->head_node, *cur = l->head, *next = l->head->next;
while (next)
{
if (cur == n)
seen++;
ASSERT_DIE(cur->prev == prev);
prev = cur;
cur = next;
next = next->next;
}
ASSERT_DIE(cur == &(l->tail_node));
ASSERT_DIE(!n || (seen == 1));
return 1;
}
/**
* add_tail - append a node to a list
* @l: linked list
* @n: list node
*
* add_tail() takes a node @n and appends it at the end of the list @l.
*/
LIST_INLINE void
add_tail(list *l, node *n)
{
EXPENSIVE_CHECK(check_list(l, NULL));
ASSUME(n->prev == NULL);
ASSUME(n->next == NULL);
node *z = l->tail;
n->next = &l->tail_node;
n->prev = z;
z->next = n;
l->tail = n;
}
/**
* add_head - prepend a node to a list
* @l: linked list
* @n: list node
*
* add_head() takes a node @n and prepends it at the start of the list @l.
*/
LIST_INLINE void
add_head(list *l, node *n)
{
EXPENSIVE_CHECK(check_list(l, NULL));
ASSUME(n->prev == NULL);
ASSUME(n->next == NULL);
node *z = l->head;
n->next = z;
n->prev = &l->head_node;
z->prev = n;
l->head = n;
}
/**
* insert_node - insert a node to a list
* @n: a new list node
* @after: a node of a list
*
* Inserts a node @n to a linked list after an already inserted
* node @after.
*/
LIST_INLINE void
insert_node(node *n, node *after)
{
EXPENSIVE_CHECK(check_list(l, after));
ASSUME(n->prev == NULL);
ASSUME(n->next == NULL);
node *z = after->next;
n->next = z;
n->prev = after;
after->next = n;
z->prev = n;
}
/**
* rem_node - remove a node from a list
* @n: node to be removed
*
* Removes a node @n from the list it's linked in. Afterwards, node @n is cleared.
*/
LIST_INLINE void
rem_node(node *n)
{
EXPENSIVE_CHECK(check_list(NULL, n));
node *z = n->prev;
node *x = n->next;
z->next = x;
x->prev = z;
n->next = NULL;
n->prev = NULL;
}
/**
* update_node - update node after calling realloc on it
* @n: node to be updated
*
* Fixes neighbor pointers.
*/
LIST_INLINE void
update_node(node *n)
{
ASSUME(n->next->prev == n->prev->next);
n->next->prev = n;
n->prev->next = n;
EXPENSIVE_CHECK(check_list(NULL, n));
}
/**
* init_list - create an empty list
* @l: list
*
* init_list() takes a &list structure and initializes its
* fields, so that it represents an empty list.
*/
LIST_INLINE void
init_list(list *l)
{
l->head = &l->tail_node;
l->null = NULL;
l->tail = &l->head_node;
}
/**
* add_tail_list - concatenate two lists
* @to: destination list
* @l: source list
*
* This function appends all elements of the list @l to
* the list @to in constant time.
*/
LIST_INLINE void
add_tail_list(list *to, list *l)
{
EXPENSIVE_CHECK(check_list(to, NULL));
EXPENSIVE_CHECK(check_list(l, NULL));
node *p = to->tail;
node *q = l->head;
p->next = q;
q->prev = p;
q = l->tail;
q->next = &to->tail_node;
to->tail = q;
EXPENSIVE_CHECK(check_list(to, NULL));
}
LIST_INLINE uint
list_length(list *l)
{
uint len = 0;
node *n;
EXPENSIVE_CHECK(check_list(l, NULL));
WALK_LIST(n, *l)
len++;
return len;
}
bird2-2.17.5/lib/lists.h 0000664 0000000 0000000 00000005456 15211753245 0014704 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Linked Lists
*
* (c) 1998 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_LISTS_H_
#define _BIRD_LISTS_H_
/*
* I admit the list structure is very tricky and also somewhat awkward,
* but it's both efficient and easy to manipulate once one understands the
* basic trick: The list head always contains two synthetic nodes which are
* always present in the list: the head and the tail. But as the `next'
* entry of the tail and the `prev' entry of the head are both NULL, the
* nodes can overlap each other:
*
* head head_node.next
* null head_node.prev tail_node.next
* tail tail_node.prev
*/
typedef struct node {
struct node *next, *prev;
} node;
typedef union list { /* In fact two overlayed nodes */
struct { /* Head node */
struct node head_node;
void *head_padding;
};
struct { /* Tail node */
void *tail_padding;
struct node tail_node;
};
struct { /* Split to separate pointers */
struct node *head;
struct node *null;
struct node *tail;
};
} list;
#define STATIC_LIST_INIT(name) name = { .head = &name.tail_node, .tail = &name.head_node, .null = NULL }
#define NODE (node *)
#define HEAD(list) ((void *)((list).head))
#define TAIL(list) ((void *)((list).tail))
#define NODE_NEXT(n) ((void *)((NODE (n))->next))
#define NODE_VALID(n) ((NODE (n))->next)
#define WALK_LIST(n,list) for(n=HEAD(list); NODE_VALID(n); n=NODE_NEXT(n))
#define WALK_LIST_(t,n,list) for(t *n=HEAD(list); NODE_VALID(n); n=NODE_NEXT(n))
#define WALK_LIST2(n,nn,list,pos) \
for(nn=(list).head; NODE_VALID(nn) && (n=SKIP_BACK(typeof(*n),pos,nn)); nn=nn->next)
#define WALK_LIST_DELSAFE(n,nxt,list) \
for(n=HEAD(list); nxt=NODE_NEXT(n); n=(void *) nxt)
#define WALK_LIST2_DELSAFE(n,nn,nxt,list,pos) \
for(nn=HEAD(list); (nxt=nn->next) && (n=SKIP_BACK(typeof(*n),pos,nn)); nn=nxt)
/* WALK_LIST_FIRST supposes that called code removes each processed node */
#define WALK_LIST_FIRST(n,list) \
while(n=HEAD(list), (NODE (n))->next)
#define WALK_LIST_FIRST2(n,pos,list) \
while(n=SKIP_BACK(typeof(*n),pos,HEAD(list)), (n)->pos.next)
#define WALK_LIST_BACKWARDS(n,list) for(n=TAIL(list);(NODE (n))->prev; \
n=(void *)((NODE (n))->prev))
#define WALK_LIST_BACKWARDS_DELSAFE(n,prv,list) \
for(n=TAIL(list); prv=(void *)((NODE (n))->prev); n=(void *) prv)
#define EMPTY_LIST(list) (!(list).head->next)
#ifndef _BIRD_LISTS_C_
#define LIST_INLINE static inline
#include "lib/lists.c"
#undef LIST_INLINE
#else /* _BIRD_LISTS_C_ */
#define LIST_INLINE
void add_tail(list *, node *);
void add_head(list *, node *);
void rem_node(node *);
void add_tail_list(list *, list *);
void init_list(list *);
void insert_node(node *, node *);
uint list_length(list *);
#endif
#endif
bird2-2.17.5/lib/lists_test.c 0000664 0000000 0000000 00000013316 15211753245 0015730 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Linked Lists Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "lib/lists.h"
#define MAX_NUM 1000
static node nodes[MAX_NUM];
static list l;
static void
show_list(void)
{
bt_debug("\n");
bt_debug("list.null is at %p and point to %p\n", &l.null, l.null);
bt_debug("list.head is at %p and point to %p\n", &l.head, l.head);
bt_debug("list.tail is at %p and point to %p\n", &l.tail, l.tail);
int i;
for (i = 0; i < MAX_NUM; i++)
{
bt_debug("n[%3i] is at %p\n", i, &nodes[i]);
bt_debug(" prev is at %p and point to %p\n", &(nodes[i].prev), nodes[i].prev);
bt_debug(" next is at %p and point to %p\n", &(nodes[i].next), nodes[i].next);
}
}
static int
is_filled_list_well_linked(void)
{
int i;
bt_assert(l.head == &nodes[0]);
bt_assert(l.tail == &nodes[MAX_NUM-1]);
bt_assert((void *) nodes[0].prev == (void *) &l.head);
bt_assert((void *) nodes[MAX_NUM-1].next == (void *) &l.null);
for (i = 0; i < MAX_NUM; i++)
{
if (i < (MAX_NUM-1))
bt_assert(nodes[i].next == &nodes[i+1]);
if (i > 0)
bt_assert(nodes[i].prev == &nodes[i-1]);
}
return 1;
}
static int
is_empty_list_well_unlinked(void)
{
int i;
bt_assert(l.head == NODE &l.null);
bt_assert(l.tail == NODE &l.head);
bt_assert(EMPTY_LIST(l));
for (i = 0; i < MAX_NUM; i++)
{
bt_assert(nodes[i].next == NULL);
bt_assert(nodes[i].prev == NULL);
}
return 1;
}
static void
init_list__(list *l, struct node nodes[])
{
init_list(l);
int i;
for (i = 0; i < MAX_NUM; i++)
{
nodes[i].next = NULL;
nodes[i].prev = NULL;
}
}
static void
init_list_(void)
{
init_list__(&l, (node *) nodes);
}
static int
t_add_tail(void)
{
int i;
init_list_();
for (i = 0; i < MAX_NUM; i++)
{
add_tail(&l, &nodes[i]);
bt_debug(".");
bt_assert(l.tail == &nodes[i]);
bt_assert(l.head == &nodes[0]);
bt_assert((void *) nodes[i].next == (void *) &l.null);
if (i > 0)
{
bt_assert(nodes[i-1].next == &nodes[i]);
bt_assert(nodes[i].prev == &nodes[i-1]);
}
}
show_list();
bt_assert(is_filled_list_well_linked());
return 1;
}
static int
t_add_head(void)
{
int i;
init_list_();
for (i = MAX_NUM-1; i >= 0; i--)
{
add_head(&l, &nodes[i]);
bt_debug(".");
bt_assert(l.head == &nodes[i]);
bt_assert(l.tail == &nodes[MAX_NUM-1]);
if (i < MAX_NUM-1)
{
bt_assert(nodes[i+1].prev == &nodes[i]);
bt_assert(nodes[i].next == &nodes[i+1]);
}
}
show_list();
bt_assert(is_filled_list_well_linked());
return 1;
}
static void
insert_node_(node *n, node *after)
{
insert_node(n, after);
bt_debug(".");
}
static int
t_insert_node(void)
{
int i;
init_list_();
// add first node
insert_node_(&nodes[0], NODE &l.head);
// add odd nodes
for (i = 2; i < MAX_NUM; i+=2)
insert_node_(&nodes[i], &nodes[i-2]);
// add even nodes
for (i = 1; i < MAX_NUM; i+=2)
insert_node_(&nodes[i], &nodes[i-1]);
bt_debug("\n");
bt_assert(is_filled_list_well_linked());
return 1;
}
static void
fill_list2(list *l, node nodes[])
{
int i;
for (i = 0; i < MAX_NUM; i++)
add_tail(l, &nodes[i]);
}
static void
fill_list(void)
{
fill_list2(&l, (node *) nodes);
}
static int
t_remove_node(void)
{
int i;
init_list_();
/* Fill & Remove & Check */
fill_list();
for (i = 0; i < MAX_NUM; i++)
rem_node(&nodes[i]);
bt_assert(is_empty_list_well_unlinked());
/* Fill & Remove the half of nodes & Check & Remove the rest nodes & Check */
fill_list();
for (i = 0; i < MAX_NUM; i+=2)
rem_node(&nodes[i]);
int tail_node_index = (MAX_NUM % 2) ? MAX_NUM - 2 : MAX_NUM - 1;
bt_assert(l.head == &nodes[1]);
bt_assert(l.tail == &nodes[tail_node_index]);
bt_assert(nodes[tail_node_index].next == NODE &l.null);
for (i = 1; i < MAX_NUM; i+=2)
{
if (i > 1)
bt_assert(nodes[i].prev == &nodes[i-2]);
if (i < tail_node_index)
bt_assert(nodes[i].next == &nodes[i+2]);
}
for (i = 1; i < MAX_NUM; i+=2)
rem_node(&nodes[i]);
bt_assert(is_empty_list_well_unlinked());
return 1;
}
static int
t_update_node(void)
{
node head, inside, tail;
init_list_();
fill_list();
head = nodes[0];
update_node(&head);
bt_assert(l.head == &head);
bt_assert(head.prev == NODE &l.head);
bt_assert(head.next == &nodes[1]);
bt_assert(nodes[1].prev == &head);
inside = nodes[MAX_NUM/2];
update_node(&inside);
bt_assert(nodes[MAX_NUM/2-1].next == &inside);
bt_assert(nodes[MAX_NUM/2+1].prev == &inside);
bt_assert(inside.prev == &nodes[MAX_NUM/2-1]);
bt_assert(inside.next == &nodes[MAX_NUM/2+1]);
tail = nodes[MAX_NUM-1];
update_node(&tail);
bt_assert(l.tail == &tail);
bt_assert(tail.prev == &nodes[MAX_NUM-2]);
bt_assert(tail.next == NODE &l.null);
bt_assert(nodes[MAX_NUM-2].next == &tail);
return 1;
}
static int
t_add_tail_list(void)
{
node nodes2[MAX_NUM];
list l2;
init_list__(&l, (node *) nodes);
fill_list2(&l, (node *) nodes);
init_list__(&l2, (node *) nodes2);
fill_list2(&l2, (node *) nodes2);
add_tail_list(&l, &l2);
bt_assert(nodes[MAX_NUM-1].next == &nodes2[0]);
bt_assert(nodes2[0].prev == &nodes[MAX_NUM-1]);
bt_assert(l.tail == &nodes2[MAX_NUM-1]);
return 1;
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_add_tail, "Adding nodes to tail of list");
bt_test_suite(t_add_head, "Adding nodes to head of list");
bt_test_suite(t_insert_node, "Inserting nodes to list");
bt_test_suite(t_remove_node, "Removing nodes from list");
bt_test_suite(t_update_node, "Updating nodes in list");
bt_test_suite(t_add_tail_list, "At the tail of a list adding the another list");
return bt_exit_value();
}
bird2-2.17.5/lib/mac.c 0000664 0000000 0000000 00000021223 15211753245 0014267 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Message Authentication Codes
*
* (c) 2016 Ondrej Zajicek
* (c) 2016 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
/**
* DOC: Message authentication codes
*
* MAC algorithms are simple cryptographic tools for message authentication.
* They use shared a secret key a and message text to generate authentication
* code, which is then passed with the message to the other side, where the code
* is verified. There are multiple families of MAC algorithms based on different
* cryptographic primitives, BIRD implements two MAC families which use hash
* functions.
*
* The first family is simply a cryptographic hash camouflaged as MAC algorithm.
* Originally supposed to be (m|k)-hash (message is concatenated with key, and
* that is hashed), but later it turned out that a raw hash is more practical.
* This is used for cryptographic authentication in OSPFv2, RIP and BFD.
*
* The second family is the standard HMAC (RFC 2104), using inner and outer hash
* to process key and message. HMAC (with SHA) is used in advanced OSPF and RIP
* authentication (RFC 5709, RFC 4822).
*/
#include "lib/mac.h"
#include "lib/md5.h"
#include "lib/sha1.h"
#include "lib/sha256.h"
#include "lib/sha512.h"
#include "lib/blake2.h"
/*
* Internal hash calls
*/
static inline void
hash_init(struct mac_context *mctx, struct hash_context *hctx)
{ mctx->type->hash_init(hctx); }
static inline void
hash_update(struct mac_context *mctx, struct hash_context *hctx, const byte *buf, uint len)
{ mctx->type->hash_update(hctx, buf, len); }
static inline byte *
hash_final(struct mac_context *mctx, struct hash_context *hctx)
{ return mctx->type->hash_final(hctx); }
static inline void
hash_buffer(struct mac_context *mctx, byte *outbuf, const byte *buffer, uint length)
{
struct hash_context hctx;
hash_init(mctx, &hctx);
hash_update(mctx, &hctx, buffer, length);
memcpy(outbuf, hash_final(mctx, &hctx), mctx->type->hash_size);
}
/*
* (not-really-MAC) Hash
*/
static void
nrmh_init(struct mac_context *ctx, const byte *key UNUSED, uint keylen UNUSED)
{
struct nrmh_context *ct = (void *) ctx;
hash_init(ctx, &ct->ictx);
}
static void
nrmh_update(struct mac_context *ctx, const byte *data, uint datalen)
{
struct nrmh_context *ct = (void *) ctx;
hash_update(ctx, &ct->ictx, data, datalen);
}
static byte *
nrmh_final(struct mac_context *ctx)
{
struct nrmh_context *ct = (void *) ctx;
return hash_final(ctx, &ct->ictx);
}
/*
* HMAC
*/
static void
hmac_init(struct mac_context *ctx, const byte *key, uint keylen)
{
struct hmac_context *ct = (void *) ctx;
uint block_size = ctx->type->block_size;
uint hash_size = ctx->type->hash_size;
byte *keybuf = alloca(block_size);
byte *buf = alloca(block_size);
uint i;
/* Hash the key if necessary */
if (keylen <= block_size)
{
memcpy(keybuf, key, keylen);
memset(keybuf + keylen, 0, block_size - keylen);
}
else
{
hash_buffer(ctx, keybuf, key, keylen);
memset(keybuf + hash_size, 0, block_size - hash_size);
}
/* Initialize the inner digest */
hash_init(ctx, &ct->ictx);
for (i = 0; i < block_size; i++)
buf[i] = keybuf[i] ^ 0x36;
hash_update(ctx, &ct->ictx, buf, block_size);
/* Initialize the outer digest */
hash_init(ctx, &ct->octx);
for (i = 0; i < block_size; i++)
buf[i] = keybuf[i] ^ 0x5c;
hash_update(ctx, &ct->octx, buf, block_size);
}
static void
hmac_update(struct mac_context *ctx, const byte *data, uint datalen)
{
struct hmac_context *ct = (void *) ctx;
/* Just update the inner digest */
hash_update(ctx, &ct->ictx, data, datalen);
}
static byte *
hmac_final(struct mac_context *ctx)
{
struct hmac_context *ct = (void *) ctx;
/* Finish the inner digest */
byte *isha = hash_final(ctx, &ct->ictx);
/* Finish the outer digest */
hash_update(ctx, &ct->octx, isha, ctx->type->hash_size);
return hash_final(ctx, &ct->octx);
}
/*
* Common code
*/
#define HASH_DESC(name, px, PX) \
{ \
name, PX##_SIZE, sizeof(struct nrmh_context), \
nrmh_init, nrmh_update, nrmh_final, \
PX##_SIZE, PX##_BLOCK_SIZE, px##_init, px##_update, px##_final \
}
#define HMAC_DESC(name, px, PX) \
{ \
name, PX##_SIZE, sizeof(struct hmac_context), \
hmac_init, hmac_update, hmac_final, \
PX##_SIZE, PX##_BLOCK_SIZE, px##_init, px##_update, px##_final \
}
#define BLAKE_DESC(name, vx, VX, size) \
{ \
name, size/8, sizeof(struct vx##_context), \
vx##_mac_init, vx##_mac_update, vx##_mac_final, \
size/8, VX##_BLOCK_SIZE, NULL, NULL, NULL, 0, VX##_SIZE \
}
const struct mac_desc mac_table[ALG_MAX] = {
[ALG_MD5] = HASH_DESC("Keyed MD5", md5, MD5),
[ALG_SHA1] = HASH_DESC("Keyed SHA-1", sha1, SHA1),
[ALG_SHA224] = HASH_DESC("Keyed SHA-224", sha224, SHA224),
[ALG_SHA256] = HASH_DESC("Keyed SHA-256", sha256, SHA256),
[ALG_SHA384] = HASH_DESC("Keyed SHA-384", sha384, SHA384),
[ALG_SHA512] = HASH_DESC("Keyed SHA-512", sha512, SHA512),
[ALG_BLAKE2S_128] = BLAKE_DESC("Blake2s-128", blake2s, BLAKE2S, 128),
[ALG_BLAKE2S_256] = BLAKE_DESC("Blake2s-256", blake2s, BLAKE2S, 256),
[ALG_BLAKE2B_256] = BLAKE_DESC("Blake2b-256", blake2b, BLAKE2B, 256),
[ALG_BLAKE2B_512] = BLAKE_DESC("Blake2b-512", blake2b, BLAKE2B, 512),
[ALG_HMAC_MD5] = HMAC_DESC("HMAC-MD5", md5, MD5),
[ALG_HMAC_SHA1] = HMAC_DESC("HMAC-SHA-1", sha1, SHA1),
[ALG_HMAC_SHA224] = HMAC_DESC("HMAC-SHA-224", sha224, SHA224),
[ALG_HMAC_SHA256] = HMAC_DESC("HMAC-SHA-256", sha256, SHA256),
[ALG_HMAC_SHA384] = HMAC_DESC("HMAC-SHA-384", sha384, SHA384),
[ALG_HMAC_SHA512] = HMAC_DESC("HMAC-SHA-512", sha512, SHA512),
};
/**
* mac_init - initialize MAC algorithm
* @ctx: context to initialize
* @id: MAC algorithm ID
* @key: MAC key
* @keylen: MAC key length
*
* Initialize MAC context @ctx for algorithm @id (e.g., %ALG_HMAC_SHA1), with
* key @key of length @keylen. After that, message data could be added using
* mac_update() function.
*/
void
mac_init(struct mac_context *ctx, uint id, const byte *key, uint keylen)
{
ctx->type = &mac_table[id];
ctx->type->init(ctx, key, keylen);
}
#if 0
/**
* mac_update - add more data to MAC algorithm
* @ctx: MAC context
* @data: data to add
* @datalen: length of data
*
* Push another @datalen bytes of data pointed to by @data into the MAC
* algorithm currently in @ctx. Can be called multiple times for the same MAC
* context. It has the same effect as concatenating all the data together and
* passing them at once.
*/
void mac_update(struct mac_context *ctx, const byte *data, uint datalen)
{ DUMMY; }
/**
* mac_final - finalize MAC algorithm
* @ctx: MAC context
*
* Finish MAC computation and return a pointer to the result. No more
* mac_update() calls could be done, but the context may be reinitialized
* later.
*
* Note that the returned pointer points into data in the @ctx context. If it
* ceases to exist, the pointer becomes invalid.
*/
byte *mac_final(struct mac_context *ctx)
{ DUMMY; }
/**
* mac_cleanup - cleanup MAC context
* @ctx: MAC context
*
* Cleanup MAC context after computation (by filling with zeros). Not strictly
* necessary, just to erase sensitive data from stack. This also invalidates the
* pointer returned by mac_final().
*/
void mac_cleanup(struct mac_context *ctx)
{ DUMMY; }
#endif
/**
* mac_fill - compute and fill MAC
* @id: MAC algorithm ID
* @key: secret key
* @keylen: key length
* @data: message data
* @datalen: message length
* @mac: place to fill MAC
*
* Compute MAC for specified key @key and message @data using algorithm @id and
* copy it to buffer @mac. mac_fill() is a shortcut function doing all usual
* steps for transmitted messages.
*/
void
mac_fill(uint id, const byte *key, uint keylen, const byte *data, uint datalen, byte *mac)
{
struct mac_context ctx;
mac_init(&ctx, id, key, keylen);
mac_update(&ctx, data, datalen);
memcpy(mac, mac_final(&ctx), mac_get_length(&ctx));
mac_cleanup(&ctx);
}
/**
* mac_verify - compute and verify MAC
* @id: MAC algorithm ID
* @key: secret key
* @keylen: key length
* @data: message data
* @datalen: message length
* @mac: received MAC
*
* Compute MAC for specified key @key and message @data using algorithm @id and
* compare it with received @mac, return whether they are the same. mac_verify()
* is a shortcut function doing all usual steps for received messages.
*/
int
mac_verify(uint id, const byte *key, uint keylen, const byte *data, uint datalen, const byte *mac)
{
struct mac_context ctx;
mac_init(&ctx, id, key, keylen);
mac_update(&ctx, data, datalen);
int res = !memcmp(mac, mac_final(&ctx), mac_get_length(&ctx));
mac_cleanup(&ctx);
return res;
}
bird2-2.17.5/lib/mac.h 0000664 0000000 0000000 00000007354 15211753245 0014305 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Message Authentication Codes
*
* (c) 2016 Ondrej Zajicek
* (c) 2016 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_MAC_H_
#define _BIRD_MAC_H_
#include "nest/bird.h"
#include "lib/sha512.h"
#include "lib/blake2.h"
#define ALG_UNDEFINED 0
#define ALG_MD5 0x01
#define ALG_SHA1 0x02
#define ALG_SHA224 0x03
#define ALG_SHA256 0x04
#define ALG_SHA384 0x05
#define ALG_SHA512 0x06
#define ALG_BLAKE2S_128 0x07
#define ALG_BLAKE2S_256 0x08
#define ALG_BLAKE2B_256 0x09
#define ALG_BLAKE2B_512 0x0A
#define ALG_CMAC_AES128_AO 0x0B /* Not implemented, just for TCP-AO */
#define ALG_HMAC 0x10
#define ALG_HMAC_MD5 0x11
#define ALG_HMAC_SHA1 0x12
#define ALG_HMAC_SHA224 0x13
#define ALG_HMAC_SHA256 0x14
#define ALG_HMAC_SHA384 0x15
#define ALG_HMAC_SHA512 0x16
#define ALG_MAX 0x17
/* These are maximums for HASH/MAC lengths and required context space */
#define MAX_HASH_SIZE SHA512_SIZE
#define HASH_STORAGE sizeof(struct sha512_context)
#define MAC_STORAGE sizeof(struct hmac_context)
/* This value is used by several IETF protocols for padding */
#define HMAC_MAGIC htonl(0x878FE1F3)
/* Generic context used by hash functions */
struct hash_context
{
u8 data[HASH_STORAGE];
u64 align[0];
};
/* Context for embedded hash (not-really-MAC hash) */
struct nrmh_context {
const struct mac_desc *type;
struct hash_context ictx;
};
/* Context for hash based HMAC */
struct hmac_context {
const struct mac_desc *type;
struct hash_context ictx;
struct hash_context octx;
};
/* Generic context used by MAC functions */
struct mac_context
{
const struct mac_desc *type;
u8 data[MAC_STORAGE - sizeof(void *)];
u64 align[0];
};
/* Union to satisfy C aliasing rules */
union mac_context_union {
struct mac_context mac;
struct nrmh_context nrmh;
struct hmac_context hmac;
struct blake2s_context blake2s;
struct blake2b_context blake2b;
};
struct mac_desc {
const char *name; /* Name of MAC algorithm */
uint mac_length; /* Length of authentication code */
uint ctx_length; /* Length of algorithm context */
void (*init)(struct mac_context *ctx, const byte *key, uint keylen);
void (*update)(struct mac_context *ctx, const byte *data, uint datalen);
byte *(*final)(struct mac_context *ctx);
uint hash_size; /* Hash length, for hash-based MACs */
uint block_size; /* Hash block size, for hash-based MACs */
void (*hash_init)(struct hash_context *ctx);
void (*hash_update)(struct hash_context *ctx, const byte *data, uint datalen);
byte *(*hash_final)(struct hash_context *ctx);
uint min_key_length; /* Minimum allowed key length */
uint max_key_length; /* Maximum allowed key length */
};
extern const struct mac_desc mac_table[ALG_MAX];
static inline const char *mac_type_name(uint id)
{ return mac_table[id].name; }
static inline uint mac_type_length(uint id)
{ return mac_table[id].mac_length; }
static inline const char *mac_get_name(struct mac_context *ctx)
{ return ctx->type->name; }
static inline uint mac_get_length(struct mac_context *ctx)
{ return ctx->type->mac_length; }
void mac_init(struct mac_context *ctx, uint id, const byte *key, uint keylen);
static inline void mac_update(struct mac_context *ctx, const byte *data, uint datalen)
{ ctx->type->update(ctx, data, datalen); }
static inline byte *mac_final(struct mac_context *ctx)
{ return ctx->type->final(ctx); }
static inline void mac_cleanup(struct mac_context *ctx)
{ memset(ctx, 0, ctx->type->ctx_length); }
void mac_fill(uint id, const byte *key, uint keylen, const byte *data, uint datalen, byte *mac);
int mac_verify(uint id, const byte *key, uint keylen, const byte *data, uint datalen, const byte *mac);
#endif /* _BIRD_MAC_H_ */
bird2-2.17.5/lib/mac_test.c 0000664 0000000 0000000 00000122734 15211753245 0015337 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- SHA and HMAC-SHA functions tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "test/bt-utils.h"
#include "lib/mac.h"
#define define_test_hash_fn(name,id) \
static int \
test_##name(void *out_, const void *in_, const void *expected_out_) \
{ \
char *out = out_; \
const char *in = in_; \
const char *expected_out = expected_out_; \
\
struct mac_context ctx; \
mac_init(&ctx, id, NULL, 0); \
mac_update(&ctx, in, strlen(in)); \
byte *out_bin = mac_final(&ctx); \
\
uint len = mac_type_length(id); \
bt_bytes_to_hex(out, out_bin, len); \
\
return strncmp(out, expected_out, 2*len+1) == 0; \
}
define_test_hash_fn(md5, ALG_MD5)
define_test_hash_fn(sha1, ALG_SHA1)
define_test_hash_fn(sha224, ALG_SHA224)
define_test_hash_fn(sha256, ALG_SHA256)
define_test_hash_fn(sha384, ALG_SHA384)
define_test_hash_fn(sha512, ALG_SHA512)
static int
t_md5(void)
{
struct bt_pair test_vectors[] = {
{
.in = "",
.out = "d41d8cd98f00b204e9800998ecf8427e",
},
{
.in = "a",
.out = "0cc175b9c0f1b6a831c399e269772661",
},
{
.in = "abc",
.out = "900150983cd24fb0d6963f7d28e17f72",
},
{
.in = "message digest",
.out = "f96b697d7cb7938d525a2f31aaf161d0",
},
{
.in = "abcdefghijklmnopqrstuvwxyz",
.out = "c3fcd3d76192e4007dfb496cca67e13b",
},
{
.in = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
.out = "d174ab98d277d9f5a5611c2c9f419d9f",
},
{
.in = "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
.out = "57edf4a22be3c955ac49da2e2107b67a",
},
};
return bt_assert_batch(test_vectors, test_md5, bt_fmt_str, bt_fmt_str);
}
/*
* Testing SHAxxx functions
*/
static int
t_sha1(void)
{
struct bt_pair test_vectors[] = {
{
.in = "",
.out = "da39a3ee5e6b4b0d3255bfef95601890afd80709",
},
{
.in = "a",
.out = "86f7e437faa5a7fce15d1ddcb9eaeaea377667b8",
},
{
.in = "abc",
.out = "a9993e364706816aba3e25717850c26c9cd0d89d",
},
{
.in = "message digest",
.out = "c12252ceda8be8994d5fa0290a47231c1d16aae3",
},
{
.in = "abcdefghijklmnopqrstuvwxyz",
.out = "32d10c7b8cf96570ca04ce37f2a19d84240d3a89",
},
{
.in = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
.out = "761c457bf73b14d27e9e9265c46f4b4dda11f940",
},
{
.in = "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
.out = "50abf5706a150990a08b2c5ea40fa0e585554732",
},
{
.in = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
.out = "6a64fcc1fb970f7339ce886601775d2efea5cd4b",
},
};
return bt_assert_batch(test_vectors, test_sha1, bt_fmt_str, bt_fmt_str);
}
static int
t_sha224(void)
{
struct bt_pair test_vectors[] = {
{
.in = "",
.out = "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f",
},
{
.in = "a",
.out = "abd37534c7d9a2efb9465de931cd7055ffdb8879563ae98078d6d6d5",
},
{
.in = "abc",
.out = "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7",
},
{
.in = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
.out = "75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525",
},
{
.in = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
.out = "cca7dd1a332a17775d8b0429bdb45055c2d4368ebaab0c7cf385586e",
},
};
return bt_assert_batch(test_vectors, test_sha224, bt_fmt_str, bt_fmt_str);
}
static int
t_sha256(void)
{
struct bt_pair test_vectors[] = {
{
.in = "",
.out = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
},
{
.in = "a",
.out = "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb",
},
{
.in = "abc",
.out = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
},
{
.in = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
.out = "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1",
},
{
.in = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
.out = "bf18b43b61652b5d73f41ebf3d72e5e43aebf5076f497dde31ea3de9de4998ef",
},
};
return bt_assert_batch(test_vectors, test_sha256, bt_fmt_str, bt_fmt_str);
}
static int
t_sha384(void)
{
struct bt_pair test_vectors[] = {
{
.in = "",
.out = "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b",
},
{
.in = "a",
.out = "54a59b9f22b0b80880d8427e548b7c23abd873486e1f035dce9cd697e85175033caa88e6d57bc35efae0b5afd3145f31",
},
{
.in = "abc",
.out = "cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7",
},
{
.in = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
.out = "3391fdddfc8dc7393707a65b1b4709397cf8b1d162af05abfe8f450de5f36bc6b0455a8520bc4e6f5fe95b1fe3c8452b",
},
{
.in = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
.out = "6452928a62ca915a60f2d16ea22cc832d8ecb35443d78a3ff6986e7def9174a1dc16ce2ff65d3ed1666db98357f3c05e",
},
};
return bt_assert_batch(test_vectors, test_sha384, bt_fmt_str, bt_fmt_str);
}
static int
t_sha512(void)
{
struct bt_pair test_vectors[] = {
{
.in = "",
.out = "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e",
},
{
.in = "a",
.out = "1f40fc92da241694750979ee6cf582f2d5d7d28e18335de05abc54d0560e0f5302860c652bf08d560252aa5e74210546f369fbbbce8c12cfc7957b2652fe9a75",
},
{
.in = "abc",
.out = "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f",
},
{
.in = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
.out = "204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c33596fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445",
},
{
.in = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
.out = "415509a1c345371acb3e27a88b3835e3b6dfebcbbab5134850596f4db64d7bb22ac42c3cd179446a80c92b8be955460eb536eac01389a7e1fdf09d1dca83922f",
},
};
return bt_assert_batch(test_vectors, test_sha512, bt_fmt_str, bt_fmt_str);
}
/*
* Testing SHAxxx HMAC functions
*/
#define HMAC_BUFFER_SIZE 160
struct hmac_data_in {
byte key[HMAC_BUFFER_SIZE];
uint key_len;
byte data[HMAC_BUFFER_SIZE];
uint data_len;
};
static void
hmac_in_fmt(char *buf, size_t size, const void *data_)
{
uint i;
const struct hmac_data_in *data = data_;
snprintf(buf, size, "data: '");
for (i = 0; i < data->data_len; i++)
snprintf(buf+strlen(buf), size-strlen(buf), bt_is_char(data->data[i]) ? "%c" : " 0x%02x", data->data[i]);
snprintf(buf+strlen(buf), size-strlen(buf), "', key: '");
for (i = 0; i < data->key_len; i++)
snprintf(buf+strlen(buf), size-strlen(buf), bt_is_char(data->key[i]) ? "%c" : " 0x%02x", data->key[i]);
snprintf(buf+strlen(buf), size-strlen(buf), "'");
}
#define define_test_hmac_fn(name,id) \
static int \
test_##name##_hmac(void *out_, const void *in_, const void *expected_out_) \
{ \
char *out = out_; \
const struct hmac_data_in *in = in_; \
const char *expected_out = expected_out_; \
\
struct mac_context ctx; \
mac_init(&ctx, id, in->key, in->key_len); \
mac_update(&ctx, in->data, in->data_len); \
byte *out_bin = mac_final(&ctx); \
\
uint len = mac_type_length(id); \
bt_bytes_to_hex(out, out_bin, len); \
\
return strncmp(out, expected_out, 2*len+1) == 0; \
}
define_test_hmac_fn(md5, ALG_HMAC_MD5)
define_test_hmac_fn(sha1, ALG_HMAC_SHA1)
define_test_hmac_fn(sha224, ALG_HMAC_SHA224)
define_test_hmac_fn(sha256, ALG_HMAC_SHA256)
define_test_hmac_fn(sha384, ALG_HMAC_SHA384)
define_test_hmac_fn(sha512, ALG_HMAC_SHA512)
static int
t_md5_hmac(void)
{
struct bt_pair test_vectors[] = {
{
.in = & (struct hmac_data_in) {
.key = {
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
},
.key_len = 16,
.data = "Hi There",
.data_len = 8,
},
.out = "9294727a3638bb1c13f48ef8158bfc9d",
},
{
.in = & (struct hmac_data_in) {
.key = "Jefe",
.key_len = 4,
.data = "what do ya want for nothing?",
.data_len = 28,
},
.out = "750c783e6ab0b503eaa86e310a5db738",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
},
.key_len = 16,
.data = {
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
},
.data_len = 50,
},
.out = "56be34521d144c88dbb8c733f0e8b3f6",
},
{
.in = & (struct hmac_data_in) {
.key = {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
0x15, 0x16, 0x17, 0x18, 0x19,
},
.key_len = 25,
.data = {
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
},
.data_len = 50,
},
.out = "697eaf0aca3a3aea3a75164746ffaa79",
},
{
.in = & (struct hmac_data_in) {
.key = {
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
},
.key_len = 16,
.data = "Test With Truncation",
.data_len = 20,
},
.out = "56461ef2342edc00f9bab995690efd4c",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
},
.key_len = 80,
.data = "Test Using Larger Than Block-Size Key - Hash Key First",
.data_len = 54,
},
.out = "6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
},
.key_len = 80,
.data = "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
.data_len = 73,
},
.out = "6f630fad67cda0ee1fb1f562db3aa53e",
},
};
return bt_assert_batch(test_vectors, test_md5_hmac, hmac_in_fmt, bt_fmt_str);
}
static int
t_sha1_hmac(void)
{
struct bt_pair test_vectors[] = {
{
.in = & (struct hmac_data_in) {
.key = {
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
},
.key_len = 20,
.data = "Hi There",
.data_len = 8,
},
.out = "b617318655057264e28bc0b6fb378c8ef146be00",
},
{
.in = & (struct hmac_data_in) {
.key = "Jefe",
.key_len = 4,
.data = "what do ya want for nothing?",
.data_len = 28,
},
.out = "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
},
.key_len = 20,
.data = {
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
},
.data_len = 50,
},
.out = "125d7342b9ac11cd91a39af48aa17b4f63f175d3",
},
{
.in = & (struct hmac_data_in) {
.key = {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
0x15, 0x16, 0x17, 0x18, 0x19,
},
.key_len = 25,
.data = {
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
},
.data_len = 50,
},
.out = "4c9007f4026250c6bc8414f9bf50c86c2d7235da",
},
{
.in = & (struct hmac_data_in) {
.key = {
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
},
.key_len = 20,
.data = "Test With Truncation",
.data_len = 20,
},
.out = "4c1a03424b55e07fe7f27be1d58bb9324a9a5a04",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
},
.key_len = 80,
.data = "Test Using Larger Than Block-Size Key - Hash Key First",
.data_len = 54,
},
.out = "aa4ae5e15272d00e95705637ce8a3b55ed402112",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
},
.key_len = 80,
.data = "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
.data_len = 73,
},
.out = "e8e99d0f45237d786d6bbaa7965c7808bbff1a91",
},
{
.in = & (struct hmac_data_in) {
.key = {
0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x61,
},
.key_len = 64,
.data = "Test Using key 64 bytes sized",
.data_len = 29,
},
.out = "a55d4fb80962a6b3d2e720705314bee417d68cf6",
},
};
return bt_assert_batch(test_vectors, test_sha1_hmac, hmac_in_fmt, bt_fmt_str);
}
static int
t_sha224_hmac(void)
{
struct bt_pair test_vectors[] = {
{
.in = & (struct hmac_data_in) {
.key = {
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
},
.key_len = 20,
.data = "Hi There",
.data_len = 8,
},
.out = "896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22",
},
{
.in = & (struct hmac_data_in) {
.key = "Jefe",
.key_len = 4,
.data = "what do ya want for nothing?",
.data_len = 28,
},
.out = "a30e01098bc6dbbf45690f3a7e9e6d0f8bbea2a39e6148008fd05e44",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
},
.key_len = 20,
.data = {
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
},
.data_len = 50,
},
.out = "7fb3cb3588c6c1f6ffa9694d7d6ad2649365b0c1f65d69d1ec8333ea",
},
{
.in = & (struct hmac_data_in) {
.key = {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
0x15, 0x16, 0x17, 0x18, 0x19,
},
.key_len = 25,
.data = {
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
},
.data_len = 50,
},
.out = "6c11506874013cac6a2abc1bb382627cec6a90d86efc012de7afec5a",
},
{
.in = & (struct hmac_data_in) {
.key = {
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
},
.key_len = 20,
.data = "Test With Truncation",
.data_len = 20,
},
.out = "0e2aea68a90c8d37c988bcdb9fca6fa8099cd857c7ec4a1815cac54c",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa,
},
.key_len = 131,
.data = "Test Using Larger Than Block-Size Key - Hash Key First",
.data_len = 54,
},
.out = "95e9a0db962095adaebe9b2d6f0dbce2d499f112f2d2b7273fa6870e",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa,
},
.key_len = 131,
.data = "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
.data_len = 152,
},
.out = "3a854166ac5d9f023f54d517d0b39dbd946770db9c2b95c9f6f565d1",
},
};
return bt_assert_batch(test_vectors, test_sha224_hmac, hmac_in_fmt, bt_fmt_str);
}
static int
t_sha256_hmac(void)
{
struct bt_pair test_vectors[] = {
{
.in = & (struct hmac_data_in) {
.key = {
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
},
.key_len = 20,
.data = "Hi There",
.data_len = 8,
},
.out = "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7",
},
{
.in = & (struct hmac_data_in) {
.key = "Jefe",
.key_len = 4,
.data = "what do ya want for nothing?",
.data_len = 28,
},
.out = "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
},
.key_len = 20,
.data = {
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
},
.data_len = 50,
},
.out = "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe",
},
{
.in = & (struct hmac_data_in) {
.key = {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
0x15, 0x16, 0x17, 0x18, 0x19,
},
.key_len = 25,
.data = {
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
},
.data_len = 50,
},
.out = "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b",
},
{
.in = & (struct hmac_data_in) {
.key = {
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
},
.key_len = 20,
.data = "Test With Truncation",
.data_len = 20,
},
.out = "a3b6167473100ee06e0c796c2955552bfa6f7c0a6a8aef8b93f860aab0cd20c5",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa,
},
.key_len = 131,
.data = "Test Using Larger Than Block-Size Key - Hash Key First",
.data_len = 54,
},
.out = "60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa,
},
.key_len = 131,
.data = "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
.data_len = 152,
},
.out = "9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2",
},
};
return bt_assert_batch(test_vectors, test_sha256_hmac, hmac_in_fmt, bt_fmt_str);
}
static int
t_sha384_hmac(void)
{
struct bt_pair test_vectors[] = {
{
.in = & (struct hmac_data_in) {
.key = {
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
},
.key_len = 20,
.data = "Hi There",
.data_len = 8,
},
.out = "afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6",
},
{
.in = & (struct hmac_data_in) {
.key = "Jefe",
.key_len = 4,
.data = "what do ya want for nothing?",
.data_len = 28,
},
.out = "af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e8e2240ca5e69e2c78b3239ecfab21649",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
},
.key_len = 20,
.data = {
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
},
.data_len = 50,
},
.out = "88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e55966144b2a5ab39dc13814b94e3ab6e101a34f27",
},
{
.in = & (struct hmac_data_in) {
.key = {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
0x15, 0x16, 0x17, 0x18, 0x19,
},
.key_len = 25,
.data = {
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
},
.data_len = 50,
},
.out = "3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e1f573b4e6801dd23c4a7d679ccf8a386c674cffb",
},
{
.in = & (struct hmac_data_in) {
.key = {
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
},
.key_len = 20,
.data = "Test With Truncation",
.data_len = 20,
},
.out = "3abf34c3503b2a23a46efc619baef897f4c8e42c934ce55ccbae9740fcbc1af4ca62269e2a37cd88ba926341efe4aeea",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa,
},
.key_len = 131,
.data = "Test Using Larger Than Block-Size Key - Hash Key First",
.data_len = 54,
},
.out = "4ece084485813e9088d2c63a041bc5b44f9ef1012a2b588f3cd11f05033ac4c60c2ef6ab4030fe8296248df163f44952",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa,
},
.key_len = 131,
.data = "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
.data_len = 152,
},
.out = "6617178e941f020d351e2f254e8fd32c602420feb0b8fb9adccebb82461e99c5a678cc31e799176d3860e6110c46523e",
},
};
return bt_assert_batch(test_vectors, test_sha384_hmac, hmac_in_fmt, bt_fmt_str);
}
static int
t_sha512_hmac(void)
{
struct bt_pair test_vectors[] = {
{
.in = & (struct hmac_data_in) {
.key = {
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
},
.key_len = 20,
.data = "Hi There",
.data_len = 8,
},
.out = "87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854",
},
{
.in = & (struct hmac_data_in) {
.key = "Jefe",
.key_len = 4,
.data = "what do ya want for nothing?",
.data_len = 28,
},
.out = "164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
},
.key_len = 20,
.data = {
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
},
.data_len = 50,
},
.out = "fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb",
},
{
.in = & (struct hmac_data_in) {
.key = {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
0x15, 0x16, 0x17, 0x18, 0x19,
},
.key_len = 25,
.data = {
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
},
.data_len = 50,
},
.out = "b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd",
},
{
.in = & (struct hmac_data_in) {
.key = {
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
},
.key_len = 20,
.data = "Test With Truncation",
.data_len = 20,
},
.out = "415fad6271580a531d4179bc891d87a650188707922a4fbb36663a1eb16da008711c5b50ddd0fc235084eb9d3364a1454fb2ef67cd1d29fe6773068ea266e96b",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa,
},
.key_len = 131,
.data = "Test Using Larger Than Block-Size Key - Hash Key First",
.data_len = 54,
},
.out = "80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f3526b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec8b915a985d786598",
},
{
.in = & (struct hmac_data_in) {
.key = {
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa,
},
.key_len = 131,
.data = "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm.",
.data_len = 152,
},
.out = "e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de0446065c97440fa8c6a58",
},
};
return bt_assert_batch(test_vectors, test_sha512_hmac, hmac_in_fmt, bt_fmt_str);
}
/*
* Testing SHAxxx concating independence
*/
#include "lib/sha256.h"
#include "lib/sha512.h"
static int
t_sha256_concating(void)
{
char hash_a[SHA256_HEX_SIZE];
char hash_b[SHA256_HEX_SIZE];
char *str_a = "a" "bb" "ccc" "dddd" "eeeee" "ffffff";
char *str_b1 = "a" ;
char *str_b2 = "bb" ;
char *str_b3 = "ccc" ;
char *str_b4 = "dddd" ;
char *str_b5 = "eeeee" ;
char *str_b6 = "ffffff";
struct hash_context ctx_a;
sha256_init(&ctx_a);
sha256_update(&ctx_a, str_a, strlen(str_a));
byte *hash_a_ = sha256_final(&ctx_a);
bt_bytes_to_hex(hash_a, hash_a_, SHA256_SIZE);
struct hash_context ctx_b;
sha256_init(&ctx_b);
sha256_update(&ctx_b, str_b1, strlen(str_b1));
sha256_update(&ctx_b, str_b2, strlen(str_b2));
sha256_update(&ctx_b, str_b3, strlen(str_b3));
sha256_update(&ctx_b, str_b4, strlen(str_b4));
sha256_update(&ctx_b, str_b5, strlen(str_b5));
sha256_update(&ctx_b, str_b6, strlen(str_b6));
byte *hash_b_ = sha256_final(&ctx_b);
bt_bytes_to_hex(hash_b, hash_b_, SHA256_SIZE);
int are_hash_a_b_equal = (strncmp(hash_a, hash_b, sizeof(hash_a)) == 0);
bt_assert_msg(are_hash_a_b_equal, "Hashes A: %s, B: %s should be same", hash_a, hash_b);
return 1;
}
static int
t_sha512_concating(void)
{
char hash_a[SHA512_HEX_SIZE];
char hash_b[SHA512_HEX_SIZE];
char *str_a = "a" "bb" "ccc" "dddd" "eeeee" "ffffff";
char *str_b1 = "a" ;
char *str_b2 = "bb" ;
char *str_b3 = "ccc" ;
char *str_b4 = "dddd" ;
char *str_b5 = "eeeee" ;
char *str_b6 = "ffffff";
struct hash_context ctx_a;
sha512_init(&ctx_a);
sha512_update(&ctx_a, str_a, strlen(str_a));
byte *hash_a_ = sha512_final(&ctx_a);
bt_bytes_to_hex(hash_a, hash_a_, SHA512_SIZE);
struct hash_context ctx_b;
sha512_init(&ctx_b);
sha512_update(&ctx_b, str_b1, strlen(str_b1));
sha512_update(&ctx_b, str_b2, strlen(str_b2));
sha512_update(&ctx_b, str_b3, strlen(str_b3));
sha512_update(&ctx_b, str_b4, strlen(str_b4));
sha512_update(&ctx_b, str_b5, strlen(str_b5));
sha512_update(&ctx_b, str_b6, strlen(str_b6));
byte *hash_b_ = sha512_final(&ctx_b);
bt_bytes_to_hex(hash_b, hash_b_, SHA512_SIZE);
int are_hash_a_b_equal = (strncmp(hash_a, hash_b, sizeof(hash_a)) == 0);
bt_assert_msg(are_hash_a_b_equal, "Hashes A: %s, B: %s should be same", hash_a, hash_b);
return 1;
}
#include "lib/blake2.h"
#include "lib/blake2-kat.h"
static void
blake_in_fmt(char *buf, size_t size, const void *data, size_t key_len)
{
uint8_t in[BLAKE2_KAT_LENGTH] = {0};
uint8_t key[64] = {0};
size_t i, len = (size_t)data;
if (size < len*2+key_len*2+2)
return;
for (i = 0; i < sizeof(in); ++i)
in[i] = i;
for (i = 0; i < sizeof(key); ++i)
key[i] = i;
bt_bytes_to_hex(buf, in, len);
buf[len*2] = ',';
bt_bytes_to_hex(buf+len*2+1, key, key_len);
}
#define define_blake_fmt(name, sz) \
static void \
name##_in_fmt(char *buf, size_t size, const void *data) \
{ \
if (size < sz * 2 + 1) \
return; \
blake_in_fmt(buf, size, data, sz); \
} \
static void \
name##_out_fmt(char *buf, size_t size, const void *data) \
{ \
if (size < sz * 2) \
return; \
bt_bytes_to_hex(buf, data, sz); \
}
define_blake_fmt(blake2s, BLAKE2S_256_SIZE)
define_blake_fmt(blake2b, BLAKE2B_512_SIZE)
#define define_test_blake_fn(name, id) \
static int test_##name(void *out_, const void *in_, \
const void *expected_out_) { \
uint8_t in[BLAKE2_KAT_LENGTH] = {0}; \
uint8_t key[64] = {0}; \
uint len = mac_type_length(id); \
uint in_len = (size_t)in_; \
byte *out; \
size_t i; \
\
for (i = 0; i < sizeof(in); ++i) \
in[i] = i; \
\
for (i = 0; i < sizeof(key); ++i) \
key[i] = i; \
\
struct mac_context ctx; \
mac_init(&ctx, id, key, len); \
mac_update(&ctx, in, in_len); \
out = mac_final(&ctx); \
memcpy(out_, out, len); \
return memcmp(out, expected_out_, len) == 0; \
}
define_test_blake_fn(blake2s, ALG_BLAKE2S_256)
define_test_blake_fn(blake2b, ALG_BLAKE2B_512)
#define define_t_blake(name) \
static int \
t_##name(void) \
{ \
struct bt_pair test_vectors[BLAKE2_KAT_LENGTH]; \
size_t i; \
\
for (i = 0; i < BLAKE2_KAT_LENGTH; i++) { \
test_vectors[i].in = (void *)i; \
test_vectors[i].out = name##_keyed_kat[i]; \
} \
\
return bt_assert_batch(test_vectors, test_##name, name##_in_fmt, name##_out_fmt); \
}
define_t_blake(blake2s)
define_t_blake(blake2b)
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_md5, "Testing MD5 by RFC 1321");
bt_test_suite(t_sha1, "Testing SHA-1");
bt_test_suite(t_sha224, "Testing SHA-224");
bt_test_suite(t_sha256, "Testing SHA-256");
bt_test_suite(t_sha384, "Testing SHA-384");
bt_test_suite(t_sha512, "Testing SHA-512");
bt_test_suite(t_md5_hmac, "Testing HMAC-MD5 by RFC 2202");
bt_test_suite(t_sha1_hmac, "Testing HMAC-SHA-1 by RFC 2202");
bt_test_suite(t_sha224_hmac, "Testing HMAC-SHA-224 by RFC 4231");
bt_test_suite(t_sha256_hmac, "Testing HMAC-SHA-256 by RFC 4231");
bt_test_suite(t_sha384_hmac, "Testing HMAC-SHA-384 by RFC 4231");
bt_test_suite(t_sha512_hmac, "Testing HMAC-SHA-512 by RFC 4231");
bt_test_suite(t_sha256_concating, "Testing concatenation input string to hash using sha256_update");
bt_test_suite(t_sha512_concating, "Testing concatenation input string to hash using sha512_update");
bt_test_suite(t_blake2s, "Testing Blake2s-256");
bt_test_suite(t_blake2b, "Testing Blake2b-512");
return bt_exit_value();
}
bird2-2.17.5/lib/macro.h 0000664 0000000 0000000 00000007104 15211753245 0014637 0 ustar 00root root 0000000 0000000 /*
* BIRD Macro Tricks
*
* (c) 2018 Jan Maria Matejka
*
* Can be freely distributed and used under the terms of the GNU GPL.
*
* Contains useful but dirty macro tricks:
* MACRO_CONCAT(a, b) -> concatenates a##b
* MACRO_BOOL(x) -> convert 0 to 0, anything else to 1
* MACRO_IFELSE(b)(true-branch)(false-branch)
* -> b shall be 0 or 1; expands to the appropriate branch
* MACRO_ISEMPTY(...) -> 1 for empty argument list, 0 otherwise
* MACRO_FOREACH(func, ...)
* -> calling FOREACH(func, a, b, c, d) expands to
* func(a) func(b) func(c) func(d)
* MACRO_RPACK(func, terminator, ...)
* -> packs the list into recursive calls:
* func(func(func(func(terminator, a), b), c), d)
*/
#ifndef _BIRD_MACRO_H_
#define _BIRD_MACRO_H_
/* What to do with args */
#define MACRO_DROP(...)
#define MACRO_UNPAREN(...) __VA_ARGS__
#define MACRO_SEP(a, b, sep) a sep b
/* Aliases for some special chars */
#define MACRO_COMMA ,
#define MACRO_LPAREN (
#define MACRO_RPAREN )
#define MACRO_LPAREN_() (
#define MACRO_RPAREN_() )
/* Multiple expansion trick */
#define MACRO_EXPAND0(...) __VA_ARGS__
#define MACRO_EXPAND1(...) MACRO_EXPAND0(MACRO_EXPAND0(__VA_ARGS__))
#define MACRO_EXPAND2(...) MACRO_EXPAND1(MACRO_EXPAND1(__VA_ARGS__))
#define MACRO_EXPAND3(...) MACRO_EXPAND2(MACRO_EXPAND2(__VA_ARGS__))
#define MACRO_EXPAND(...) MACRO_EXPAND3(MACRO_EXPAND3(__VA_ARGS__))
/* Deferring expansion in the expansion trick */
#define MACRO_EMPTY()
#define MACRO_DEFER(t) t MACRO_EMPTY()
#define MACRO_DEFER2(t) t MACRO_EMPTY MACRO_EMPTY()()
#define MACRO_DEFER3(t) t MACRO_EMPTY MACRO_EMPTY MACRO_EMPTY()()()
/* Token concatenation */
#define MACRO_CONCAT(prefix, ...) prefix##__VA_ARGS__
#define MACRO_CONCAT_AFTER(...) MACRO_CONCAT(__VA_ARGS__)
/* Get first or second argument only */
#define MACRO_FIRST(a, ...) a
#define MACRO_SECOND(a, b, ...) b
#define MACRO_SECOND_OR_ZERO(...) MACRO_SECOND(__VA_ARGS__, 0,)
/* Macro Boolean auxiliary macros */
#define MACRO_BOOL_CHECK_0 ~, 1
#define MACRO_BOOL_NEG(x) MACRO_SECOND_OR_ZERO(MACRO_CONCAT(MACRO_BOOL_CHECK_, x))
#define MACRO_BOOL_NOT_0 1
#define MACRO_BOOL_NOT_1 0
/* Macro Boolean negation */
#define MACRO_NOT(x) MACRO_CONCAT(MACRO_BOOL_NOT_, x)
/* Convert anything to bool (anything -> 1, 0 -> 0) */
#define MACRO_BOOL(x) MACRO_NOT(MACRO_BOOL_NEG(x))
/*
* Macro If/Else condition
* Usage: MACRO_IFELSE(condition)(true-branch)(false-branch)
* Expands to true-branch if condition is true, otherwise to false-branch.
*/
#define MACRO_IFELSE(b) MACRO_CONCAT(MACRO_IFELSE_, b)
#define MACRO_IFELSE_0(...) MACRO_UNPAREN
#define MACRO_IFELSE_1(...) __VA_ARGS__ MACRO_DROP
/* Auxiliary macros for MACRO_FOREACH */
#define MACRO_ISLAST(...) MACRO_BOOL_NEG(MACRO_FIRST(MACRO_ISLAST_CHECK __VA_ARGS__)())
#define MACRO_ISLAST_CHECK() 0
#define MACRO_FOREACH_EXPAND(call, a, ...) MACRO_IFELSE(MACRO_ISLAST(__VA_ARGS__))(call(a))(call(a) MACRO_DEFER2(MACRO_FOREACH_PAREN)()(call, __VA_ARGS__))
#define MACRO_FOREACH_PAREN() MACRO_FOREACH_EXPAND
#define MACRO_RPACK_EXPAND(call, terminator, a, ...) MACRO_IFELSE(MACRO_ISLAST(__VA_ARGS__))(call(terminator, a))(call(MACRO_DEFER2(MACRO_RPACK_PAREN)()(call, terminator, __VA_ARGS__), a))
#define MACRO_RPACK_PAREN() MACRO_RPACK_EXPAND
/*
* Call the first argument for each following:
* MACRO_FOREACH(func, a, b, c, d) expands to func(a) func(b) func(c) func(d).
* It supports also macros as func.
*/
#define MACRO_FOREACH(call, ...) MACRO_EXPAND(MACRO_FOREACH_EXPAND(call, __VA_ARGS__))
#define MACRO_RPACK(call, terminator, ...) MACRO_EXPAND(MACRO_RPACK_EXPAND(call, terminator, __VA_ARGS__))
#endif
bird2-2.17.5/lib/md5.c 0000664 0000000 0000000 00000016373 15211753245 0014226 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- MD5 Hash Function and HMAC-MD5 Function
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* The code was written by Colin Plumb in 1993, no copyright is claimed.
*
* Adapted for BIRD by Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "lib/md5.h"
#ifdef CPU_LITTLE_ENDIAN
#define byteReverse(buf, len) /* Nothing */
#else
void byteReverse(byte *buf, uint longs);
/*
* Note: this code is harmless on little-endian machines.
*/
void byteReverse(byte *buf, uint longs)
{
u32 t;
do {
t = (u32) ((uint) buf[3] << 8 | buf[2]) << 16 |
((uint) buf[1] << 8 | buf[0]);
*(u32 *) buf = t;
buf += 4;
} while (--longs);
}
#endif
static void md5_transform(u32 buf[4], u32 const in[16]);
/*
* Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
* initialization constants.
*/
void
md5_init(struct hash_context *CTX)
{
struct md5_context *ctx = (void *) CTX;
ctx->buf[0] = 0x67452301;
ctx->buf[1] = 0xefcdab89;
ctx->buf[2] = 0x98badcfe;
ctx->buf[3] = 0x10325476;
ctx->bits[0] = 0;
ctx->bits[1] = 0;
}
/*
* Update context to reflect the concatenation of another buffer full
* of bytes.
*/
void
md5_update(struct hash_context *CTX, const byte *buf, uint len)
{
struct md5_context *ctx = (void *) CTX;
u32 t;
/* Update bitcount */
t = ctx->bits[0];
if ((ctx->bits[0] = t + ((u32) len << 3)) < t)
ctx->bits[1]++; /* Carry from low to high */
ctx->bits[1] += len >> 29;
t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
/* Handle any leading odd-sized chunks */
if (t)
{
byte *p = (byte *) ctx->in + t;
t = 64 - t;
if (len < t)
{
memcpy(p, buf, len);
return;
}
memcpy(p, buf, t);
byteReverse(ctx->in, 16);
md5_transform(ctx->buf, (u32 *) ctx->in);
buf += t;
len -= t;
}
/* Process data in 64-byte chunks */
while (len >= 64)
{
memcpy(ctx->in, buf, 64);
byteReverse(ctx->in, 16);
md5_transform(ctx->buf, (u32 *) ctx->in);
buf += 64;
len -= 64;
}
/* Handle any remaining bytes of data. */
memcpy(ctx->in, buf, len);
}
/*
* Final wrapup - pad to 64-byte boundary with the bit pattern
* 1 0* (64-bit count of bits processed, MSB-first)
*/
byte *
md5_final(struct hash_context *CTX)
{
struct md5_context *ctx = (void *) CTX;
uint count;
byte *p;
/* Compute number of bytes mod 64 */
count = (ctx->bits[0] >> 3) & 0x3F;
/* Set the first char of padding to 0x80. This is safe since there is
always at least one byte free */
p = ctx->in + count;
*p++ = 0x80;
/* Bytes of padding needed to make 64 bytes */
count = 64 - 1 - count;
/* Pad out to 56 mod 64 */
if (count < 8)
{
/* Two lots of padding: Pad the first block to 64 bytes */
memset(p, 0, count);
byteReverse(ctx->in, 16);
md5_transform(ctx->buf, (u32 *) ctx->in);
/* Now fill the next block with 56 bytes */
memset(ctx->in, 0, 56);
}
else
{
/* Pad block to 56 bytes */
memset(p, 0, count - 8);
}
byteReverse(ctx->in, 14);
/* Append length in bits and transform */
((u32 *) ctx->in)[14] = ctx->bits[0];
((u32 *) ctx->in)[15] = ctx->bits[1];
md5_transform(ctx->buf, (u32 *) ctx->in);
byteReverse((byte *) ctx->buf, 4);
return (byte*) ctx->buf;
}
/* The four core functions - F1 is optimized somewhat */
/* #define F1(x, y, z) (x & y | ~x & z) */
#define F1(x, y, z) (z ^ (x & (y ^ z)))
#define F2(x, y, z) F1(z, x, y)
#define F3(x, y, z) (x ^ y ^ z)
#define F4(x, y, z) (y ^ (x | ~z))
/* This is the central step in the MD5 algorithm. */
#define MD5STEP(f, w, x, y, z, data, s) \
( w += f(x, y, z) + data, w = w<>(32-s), w += x )
/*
* The core of the MD5 algorithm, this alters an existing MD5 hash to
* reflect the addition of 16 longwords of new data. MD5Update blocks
* the data and converts bytes into longwords for this routine.
*/
void
md5_transform(u32 buf[4], u32 const in[16])
{
register u32 a, b, c, d;
a = buf[0];
b = buf[1];
c = buf[2];
d = buf[3];
MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
buf[0] += a;
buf[1] += b;
buf[2] += c;
buf[3] += d;
}
bird2-2.17.5/lib/md5.h 0000664 0000000 0000000 00000001177 15211753245 0014227 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- MD5 Hash Function and HMAC-MD5 Function
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Adapted for BIRD by Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_MD5_H_
#define _BIRD_MD5_H_
#include "nest/bird.h"
#define MD5_SIZE 16
#define MD5_HEX_SIZE 33
#define MD5_BLOCK_SIZE 64
struct hash_context;
struct md5_context {
u32 buf[4];
u32 bits[2];
byte in[64];
};
void md5_init(struct hash_context *ctx);
void md5_update(struct hash_context *ctx, const byte *buf, uint len);
byte *md5_final(struct hash_context *ctx);
#endif /* _BIRD_MD5_H_ */
bird2-2.17.5/lib/mempool.c 0000664 0000000 0000000 00000016754 15211753245 0015214 0 ustar 00root root 0000000 0000000 /*
* BIRD Resource Manager -- Memory Pools
*
* (c) 1998--2000 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
/**
* DOC: Linear memory pools
*
* Linear memory pools are collections of memory blocks which
* support very fast allocation of new blocks, but are able to free only
* the whole collection at once (or in stack order).
*
* Example: Each configuration is described by a complex system of structures,
* linked lists and function trees which are all allocated from a single linear
* pool, thus they can be freed at once when the configuration is no longer used.
*/
#include
#include
#include "nest/bird.h"
#include "lib/resource.h"
#include "lib/string.h"
struct lp_chunk {
struct lp_chunk *next;
max_align_t data_align[0];
byte data[0];
};
#define LP_DATA_SIZE (page_size - OFFSETOF(struct lp_chunk, data))
struct linpool {
resource r;
byte *ptr, *end;
struct lp_chunk *first, *current; /* Normal (reusable) chunks */
struct lp_chunk *first_large; /* Large chunks */
uint total, total_large;
};
_Thread_local linpool *tmp_linpool;
static void lp_free(resource *);
static void lp_dump(struct dump_request *, resource *);
static resource *lp_lookup(resource *, unsigned long);
static struct resmem lp_memsize(resource *r);
static struct resclass lp_class = {
"LinPool",
sizeof(struct linpool),
lp_free,
lp_dump,
lp_lookup,
lp_memsize
};
/**
* lp_new - create a new linear memory pool
* @p: pool
*
* lp_new() creates a new linear memory pool resource inside the pool @p.
* The linear pool consists of a list of memory chunks of page size.
*/
linpool
*lp_new(pool *p)
{
return ralloc(p, &lp_class);
}
/**
* lp_alloc - allocate memory from a &linpool
* @m: linear memory pool
* @size: amount of memory
*
* lp_alloc() allocates @size bytes of memory from a &linpool @m
* and it returns a pointer to the allocated memory.
*
* It works by trying to find free space in the last memory chunk
* associated with the &linpool and creating a new chunk of the standard
* size (as specified during lp_new()) if the free space is too small
* to satisfy the allocation. If @size is too large to fit in a standard
* size chunk, an "overflow" chunk is created for it instead.
*/
void *
lp_alloc(linpool *m, uint size)
{
byte *a = (byte *) BIRD_ALIGN((unsigned long) m->ptr, CPU_STRUCT_ALIGN);
byte *e = a + size;
if (e <= m->end)
{
m->ptr = e;
return a;
}
else
{
struct lp_chunk *c;
if (size > LP_DATA_SIZE)
{
/* Too large => allocate large chunk */
c = xmalloc(sizeof(struct lp_chunk) + size);
m->total_large += size;
c->next = m->first_large;
m->first_large = c;
}
else
{
if (m->current && m->current->next)
{
/* Still have free chunks from previous incarnation (before lp_flush()) */
c = m->current->next;
}
else
{
/* Need to allocate a new chunk */
c = alloc_page();
m->total += LP_DATA_SIZE;
c->next = NULL;
if (m->current)
m->current->next = c;
else
m->first = c;
}
m->current = c;
m->ptr = c->data + size;
m->end = c->data + LP_DATA_SIZE;
}
return c->data;
}
}
/**
* lp_allocu - allocate unaligned memory from a &linpool
* @m: linear memory pool
* @size: amount of memory
*
* lp_allocu() allocates @size bytes of memory from a &linpool @m
* and it returns a pointer to the allocated memory. It doesn't
* attempt to align the memory block, giving a very efficient way
* how to allocate strings without any space overhead.
*/
void *
lp_allocu(linpool *m, uint size)
{
byte *a = m->ptr;
byte *e = a + size;
if (e <= m->end)
{
m->ptr = e;
return a;
}
return lp_alloc(m, size);
}
/**
* lp_allocz - allocate cleared memory from a &linpool
* @m: linear memory pool
* @size: amount of memory
*
* This function is identical to lp_alloc() except that it
* clears the allocated memory block.
*/
void *
lp_allocz(linpool *m, uint size)
{
void *z = lp_alloc(m, size);
bzero(z, size);
return z;
}
/**
* lp_flush - flush a linear memory pool
* @m: linear memory pool
*
* This function frees the whole contents of the given &linpool @m,
* but leaves the pool itself.
*/
void
lp_flush(linpool *m)
{
struct lp_chunk *c;
/* Move ptr to the first chunk and free all other chunks */
m->current = c = m->first;
m->ptr = c ? c->data : NULL;
m->end = c ? c->data + LP_DATA_SIZE : NULL;
while (c && c->next)
{
struct lp_chunk *d = c->next;
c->next = d->next;
free_page(d);
}
while (c = m->first_large)
{
m->first_large = c->next;
xfree(c);
}
m->total_large = 0;
}
/**
* lp_save - save the state of a linear memory pool
* @m: linear memory pool
* @p: state buffer
*
* This function saves the state of a linear memory pool. Saved state can be
* used later to restore the pool (to free memory allocated since).
*/
void
lp_save(linpool *m, lp_state *p)
{
p->current = m->current;
p->large = m->first_large;
p->total_large = m->total_large;
p->ptr = m->ptr;
}
/**
* lp_restore - restore the state of a linear memory pool
* @m: linear memory pool
* @p: saved state
*
* This function restores the state of a linear memory pool, freeing all memory
* allocated since the state was saved. Note that the function cannot un-free
* the memory, therefore the function also invalidates other states that were
* saved between (on the same pool).
*/
void
lp_restore(linpool *m, lp_state *p)
{
struct lp_chunk *c;
/* Move ptr to the saved pos and free all newer large chunks */
m->current = c = p->current ?: m->first;
m->ptr = p->ptr ?: (c ? c->data : NULL);
m->end = c ? (c->data + LP_DATA_SIZE) : NULL;
m->total_large = p->total_large;
while ((c = m->first_large) && (c != p->large))
{
m->first_large = c->next;
xfree(c);
}
}
static void
lp_free(resource *r)
{
linpool *m = (linpool *) r;
struct lp_chunk *c, *d;
for(d=m->first; d; d = c)
{
c = d->next;
free_page(d);
}
for(d=m->first_large; d; d = c)
{
c = d->next;
xfree(d);
}
}
static void
lp_dump(struct dump_request *dreq, resource *r)
{
linpool *m = (linpool *) r;
int chunks = 0, large = 0;
RDUMP("\n%*schunks:\n", dreq->indent+3, "");
for (struct lp_chunk *c = m->first; c; c = c->next)
{
RDUMP("%*s%p\n", dreq->indent+6, "", c);
chunks++;
}
RDUMP("%*scount=%d total=%d\n", dreq->indent+3, "", chunks, m->total);
RDUMP("%*slarge:\n", dreq->indent+3, "");
for (struct lp_chunk *c = m->first_large; c; c = c->next)
{
RDUMP("%*s%p\n", dreq->indent+6, "", c);
large++;
}
RDUMP("%*scount=%d total=%d\n", dreq->indent+3, "", large, m->total_large);
}
static struct resmem
lp_memsize(resource *r)
{
linpool *m = (linpool *) r;
struct resmem sz = {
.overhead = sizeof(struct linpool) + ALLOC_OVERHEAD,
.effective = m->total_large,
};
for (struct lp_chunk *c = m->first_large; c; c = c->next)
sz.overhead += sizeof(struct lp_chunk) + ALLOC_OVERHEAD;
uint regular = 0;
for (struct lp_chunk *c = m->first; c; c = c->next)
regular++;
sz.effective += LP_DATA_SIZE * regular;
sz.overhead += (sizeof(struct lp_chunk) + ALLOC_OVERHEAD) * regular;
return sz;
}
static resource *
lp_lookup(resource *r, unsigned long a)
{
linpool *m = (linpool *) r;
struct lp_chunk *c;
for(c=m->first; c; c=c->next)
if ((unsigned long) c->data <= a && (unsigned long) c->data + LP_DATA_SIZE > a)
return r;
return NULL;
}
bird2-2.17.5/lib/net.c 0000664 0000000 0000000 00000024561 15211753245 0014325 0 ustar 00root root 0000000 0000000
#include "nest/bird.h"
#include "lib/ip.h"
#include "lib/net.h"
#include "lib/flowspec.h"
const char * const net_label[] = {
[NET_IP4] = "ipv4",
[NET_IP6] = "ipv6",
[NET_VPN4] = "vpn4",
[NET_VPN6] = "vpn6",
[NET_ROA4] = "roa4",
[NET_ROA6] = "roa6",
[NET_FLOW4] = "flow4",
[NET_FLOW6] = "flow6",
[NET_IP6_SADR]= "ipv6-sadr",
[NET_MPLS] = "mpls",
[NET_ASPA] = "aspa",
};
const u16 net_addr_length[] = {
[NET_IP4] = sizeof(net_addr_ip4),
[NET_IP6] = sizeof(net_addr_ip6),
[NET_VPN4] = sizeof(net_addr_vpn4),
[NET_VPN6] = sizeof(net_addr_vpn6),
[NET_ROA4] = sizeof(net_addr_roa4),
[NET_ROA6] = sizeof(net_addr_roa6),
[NET_FLOW4] = 0,
[NET_FLOW6] = 0,
[NET_IP6_SADR]= sizeof(net_addr_ip6_sadr),
[NET_MPLS] = sizeof(net_addr_mpls),
[NET_ASPA] = sizeof(net_addr_aspa),
};
const u8 net_max_prefix_length[] = {
[NET_IP4] = IP4_MAX_PREFIX_LENGTH,
[NET_IP6] = IP6_MAX_PREFIX_LENGTH,
[NET_VPN4] = IP4_MAX_PREFIX_LENGTH,
[NET_VPN6] = IP6_MAX_PREFIX_LENGTH,
[NET_ROA4] = IP4_MAX_PREFIX_LENGTH,
[NET_ROA6] = IP6_MAX_PREFIX_LENGTH,
[NET_FLOW4] = IP4_MAX_PREFIX_LENGTH,
[NET_FLOW6] = IP6_MAX_PREFIX_LENGTH,
[NET_IP6_SADR]= IP6_MAX_PREFIX_LENGTH,
[NET_MPLS] = 0,
[NET_ASPA] = 0,
};
const u16 net_max_text_length[] = {
[NET_IP4] = 18, /* "255.255.255.255/32" */
[NET_IP6] = 43, /* "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128" */
[NET_VPN4] = 40, /* "4294967296:4294967296 255.255.255.255/32" */
[NET_VPN6] = 65, /* "4294967296:4294967296 ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128" */
[NET_ROA4] = 34, /* "255.255.255.255/32-32 AS4294967295" */
[NET_ROA6] = 60, /* "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128-128 AS4294967295" */
[NET_FLOW4] = 0, /* "flow4 { ... }" */
[NET_FLOW6] = 0, /* "flow6 { ... }" */
[NET_IP6_SADR]= 92, /* "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128 from ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128" */
[NET_MPLS] = 7, /* "1048575" */
[NET_ASPA] = 10, /* "4294967295" */
};
/* There should be no implicit padding in net_addr structures */
STATIC_ASSERT(sizeof(net_addr) == 24);
STATIC_ASSERT(sizeof(net_addr_ip4) == 8);
STATIC_ASSERT(sizeof(net_addr_ip6) == 20);
STATIC_ASSERT(sizeof(net_addr_vpn4) == 16);
STATIC_ASSERT(sizeof(net_addr_vpn6) == 32);
STATIC_ASSERT(sizeof(net_addr_roa4) == 16);
STATIC_ASSERT(sizeof(net_addr_roa6) == 28);
STATIC_ASSERT(sizeof(net_addr_flow4) == 8);
STATIC_ASSERT(sizeof(net_addr_flow6) == 20);
STATIC_ASSERT(sizeof(net_addr_ip6_sadr) == 40);
STATIC_ASSERT(sizeof(net_addr_mpls) == 8);
STATIC_ASSERT(sizeof(net_addr_aspa) == 8);
/* Ensure that all net_addr structures have the same alignment */
STATIC_ASSERT(alignof(net_addr_ip4) == alignof(net_addr));
STATIC_ASSERT(alignof(net_addr_ip6) == alignof(net_addr));
STATIC_ASSERT(alignof(net_addr_vpn4) == alignof(net_addr));
STATIC_ASSERT(alignof(net_addr_vpn6) == alignof(net_addr));
STATIC_ASSERT(alignof(net_addr_roa4) == alignof(net_addr));
STATIC_ASSERT(alignof(net_addr_roa6) == alignof(net_addr));
STATIC_ASSERT(alignof(net_addr_flow4) == alignof(net_addr));
STATIC_ASSERT(alignof(net_addr_flow6) == alignof(net_addr));
STATIC_ASSERT(alignof(net_addr_flow4) == alignof(net_addr));
STATIC_ASSERT(alignof(net_addr_flow6) == alignof(net_addr));
STATIC_ASSERT(alignof(net_addr_ip6_sadr) == alignof(net_addr));
STATIC_ASSERT(alignof(net_addr_mpls) == alignof(net_addr));
STATIC_ASSERT(alignof(net_addr_aspa) == alignof(net_addr));
int
rd_format(const vpn_rd rd_, char *buf, int buflen)
{
u64 rd = rd_to_u64(rd_);
switch (rd >> 48)
{
case 0: return bsnprintf(buf, buflen, "%u:%u", (u32) (rd >> 32), (u32) rd);
case 1: return bsnprintf(buf, buflen, "%I4:%u", ip4_from_u32(rd >> 16), (u32) (rd & 0xffff));
case 2: if (((u32) (rd >> 16)) >> 16)
return bsnprintf(buf, buflen, "%u:%u", (u32) (rd >> 16), (u32) (rd & 0xffff));
else
return bsnprintf(buf, buflen, "2:%u:%u", (u32) (rd >> 16), (u32) (rd & 0xffff));
default: return bsnprintf(buf, buflen, "X:%08x:%08x", (u32) (rd >> 32), (u32) rd);
}
}
int
net_format(const net_addr *N, char *buf, int buflen)
{
net_addr_union *n = (void *) N;
buf[0] = 0;
switch (n->n.type)
{
case NET_IP4:
return (buflen < IP4_PX_BUFFER_SIZE) ? -1 : ip4_px_ntop(n->ip4.prefix, n->ip4.pxlen, buf) - buf;
case NET_IP6:
return bsnprintf(buf, buflen, "%I6/%d", n->ip6.prefix, n->ip6.pxlen);
case NET_VPN4:
{
int c = rd_format(n->vpn4.rd, buf, buflen);
ADVANCE(buf, buflen, c);
return bsnprintf(buf, buflen, " %I4/%d", n->vpn4.prefix, n->vpn4.pxlen);
}
case NET_VPN6:
{
/* XXX: RD format is specified for VPN4; not found any for VPN6, reusing the same as for VPN4 */
int c = rd_format(n->vpn6.rd, buf, buflen);
ADVANCE(buf, buflen, c);
return bsnprintf(buf, buflen, " %I6/%d", n->vpn6.prefix, n->vpn6.pxlen);
}
case NET_ROA4:
return bsnprintf(buf, buflen, "%I4/%u-%u AS%u", n->roa4.prefix, n->roa4.pxlen, n->roa4.max_pxlen, n->roa4.asn);
case NET_ROA6:
return bsnprintf(buf, buflen, "%I6/%u-%u AS%u", n->roa6.prefix, n->roa6.pxlen, n->roa6.max_pxlen, n->roa6.asn);
case NET_FLOW4:
return flow4_net_format(buf, buflen, &n->flow4);
case NET_FLOW6:
return flow6_net_format(buf, buflen, &n->flow6);
case NET_IP6_SADR:
return bsnprintf(buf, buflen, "%I6/%d from %I6/%d", n->ip6_sadr.dst_prefix, n->ip6_sadr.dst_pxlen, n->ip6_sadr.src_prefix, n->ip6_sadr.src_pxlen);
case NET_MPLS:
return bsnprintf(buf, buflen, "%u", n->mpls.label);
case NET_ASPA:
return bsnprintf(buf, buflen, "%u", n->aspa.asn);
}
bug("unknown network type");
}
ip_addr
net_pxmask(const net_addr *a)
{
switch (a->type)
{
case NET_IP4:
case NET_VPN4:
case NET_ROA4:
case NET_FLOW4:
return ipa_from_ip4(ip4_mkmask(net4_pxlen(a)));
case NET_IP6:
case NET_VPN6:
case NET_ROA6:
case NET_FLOW6:
case NET_IP6_SADR:
return ipa_from_ip6(ip6_mkmask(net6_pxlen(a)));
case NET_MPLS:
case NET_ASPA:
default:
return IPA_NONE;
}
}
int
net_compare(const net_addr *a, const net_addr *b)
{
if (a->type != b->type)
return uint_cmp(a->type, b->type);
switch (a->type)
{
case NET_IP4:
return net_compare_ip4((const net_addr_ip4 *) a, (const net_addr_ip4 *) b);
case NET_IP6:
return net_compare_ip6((const net_addr_ip6 *) a, (const net_addr_ip6 *) b);
case NET_VPN4:
return net_compare_vpn4((const net_addr_vpn4 *) a, (const net_addr_vpn4 *) b);
case NET_VPN6:
return net_compare_vpn6((const net_addr_vpn6 *) a, (const net_addr_vpn6 *) b);
case NET_ROA4:
return net_compare_roa4((const net_addr_roa4 *) a, (const net_addr_roa4 *) b);
case NET_ROA6:
return net_compare_roa6((const net_addr_roa6 *) a, (const net_addr_roa6 *) b);
case NET_FLOW4:
return net_compare_flow4((const net_addr_flow4 *) a, (const net_addr_flow4 *) b);
case NET_FLOW6:
return net_compare_flow6((const net_addr_flow6 *) a, (const net_addr_flow6 *) b);
case NET_IP6_SADR:
return net_compare_ip6_sadr((const net_addr_ip6_sadr *) a, (const net_addr_ip6_sadr *) b);
case NET_MPLS:
return net_compare_mpls((const net_addr_mpls *) a, (const net_addr_mpls *) b);
case NET_ASPA:
return net_compare_aspa((const net_addr_aspa *) a, (const net_addr_aspa *) b);
}
return 0;
}
#define NET_HASH(a,t) net_hash_##t((const net_addr_##t *) a)
u32
net_hash(const net_addr *n)
{
switch (n->type)
{
case NET_IP4: return NET_HASH(n, ip4);
case NET_IP6: return NET_HASH(n, ip6);
case NET_VPN4: return NET_HASH(n, vpn4);
case NET_VPN6: return NET_HASH(n, vpn6);
case NET_ROA4: return NET_HASH(n, roa4);
case NET_ROA6: return NET_HASH(n, roa6);
case NET_FLOW4: return NET_HASH(n, flow4);
case NET_FLOW6: return NET_HASH(n, flow6);
case NET_IP6_SADR: return NET_HASH(n, ip6_sadr);
case NET_MPLS: return NET_HASH(n, mpls);
case NET_ASPA: return NET_HASH(n, aspa);
default: bug("invalid type");
}
}
#define NET_VALIDATE(a,t) net_validate_##t((const net_addr_##t *) a)
int
net_validate(const net_addr *n)
{
switch (n->type)
{
case NET_IP4: return NET_VALIDATE(n, ip4);
case NET_IP6: return NET_VALIDATE(n, ip6);
case NET_VPN4: return NET_VALIDATE(n, vpn4);
case NET_VPN6: return NET_VALIDATE(n, vpn6);
case NET_ROA4: return NET_VALIDATE(n, roa4);
case NET_ROA6: return NET_VALIDATE(n, roa6);
case NET_FLOW4: return NET_VALIDATE(n, flow4);
case NET_FLOW6: return NET_VALIDATE(n, flow6);
case NET_IP6_SADR: return NET_VALIDATE(n, ip6_sadr);
case NET_MPLS: return NET_VALIDATE(n, mpls);
case NET_ASPA: return NET_VALIDATE(n, aspa);
default: return 0;
}
}
void
net_normalize(net_addr *N)
{
net_addr_union *n = (void *) N;
switch (n->n.type)
{
case NET_IP4:
case NET_VPN4:
case NET_ROA4:
case NET_FLOW4:
return net_normalize_ip4(&n->ip4);
case NET_IP6:
case NET_VPN6:
case NET_ROA6:
case NET_FLOW6:
return net_normalize_ip6(&n->ip6);
case NET_IP6_SADR:
return net_normalize_ip6_sadr(&n->ip6_sadr);
case NET_MPLS:
case NET_ASPA:
return;
}
}
int
net_classify(const net_addr *N)
{
net_addr_union *n = (void *) N;
switch (n->n.type)
{
case NET_IP4:
case NET_VPN4:
case NET_ROA4:
case NET_FLOW4:
return ip4_zero(n->ip4.prefix) ? (IADDR_HOST | SCOPE_UNIVERSE) : ip4_classify(n->ip4.prefix);
case NET_IP6:
case NET_VPN6:
case NET_ROA6:
case NET_FLOW6:
return ip6_zero(n->ip6.prefix) ? (IADDR_HOST | SCOPE_UNIVERSE) : ip6_classify(&n->ip6.prefix);
case NET_IP6_SADR:
return ip6_zero(n->ip6_sadr.dst_prefix) ? (IADDR_HOST | SCOPE_UNIVERSE) : ip6_classify(&n->ip6_sadr.dst_prefix);
case NET_MPLS:
case NET_ASPA:
return IADDR_HOST | SCOPE_UNIVERSE;
}
return IADDR_INVALID;
}
int
ipa_in_netX(const ip_addr a, const net_addr *n)
{
switch (n->type)
{
case NET_IP4:
case NET_VPN4:
case NET_ROA4:
case NET_FLOW4:
if (!ipa_is_ip4(a)) return 0;
return ip4_zero(ip4_and(ip4_xor(ipa_to_ip4(a), net4_prefix(n)),
ip4_mkmask(net4_pxlen(n))));
case NET_IP6:
case NET_VPN6:
case NET_ROA6:
case NET_FLOW6:
if (ipa_is_ip4(a)) return 0;
return ip6_zero(ip6_and(ip6_xor(ipa_to_ip6(a), net6_prefix(n)),
ip6_mkmask(net6_pxlen(n))));
case NET_IP6_SADR:
if (ipa_is_ip4(a)) return 0;
return ip6_zero(ip6_and(ip6_xor(ipa_to_ip6(a), net6_prefix(n)),
ip6_mkmask(net6_pxlen(n))));
case NET_MPLS:
case NET_ASPA:
default:
return 0;
}
}
int
net_in_netX(const net_addr *a, const net_addr *n)
{
if (a->type != n->type)
return 0;
return (net_pxlen(n) <= net_pxlen(a)) && ipa_in_netX(net_prefix(a), n);
}
bird2-2.17.5/lib/net.h 0000664 0000000 0000000 00000052230 15211753245 0014324 0 ustar 00root root 0000000 0000000 /*
* BIRD Internet Routing Daemon -- Network addresses
*
* (c) 2015 Ondrej Zajicek
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_NET_H_
#define _BIRD_NET_H_
#include "lib/ip.h"
#define NET_IP4 1
#define NET_IP6 2
#define NET_VPN4 3
#define NET_VPN6 4
#define NET_ROA4 5
#define NET_ROA6 6
#define NET_FLOW4 7
#define NET_FLOW6 8
#define NET_IP6_SADR 9
#define NET_MPLS 10
#define NET_ASPA 11
#define NET_MAX 12
#define NB_IP4 (1 << NET_IP4)
#define NB_IP6 (1 << NET_IP6)
#define NB_VPN4 (1 << NET_VPN4)
#define NB_VPN6 (1 << NET_VPN6)
#define NB_ROA4 (1 << NET_ROA4)
#define NB_ROA6 (1 << NET_ROA6)
#define NB_FLOW4 (1 << NET_FLOW4)
#define NB_FLOW6 (1 << NET_FLOW6)
#define NB_IP6_SADR (1 << NET_IP6_SADR)
#define NB_MPLS (1 << NET_MPLS)
#define NB_ASPA (1 << NET_ASPA)
#define NB_IP (NB_IP4 | NB_IP6)
#define NB_VPN (NB_VPN4 | NB_VPN6)
#define NB_ROA (NB_ROA4 | NB_ROA6)
#define NB_FLOW (NB_FLOW4 | NB_FLOW6)
#define NB_DEST (NB_IP | NB_IP6_SADR | NB_VPN | NB_MPLS)
#define NB_ANY 0xffffffff
typedef struct net_addr {
u8 type;
u8 pxlen;
u16 length;
u8 data[20];
u32 align[0];
} net_addr;
typedef struct net_addr_ip4 {
u8 type;
u8 pxlen;
u16 length;
ip4_addr prefix;
} net_addr_ip4;
typedef struct net_addr_ip6 {
u8 type;
u8 pxlen;
u16 length;
ip6_addr prefix;
} net_addr_ip6;
typedef struct net_addr_vpn4 {
u8 type;
u8 pxlen;
u16 length;
ip4_addr prefix;
vpn_rd rd;
} net_addr_vpn4;
typedef struct net_addr_vpn6 {
u8 type;
u8 pxlen;
u16 length;
ip6_addr prefix;
u32 padding;
vpn_rd rd;
} net_addr_vpn6;
typedef struct net_addr_roa4 {
u8 type;
u8 pxlen;
u16 length;
ip4_addr prefix;
u32 max_pxlen;
u32 asn;
} net_addr_roa4;
typedef struct net_addr_roa6 {
u8 type;
u8 pxlen;
u16 length;
ip6_addr prefix;
u32 max_pxlen;
u32 asn;
} net_addr_roa6;
typedef struct net_addr_flow4 {
u8 type;
u8 pxlen;
u16 length;
ip4_addr prefix;
byte data[0];
} net_addr_flow4;
typedef struct net_addr_flow6 {
u8 type;
u8 pxlen;
u16 length;
ip6_addr prefix;
byte data[0];
} net_addr_flow6;
typedef struct net_addr_mpls {
u8 type;
u8 pxlen;
u16 length;
u32 label;
} net_addr_mpls;
typedef struct net_addr_aspa {
u8 type;
u8 pxlen;
u16 length;
u32 asn;
} net_addr_aspa;
typedef struct net_addr_ip6_sadr {
u8 type;
u8 dst_pxlen;
u16 length;
ip6_addr dst_prefix;
s32 src_pxlen; /* s32 to avoid padding */
ip6_addr src_prefix;
} net_addr_ip6_sadr;
typedef union net_addr_union {
net_addr n;
net_addr_ip4 ip4;
net_addr_ip6 ip6;
net_addr_vpn4 vpn4;
net_addr_vpn6 vpn6;
net_addr_roa4 roa4;
net_addr_roa6 roa6;
net_addr_flow4 flow4;
net_addr_flow6 flow6;
net_addr_ip6_sadr ip6_sadr;
net_addr_mpls mpls;
net_addr_aspa aspa;
} net_addr_union;
extern const char * const net_label[];
extern const u16 net_addr_length[];
extern const u8 net_max_prefix_length[];
extern const u16 net_max_text_length[];
#define NET_MAX_TEXT_LENGTH 256
#define NET_ADDR_IP4(prefix,pxlen) \
((net_addr_ip4) { NET_IP4, pxlen, sizeof(net_addr_ip4), prefix })
#define NET_ADDR_IP6(prefix,pxlen) \
((net_addr_ip6) { NET_IP6, pxlen, sizeof(net_addr_ip6), prefix })
#define NET_ADDR_VPN4(prefix,pxlen,rd) \
((net_addr_vpn4) { NET_VPN4, pxlen, sizeof(net_addr_vpn4), prefix, rd })
#define NET_ADDR_VPN6(prefix,pxlen,rd) \
((net_addr_vpn6) { NET_VPN6, pxlen, sizeof(net_addr_vpn6), prefix, 0, rd })
#define NET_ADDR_ROA4(prefix,pxlen,max_pxlen,asn) \
((net_addr_roa4) { NET_ROA4, pxlen, sizeof(net_addr_roa4), prefix, max_pxlen, asn })
#define NET_ADDR_ROA6(prefix,pxlen,max_pxlen,asn) \
((net_addr_roa6) { NET_ROA6, pxlen, sizeof(net_addr_roa6), prefix, max_pxlen, asn })
#define NET_ADDR_FLOW4(prefix,pxlen,dlen) \
((net_addr_flow4) { NET_FLOW4, pxlen, sizeof(net_addr_flow4) + dlen, prefix })
#define NET_ADDR_FLOW6(prefix,pxlen,dlen) \
((net_addr_flow6) { NET_FLOW6, pxlen, sizeof(net_addr_flow6) + dlen, prefix })
#define NET_ADDR_IP6_SADR(dst_prefix,dst_pxlen,src_prefix,src_pxlen) \
((net_addr_ip6_sadr) { NET_IP6_SADR, dst_pxlen, sizeof(net_addr_ip6_sadr), dst_prefix, src_pxlen, src_prefix })
#define NET_ADDR_ASPA(asn) \
((net_addr_aspa) { NET_ASPA, 32, sizeof(net_addr_aspa), asn })
#define NET_ADDR_MPLS(label) \
((net_addr_mpls) { NET_MPLS, 20, sizeof(net_addr_mpls), label })
static inline void net_fill_ip4(net_addr *a, ip4_addr prefix, uint pxlen)
{ *(net_addr_ip4 *)a = NET_ADDR_IP4(prefix, pxlen); }
static inline void net_fill_ip6(net_addr *a, ip6_addr prefix, uint pxlen)
{ *(net_addr_ip6 *)a = NET_ADDR_IP6(prefix, pxlen); }
static inline void net_fill_vpn4(net_addr *a, ip4_addr prefix, uint pxlen, vpn_rd rd)
{ *(net_addr_vpn4 *)a = NET_ADDR_VPN4(prefix, pxlen, rd); }
static inline void net_fill_vpn6(net_addr *a, ip6_addr prefix, uint pxlen, vpn_rd rd)
{ *(net_addr_vpn6 *)a = NET_ADDR_VPN6(prefix, pxlen, rd); }
static inline void net_fill_roa4(net_addr *a, ip4_addr prefix, uint pxlen, uint max_pxlen, u32 asn)
{ *(net_addr_roa4 *)a = NET_ADDR_ROA4(prefix, pxlen, max_pxlen, asn); }
static inline void net_fill_roa6(net_addr *a, ip6_addr prefix, uint pxlen, uint max_pxlen, u32 asn)
{ *(net_addr_roa6 *)a = NET_ADDR_ROA6(prefix, pxlen, max_pxlen, asn); }
static inline void net_fill_ip6_sadr(net_addr *a, ip6_addr dst_prefix, uint dst_pxlen, ip6_addr src_prefix, uint src_pxlen)
{ *(net_addr_ip6_sadr *)a = NET_ADDR_IP6_SADR(dst_prefix, dst_pxlen, src_prefix, src_pxlen); }
static inline void net_fill_mpls(net_addr *a, u32 label)
{ *(net_addr_mpls *)a = NET_ADDR_MPLS(label); }
static inline void net_fill_aspa(net_addr *a, u32 asn)
{ *(net_addr_aspa *)a = NET_ADDR_ASPA(asn); }
static inline void net_fill_ipa(net_addr *a, ip_addr prefix, uint pxlen)
{
if (ipa_is_ip4(prefix))
net_fill_ip4(a, ipa_to_ip4(prefix), pxlen);
else
net_fill_ip6(a, ipa_to_ip6(prefix), pxlen);
}
static inline void net_fill_ip_host(net_addr *a, ip_addr prefix)
{
if (ipa_is_ip4(prefix))
net_fill_ip4(a, ipa_to_ip4(prefix), IP4_MAX_PREFIX_LENGTH);
else
net_fill_ip6(a, ipa_to_ip6(prefix), IP6_MAX_PREFIX_LENGTH);
}
static inline void net_fill_flow4(net_addr *a, ip4_addr prefix, uint pxlen, byte *data, uint dlen)
{
net_addr_flow4 *f = (void *) a;
*f = NET_ADDR_FLOW4(prefix, pxlen, dlen);
memcpy(f->data, data, dlen);
}
static inline void net_fill_flow6(net_addr *a, ip6_addr prefix, uint pxlen, byte *data, uint dlen)
{
net_addr_flow6 *f = (void *) a;
*f = NET_ADDR_FLOW6(prefix, pxlen, dlen);
memcpy(f->data, data, dlen);
}
/* Make NET_IP6_SADR from NET_IP6, assuming there is enough space */
static inline void net_make_ip6_sadr(net_addr *a)
{
net_addr_ip6_sadr *n = (void *) a;
n->type = NET_IP6_SADR;
n->length = sizeof(net_addr_ip6_sadr);
n->src_pxlen = 0;
n->src_prefix = IP6_NONE;
}
static inline int net_val_match(u8 type, u32 mask)
{ return !!((1 << type) & mask); }
static inline int net_type_match(const net_addr *a, u32 mask)
{ return net_val_match(a->type, mask); }
static inline int net_is_ip(const net_addr *a)
{ return (a->type == NET_IP4) || (a->type == NET_IP6); }
static inline int net_is_vpn(const net_addr *a)
{ return (a->type == NET_VPN4) || (a->type == NET_VPN6); }
static inline int net_is_roa(const net_addr *a)
{ return (a->type == NET_ROA4) || (a->type == NET_ROA6); }
static inline int net_is_flow(const net_addr *a)
{ return (a->type == NET_FLOW4) || (a->type == NET_FLOW6); }
static inline int net_is_aspa(const net_addr *a)
{ return (a->type == NET_ASPA); }
static inline int net_is_sadr(const net_addr *a)
{ return (a->type == NET_IP6_SADR); }
static inline ip4_addr net4_prefix(const net_addr *a)
{ return ((net_addr_ip4 *) a)->prefix; }
static inline ip6_addr net6_prefix(const net_addr *a)
{ return ((net_addr_ip6 *) a)->prefix; }
static inline ip_addr net_prefix(const net_addr *a)
{
switch (a->type)
{
case NET_IP4:
case NET_VPN4:
case NET_ROA4:
case NET_FLOW4:
return ipa_from_ip4(net4_prefix(a));
case NET_IP6:
case NET_VPN6:
case NET_ROA6:
case NET_FLOW6:
case NET_IP6_SADR:
return ipa_from_ip6(net6_prefix(a));
case NET_MPLS:
case NET_ASPA:
default:
return IPA_NONE;
}
}
static inline u32 net_mpls(const net_addr *a)
{
if (a->type == NET_MPLS)
return ((net_addr_mpls *) a)->label;
bug("Can't call net_mpls on non-mpls net_addr");
}
static inline uint net4_pxlen(const net_addr *a)
{ return a->pxlen; }
static inline uint net6_pxlen(const net_addr *a)
{ return a->pxlen; }
static inline uint net_pxlen(const net_addr *a)
{ return a->pxlen; }
ip_addr net_pxmask(const net_addr *a);
static inline vpn_rd net_rd(const net_addr *a)
{
switch (a->type)
{
case NET_VPN4:
return ((net_addr_vpn4 *)a)->rd;
case NET_VPN6:
return ((net_addr_vpn6 *)a)->rd;
}
return RD_NONE;
}
static inline int net_equal(const net_addr *a, const net_addr *b)
{ return (a->length == b->length) && !memcmp(a, b, a->length); }
static inline int net_equal_ip4(const net_addr_ip4 *a, const net_addr_ip4 *b)
{ return !memcmp(a, b, sizeof(net_addr_ip4)); }
static inline int net_equal_ip6(const net_addr_ip6 *a, const net_addr_ip6 *b)
{ return !memcmp(a, b, sizeof(net_addr_ip6)); }
static inline int net_equal_vpn4(const net_addr_vpn4 *a, const net_addr_vpn4 *b)
{ return !memcmp(a, b, sizeof(net_addr_vpn4)); }
static inline int net_equal_vpn6(const net_addr_vpn6 *a, const net_addr_vpn6 *b)
{ return !memcmp(a, b, sizeof(net_addr_vpn6)); }
static inline int net_equal_roa4(const net_addr_roa4 *a, const net_addr_roa4 *b)
{ return !memcmp(a, b, sizeof(net_addr_roa4)); }
static inline int net_equal_roa6(const net_addr_roa6 *a, const net_addr_roa6 *b)
{ return !memcmp(a, b, sizeof(net_addr_roa6)); }
static inline int net_equal_flow4(const net_addr_flow4 *a, const net_addr_flow4 *b)
{ return net_equal((const net_addr *) a, (const net_addr *) b); }
static inline int net_equal_flow6(const net_addr_flow6 *a, const net_addr_flow6 *b)
{ return net_equal((const net_addr *) a, (const net_addr *) b); }
static inline int net_equal_ip6_sadr(const net_addr_ip6_sadr *a, const net_addr_ip6_sadr *b)
{ return !memcmp(a, b, sizeof(net_addr_ip6_sadr)); }
static inline int net_equal_mpls(const net_addr_mpls *a, const net_addr_mpls *b)
{ return !memcmp(a, b, sizeof(net_addr_mpls)); }
static inline int net_equal_aspa(const net_addr_aspa *a, const net_addr_aspa *b)
{ return !memcmp(a, b, sizeof(net_addr_aspa)); }
static inline int net_equal_prefix_roa4(const net_addr_roa4 *a, const net_addr_roa4 *b)
{ return ip4_equal(a->prefix, b->prefix) && (a->pxlen == b->pxlen); }
static inline int net_equal_prefix_roa6(const net_addr_roa6 *a, const net_addr_roa6 *b)
{ return ip6_equal(a->prefix, b->prefix) && (a->pxlen == b->pxlen); }
static inline int net_equal_dst_ip6_sadr(const net_addr_ip6_sadr *a, const net_addr_ip6_sadr *b)
{ return ip6_equal(a->dst_prefix, b->dst_prefix) && (a->dst_pxlen == b->dst_pxlen); }
static inline int net_equal_src_ip6_sadr(const net_addr_ip6_sadr *a, const net_addr_ip6_sadr *b)
{ return ip6_equal(a->src_prefix, b->src_prefix) && (a->src_pxlen == b->src_pxlen); }
static inline int net_zero_ip4(const net_addr_ip4 *a)
{ return !a->pxlen && ip4_zero(a->prefix); }
static inline int net_zero_ip6(const net_addr_ip6 *a)
{ return !a->pxlen && ip6_zero(a->prefix); }
static inline int net_zero_vpn4(const net_addr_vpn4 *a)
{ return !a->pxlen && ip4_zero(a->prefix) && rd_zero(a->rd); }
static inline int net_zero_vpn6(const net_addr_vpn6 *a)
{ return !a->pxlen && ip6_zero(a->prefix) && rd_zero(a->rd); }
static inline int net_zero_roa4(const net_addr_roa4 *a)
{ return !a->pxlen && ip4_zero(a->prefix) && !a->max_pxlen && !a->asn; }
static inline int net_zero_roa6(const net_addr_roa6 *a)
{ return !a->pxlen && ip6_zero(a->prefix) && !a->max_pxlen && !a->asn; }
static inline int net_zero_flow4(const net_addr_flow4 *a)
{ return !a->pxlen && ip4_zero(a->prefix) && (a->length == sizeof(net_addr_flow4)); }
static inline int net_zero_flow6(const net_addr_flow6 *a)
{ return !a->pxlen && ip6_zero(a->prefix) && (a->length == sizeof(net_addr_flow6)); }
static inline int net_zero_mpls(const net_addr_mpls *a)
{ return !a->label; }
static inline int net_zero_aspa(const net_addr_aspa *a)
{ return !a->asn; }
static inline int net_compare_ip4(const net_addr_ip4 *a, const net_addr_ip4 *b)
{ return ip4_compare(a->prefix, b->prefix) ?: uint_cmp(a->pxlen, b->pxlen); }
static inline int net_compare_ip6(const net_addr_ip6 *a, const net_addr_ip6 *b)
{ return ip6_compare(a->prefix, b->prefix) ?: uint_cmp(a->pxlen, b->pxlen); }
static inline int net_compare_vpn4(const net_addr_vpn4 *a, const net_addr_vpn4 *b)
{ return rd_compare(a->rd, b->rd) ?: ip4_compare(a->prefix, b->prefix) ?: uint_cmp(a->pxlen, b->pxlen); }
static inline int net_compare_vpn6(const net_addr_vpn6 *a, const net_addr_vpn6 *b)
{ return rd_compare(a->rd, b->rd) ?: ip6_compare(a->prefix, b->prefix) ?: uint_cmp(a->pxlen, b->pxlen); }
static inline int net_compare_roa4(const net_addr_roa4 *a, const net_addr_roa4 *b)
{ return ip4_compare(a->prefix, b->prefix) ?: uint_cmp(a->pxlen, b->pxlen) ?: uint_cmp(a->max_pxlen, b->max_pxlen) ?: uint_cmp(a->asn, b->asn); }
static inline int net_compare_roa6(const net_addr_roa6 *a, const net_addr_roa6 *b)
{ return ip6_compare(a->prefix, b->prefix) ?: uint_cmp(a->pxlen, b->pxlen) ?: uint_cmp(a->max_pxlen, b->max_pxlen) ?: uint_cmp(a->asn, b->asn); }
static inline int net_compare_flow4(const net_addr_flow4 *a, const net_addr_flow4 *b)
{ return ip4_compare(a->prefix, b->prefix) ?: uint_cmp(a->pxlen, b->pxlen) ?: uint_cmp(a->length, b->length) ?: memcmp(a->data, b->data, a->length - sizeof(net_addr_flow4)); }
static inline int net_compare_flow6(const net_addr_flow6 *a, const net_addr_flow6 *b)
{ return ip6_compare(a->prefix, b->prefix) ?: uint_cmp(a->pxlen, b->pxlen) ?: uint_cmp(a->length, b->length) ?: memcmp(a->data, b->data, a->length - sizeof(net_addr_flow6)); }
static inline int net_compare_ip6_sadr(const net_addr_ip6_sadr *a, const net_addr_ip6_sadr *b)
{
return
ip6_compare(a->dst_prefix, b->dst_prefix) ?: uint_cmp(a->dst_pxlen, b->dst_pxlen) ?:
ip6_compare(a->src_prefix, b->src_prefix) ?: uint_cmp(a->src_pxlen, b->src_pxlen);
}
static inline int net_compare_mpls(const net_addr_mpls *a, const net_addr_mpls *b)
{ return uint_cmp(a->label, b->label); }
static inline int net_compare_aspa(const net_addr_aspa *a, const net_addr_aspa *b)
{ return uint_cmp(a->asn, b->asn); }
int net_compare(const net_addr *a, const net_addr *b);
static inline void net_copy(net_addr *dst, const net_addr *src)
{ memcpy(dst, src, src->length); }
static inline void net_copy_ip4(net_addr_ip4 *dst, const net_addr_ip4 *src)
{ memcpy(dst, src, sizeof(net_addr_ip4)); }
static inline void net_copy_ip6(net_addr_ip6 *dst, const net_addr_ip6 *src)
{ memcpy(dst, src, sizeof(net_addr_ip6)); }
static inline void net_copy_vpn4(net_addr_vpn4 *dst, const net_addr_vpn4 *src)
{ memcpy(dst, src, sizeof(net_addr_vpn4)); }
static inline void net_copy_vpn6(net_addr_vpn6 *dst, const net_addr_vpn6 *src)
{ memcpy(dst, src, sizeof(net_addr_vpn6)); }
static inline void net_copy_roa4(net_addr_roa4 *dst, const net_addr_roa4 *src)
{ memcpy(dst, src, sizeof(net_addr_roa4)); }
static inline void net_copy_roa6(net_addr_roa6 *dst, const net_addr_roa6 *src)
{ memcpy(dst, src, sizeof(net_addr_roa6)); }
static inline void net_copy_flow4(net_addr_flow4 *dst, const net_addr_flow4 *src)
{ memcpy(dst, src, src->length); }
static inline void net_copy_flow6(net_addr_flow6 *dst, const net_addr_flow6 *src)
{ memcpy(dst, src, src->length); }
static inline void net_copy_ip6_sadr(net_addr_ip6_sadr *dst, const net_addr_ip6_sadr *src)
{ memcpy(dst, src, sizeof(net_addr_ip6_sadr)); }
static inline void net_copy_mpls(net_addr_mpls *dst, const net_addr_mpls *src)
{ memcpy(dst, src, sizeof(net_addr_mpls)); }
static inline void net_copy_aspa(net_addr_aspa *dst, const net_addr_aspa *src)
{ memcpy(dst, src, sizeof(net_addr_aspa)); }
static inline u32 px4_hash(ip4_addr prefix, u32 pxlen)
{ return ip4_hash(prefix) ^ (pxlen << 26); }
static inline u32 px6_hash(ip6_addr prefix, u32 pxlen)
{ return ip6_hash(prefix) ^ (pxlen << 26); }
static inline u32 net_hash_ip4(const net_addr_ip4 *n)
{ return px4_hash(n->prefix, n->pxlen); }
static inline u32 net_hash_ip6(const net_addr_ip6 *n)
{ return px6_hash(n->prefix, n->pxlen); }
static inline u32 net_hash_vpn4(const net_addr_vpn4 *n)
{
u64 acc = ip4_hash0(n->prefix, HASH_PARAM, 0) ^ (n->pxlen << 26);
return hash_value(rd_hash0(n->rd, HASH_PARAM, acc));
}
static inline u32 net_hash_vpn6(const net_addr_vpn6 *n)
{
u64 acc = ip6_hash0(n->prefix, HASH_PARAM, 0) ^ (n->pxlen << 26);
return hash_value(rd_hash0(n->rd, HASH_PARAM, acc));
}
static inline u32 net_hash_roa4(const net_addr_roa4 *n)
{ return px4_hash(n->prefix, n->pxlen); }
static inline u32 net_hash_roa6(const net_addr_roa6 *n)
{ return px6_hash(n->prefix, n->pxlen); }
static inline u32 net_hash_flow4(const net_addr_flow4 *n)
{ return px4_hash(n->prefix, n->pxlen); }
static inline u32 net_hash_flow6(const net_addr_flow6 *n)
{ return px6_hash(n->prefix, n->pxlen); }
static inline u32 net_hash_ip6_sadr(const net_addr_ip6_sadr *n)
{ return px6_hash(n->dst_prefix, n->dst_pxlen); }
static inline u32 net_hash_mpls(const net_addr_mpls *n)
{ return u32_hash(n->label); }
static inline u32 net_hash_aspa(const net_addr_aspa *n)
{ return u32_hash(n->asn); }
u32 net_hash(const net_addr *a);
static inline int net_validate_px4(const ip4_addr prefix, uint pxlen)
{
return (pxlen <= IP4_MAX_PREFIX_LENGTH) &&
ip4_zero(ip4_and(prefix, ip4_not(ip4_mkmask(pxlen))));
}
static inline int net_validate_px6(const ip6_addr prefix, uint pxlen)
{
return (pxlen <= IP6_MAX_PREFIX_LENGTH) &&
ip6_zero(ip6_and(prefix, ip6_not(ip6_mkmask(pxlen))));
}
static inline int net_validate_ip4(const net_addr_ip4 *n)
{ return net_validate_px4(n->prefix, n->pxlen); }
static inline int net_validate_ip6(const net_addr_ip6 *n)
{ return net_validate_px6(n->prefix, n->pxlen); }
static inline int net_validate_vpn4(const net_addr_vpn4 *n)
{ return net_validate_px4(n->prefix, n->pxlen); }
static inline int net_validate_vpn6(const net_addr_vpn6 *n)
{ return net_validate_px6(n->prefix, n->pxlen); }
static inline int net_validate_roa4(const net_addr_roa4 *n)
{
return net_validate_px4(n->prefix, n->pxlen) &&
(n->pxlen <= n->max_pxlen) && (n->max_pxlen <= IP4_MAX_PREFIX_LENGTH);
}
static inline int net_validate_roa6(const net_addr_roa6 *n)
{
return net_validate_px6(n->prefix, n->pxlen) &&
(n->pxlen <= n->max_pxlen) && (n->max_pxlen <= IP6_MAX_PREFIX_LENGTH);
}
// FIXME: Better check, call flow_validate?
static inline int net_validate_flow4(const net_addr_flow4 *n)
{ return net_validate_px4(n->prefix, n->pxlen); }
static inline int net_validate_flow6(const net_addr_flow6 *n)
{ return net_validate_px6(n->prefix, n->pxlen); }
static inline int net_validate_mpls(const net_addr_mpls *n)
{ return n->label < (1 << 20); }
static inline int net_validate_aspa(const net_addr_aspa *n)
{ return n->asn > 0; }
static inline int net_validate_ip6_sadr(const net_addr_ip6_sadr *n)
{ return net_validate_px6(n->dst_prefix, n->dst_pxlen) && net_validate_px6(n->src_prefix, n->src_pxlen); }
int net_validate(const net_addr *N);
static inline void net_normalize_ip4(net_addr_ip4 *n)
{ n->prefix = ip4_and(n->prefix, ip4_mkmask(n->pxlen)); }
static inline void net_normalize_ip6(net_addr_ip6 *n)
{ n->prefix = ip6_and(n->prefix, ip6_mkmask(n->pxlen)); }
static inline void net_normalize_vpn4(net_addr_vpn4 *n)
{ net_normalize_ip4((net_addr_ip4 *) n); }
static inline void net_normalize_vpn6(net_addr_vpn6 *n)
{ net_normalize_ip6((net_addr_ip6 *) n); }
static inline void net_normalize_ip6_sadr(net_addr_ip6_sadr *n)
{
n->dst_prefix = ip6_and(n->dst_prefix, ip6_mkmask(n->dst_pxlen));
n->src_prefix = ip6_and(n->src_prefix, ip6_mkmask(n->src_pxlen));
}
void net_normalize(net_addr *N);
int net_classify(const net_addr *N);
int net_format(const net_addr *N, char *buf, int buflen) ACCESS_WRITE(2, 3);
int rd_format(const vpn_rd rd, char *buf, int buflen) ACCESS_WRITE(2, 3);
static inline int ipa_in_px4(ip4_addr a, ip4_addr prefix, uint pxlen)
{ return ip4_zero(ip4_and(ip4_xor(a, prefix), ip4_mkmask(pxlen))); }
static inline int ipa_in_px6(ip6_addr a, ip6_addr prefix, uint pxlen)
{ return ip6_zero(ip6_and(ip6_xor(a, prefix), ip6_mkmask(pxlen))); }
static inline int ipa_in_net_ip4(ip4_addr a, const net_addr_ip4 *n)
{ return ipa_in_px4(a, n->prefix, n->pxlen); }
static inline int ipa_in_net_ip6(ip6_addr a, const net_addr_ip6 *n)
{ return ipa_in_px6(a, n->prefix, n->pxlen); }
static inline int net_in_net_ip4(const net_addr_ip4 *a, const net_addr_ip4 *b)
{ return (a->pxlen >= b->pxlen) && ipa_in_px4(a->prefix, b->prefix, b->pxlen); }
static inline int net_in_net_ip6(const net_addr_ip6 *a, const net_addr_ip6 *b)
{ return (a->pxlen >= b->pxlen) && ipa_in_px6(a->prefix, b->prefix, b->pxlen); }
static inline int net_in_net_dst_ip6_sadr(const net_addr_ip6_sadr *a, const net_addr_ip6_sadr *b)
{ return (a->dst_pxlen >= b->dst_pxlen) && ipa_in_px6(a->dst_prefix, b->dst_prefix, b->dst_pxlen); }
static inline int net_in_net_src_ip6_sadr(const net_addr_ip6_sadr *a, const net_addr_ip6_sadr *b)
{ return (a->src_pxlen >= b->src_pxlen) && ipa_in_px6(a->src_prefix, b->src_prefix, b->src_pxlen); }
int ipa_in_netX(const ip_addr A, const net_addr *N);
int net_in_netX(const net_addr *A, const net_addr *N);
#endif
bird2-2.17.5/lib/patmatch.c 0000664 0000000 0000000 00000002702 15211753245 0015331 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Generic Shell-Like Pattern Matching (currently only '?' and '*')
*
* (c) 1998--2000 Martin Mares
*/
#include "nest/bird.h"
#include "lib/string.h"
#ifndef MATCH_FUNC_NAME
#define MATCH_FUNC_NAME patmatch
#endif
#ifndef Convert
#define Convert(x) x
#endif
int
MATCH_FUNC_NAME(const byte *p, const byte *s)
{
while (*p)
{
if (*p == '?' && *s)
p++, s++;
else if (*p == '*')
{
int z = p[1];
if (!z)
return 1;
if (z == '\\' && p[2])
z = p[2];
z = Convert(z);
for(;;)
{
while (*s && Convert(*s) != z)
s++;
if (!*s)
return 0;
if (MATCH_FUNC_NAME(p+1, s))
return 1;
s++;
}
}
else
{
if (*p == '\\' && p[1])
p++;
if (Convert(*p++) != Convert(*s++))
return 0;
}
}
return !*s;
}
#if 0
/**
* patmatch - match shell-like patterns
* @p: pattern
* @s: string
*
* patmatch() returns whether given string @s matches the given shell-like
* pattern @p. The patterns consist of characters (which are matched literally),
* question marks which match any single character, asterisks which match any
* (possibly empty) string of characters and backslashes which are used to
* escape any special characters and force them to be treated literally.
*
* The matching process is not optimized with respect to time, so please
* avoid using this function for complex patterns.
*/
int
patmatch(byte *p, byte *s)
{ DUMMY; }
#endif
bird2-2.17.5/lib/patmatch_test.c 0000664 0000000 0000000 00000005663 15211753245 0016401 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Pattern Matching Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "nest/bird.h"
#include "lib/string.h"
#define MATCH (int) { 1 }
#define NOMATCH (int) { 0 }
struct match_pair {
byte *pattern;
byte *data;
};
static int
test_matching(void *out_, const void *in_, const void *expected_out_)
{
int *out = out_;
const struct match_pair *in = in_;
const int *expected_out = expected_out_;
*out = patmatch(in->pattern, in->data);
return *out == *expected_out;
}
static void
fmt_match_pair(char *buf, size_t size, const void *data)
{
const struct match_pair *mp = data;
snprintf(buf, size, "pattern: '%s', subject: '%s'", mp->pattern, mp->data);
}
static void
fmt_match_result(char *buf, size_t size, const void *data)
{
const int *result = data;
snprintf(buf, size, *result ? "match" : "no-match");
}
static int
t_matching(void)
{
struct bt_pair test_vectors[] = {
{
.in = & (struct match_pair) {
.pattern = "",
.data = "",
},
.out = & MATCH,
},
{
.in = & (struct match_pair) {
.pattern = "*",
.data = "",
},
.out = & MATCH,
},
{
.in = & (struct match_pair) {
.pattern = "\\*",
.data = "*",
},
.out = & MATCH,
},
{
.in = & (struct match_pair) {
.pattern = "\\*",
.data = "a",
},
.out = & NOMATCH,
},
{
.in = & (struct match_pair) {
.pattern = "?",
.data = "",
},
.out = & NOMATCH,
},
{
.in = & (struct match_pair) {
.pattern = "abcdefghijklmnopqrstuvwxyz",
.data = "abcdefghijklmnopqrstuvwxyz",
},
.out = & MATCH,
},
{
.in = & (struct match_pair) {
.pattern = "??????????????????????????",
.data = "abcdefghijklmnopqrstuvwxyz",
},
.out = & MATCH,
},
{
.in = & (struct match_pair) {
.pattern = "*abcdefghijklmnopqrstuvwxyz*",
.data = "abcdefghijklmnopqrstuvwxyz",
},
.out = & MATCH,
},
{
.in = & (struct match_pair) {
.pattern = "ab?defg*jklmnop*stu*wxy*z",
.data = "abcdefghijklmnopqrstuvwxyz",
},
.out = & MATCH,
},
{
.in = & (struct match_pair) {
.pattern = "abcdefghijklmnopqrstuvwxyz",
.data = "abcdefghijklmnopqrtuvwxyz",
},
.out = & NOMATCH,
},
{
.in = & (struct match_pair) {
.pattern = "abcdefghijklmnopqr?uvwxyz",
.data = "abcdefghijklmnopqrstuvwxyz",
},
.out = & NOMATCH,
},
{
.in = & (struct match_pair) {
.pattern = "aa*aaaaa?aaaaaaaaaaaaaaaaaaa",
.data = "aaaaaaaaaaaaaaaaaaaaaaaaaa",
},
.out = & NOMATCH,
},
};
return bt_assert_batch(test_vectors, test_matching, fmt_match_pair, fmt_match_result);
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_matching, "Pattern matching");
return bt_exit_value();
}
bird2-2.17.5/lib/printf.c 0000664 0000000 0000000 00000041030 15211753245 0015027 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Formatted Output
*
* (c) 1991, 1992 Lars Wirzenius & Linus Torvalds
*
* Hacked up for BIRD by Martin Mares
* Buffer size limitation implemented by Martin Mares.
*/
#include "nest/bird.h"
#include "lib/macro.h"
#include "lib/string.h"
#include
#include "nest/iface.h"
/* we use this so that we can do without the ctype library */
#define is_digit(c) ((c) >= '0' && (c) <= '9')
static int skip_atoi(const char **s)
{
int i=0;
while (is_digit(**s))
i = i*10 + *((*s)++) - '0';
return i;
}
#define ZEROPAD 1 /* pad with zero */
#define SIGN 2 /* unsigned/signed long */
#define PLUS 4 /* show plus */
#define SPACE 8 /* space if plus */
#define LEFT 16 /* left justified */
#define SPECIAL 32 /* 0x */
#define LARGE 64 /* use 'ABCDEF' instead of 'abcdef' */
static char * number(char * str, u64 num, uint base, int size, int precision,
int type, int remains)
{
char c,sign,tmp[66];
const char *digits="0123456789abcdefghijklmnopqrstuvwxyz";
int i;
if (size >= 0 && (remains -= size) < 0)
return NULL;
if (type & LARGE)
digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
if (type & LEFT)
type &= ~ZEROPAD;
if (base < 2 || base > 36)
return 0;
c = (type & ZEROPAD) ? '0' : ' ';
sign = 0;
if (type & SIGN) {
if (num > (u64) INT64_MAX) {
sign = '-';
num = -num;
size--;
} else if (type & PLUS) {
sign = '+';
size--;
} else if (type & SPACE) {
sign = ' ';
size--;
}
}
if (type & SPECIAL) {
if (base == 16)
size -= 2;
else if (base == 8)
size--;
}
i = 0;
if (num == 0)
tmp[i++]='0';
else if (base == 10) {
/* Separate cases to have fixed divisors */
while (num != 0) {
uint res = num % 10;
num = num / 10;
tmp[i++] = digits[res];
}
} else if (base == 16) {
while (num != 0) {
uint res = num % 16;
num = num / 16;
tmp[i++] = digits[res];
}
} else {
while (num != 0) {
uint res = num % base;
num = num / base;
tmp[i++] = digits[res];
}
}
if (i > precision)
precision = i;
size -= precision;
if (size < 0 && -size > remains)
return NULL;
if (!(type&(ZEROPAD+LEFT)))
while(size-->0)
*str++ = ' ';
if (sign)
*str++ = sign;
if (type & SPECIAL) {
if (base==8)
*str++ = '0';
else if (base==16) {
*str++ = '0';
*str++ = digits[33];
}
}
if (!(type & LEFT))
while (size-- > 0)
*str++ = c;
while (i < precision--)
*str++ = '0';
while (i-- > 0)
*str++ = tmp[i];
while (size-- > 0)
*str++ = ' ';
return str;
}
/**
* bvsnprintf - BIRD's vsnprintf()
* @buf: destination buffer
* @size: size of the buffer
* @fmt: format string
* @args: a list of arguments to be formatted
*
* This functions acts like ordinary sprintf() except that it checks available
* space to avoid buffer overflows and it allows some more format specifiers:
* |%I| for formatting of IP addresses (width of 1 is automatically replaced by
* standard IP address width which depends on whether we use IPv4 or IPv6; |%I4|
* or |%I6| can be used for explicit ip4_addr / ip6_addr arguments, |%N| for
* generic network addresses (net_addr *), |%R| for Router / Network ID (u32
* value printed as IPv4 address), |%lR| for 64bit Router / Network ID (u64
* value printed as eight :-separated octets), |%t| for time values (btime) with
* specified subsecond precision, and |%m| resp. |%M| for error messages (uses
* strerror() to translate @errno code to message text). On the other hand, it
* doesn't support floating point numbers. The bvsnprintf() supports |%h| and
* |%l| qualifiers, but |%l| is used for s64/u64 instead of long/ulong.
*
* Result: number of characters of the output string or -1 if
* the buffer space was insufficient.
*/
int bvsnprintf(char *buf, int size, const char *fmt, va_list args)
{
int len, i;
u64 num;
uint base;
u32 x;
u64 X;
btime t;
s64 t1, t2;
char *str, *start;
const char *s;
char ipbuf[NET_MAX_TEXT_LENGTH+1];
struct iface *iface;
int flags; /* flags to number() */
int field_width; /* width of output field */
int precision; /* min. # of digits for integers; max
number of chars for from string */
int qualifier; /* 'h' or 'l' for integer fields */
for (start=str=buf ; *fmt ; ++fmt, size-=(str-start), start=str) {
if (!size)
return -1;
if (*fmt != '%') {
*str++ = *fmt;
continue;
}
/* process flags */
flags = 0;
repeat:
++fmt; /* this also skips first '%' */
switch (*fmt) {
case '-': flags |= LEFT; goto repeat;
case '+': flags |= PLUS; goto repeat;
case ' ': flags |= SPACE; goto repeat;
case '#': flags |= SPECIAL; goto repeat;
case '0': flags |= ZEROPAD; goto repeat;
}
/* get field width */
field_width = -1;
if (is_digit(*fmt))
field_width = skip_atoi(&fmt);
else if (*fmt == '*') {
++fmt;
/* it's the next argument */
field_width = va_arg(args, int);
if (field_width < 0) {
field_width = -field_width;
flags |= LEFT;
}
}
/* get the precision */
precision = -1;
if (*fmt == '.') {
++fmt;
if (is_digit(*fmt))
precision = skip_atoi(&fmt);
else if (*fmt == '*') {
++fmt;
/* it's the next argument */
precision = va_arg(args, int);
}
if (precision < 0)
precision = 0;
}
/* get the conversion qualifier */
qualifier = -1;
if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L') {
qualifier = *fmt;
++fmt;
}
/* default base */
base = 10;
if (field_width > size)
return -1;
switch (*fmt) {
case 'c':
if (!(flags & LEFT))
while (--field_width > 0)
*str++ = ' ';
*str++ = (byte) va_arg(args, int);
while (--field_width > 0)
*str++ = ' ';
continue;
case 'm':
if (flags & SPECIAL) {
if (!errno)
continue;
if (size < 2)
return -1;
*str++ = ':';
*str++ = ' ';
start += 2;
size -= 2;
}
s = strerror(errno);
goto str;
case 'M':
s = strerror(va_arg(args, int));
goto str;
case 'N': {
net_addr *n = va_arg(args, net_addr *);
if (field_width == 1)
field_width = net_max_text_length[n->type];
net_format(n, ipbuf, sizeof(ipbuf));
s = ipbuf;
goto str;
}
case 's':
s = va_arg(args, char *);
if (!s)
s = "";
str:
len = strlen(s);
if (precision >= 0 && len > precision)
len = precision;
if ((len > size) || (field_width > size))
return -1;
if (!(flags & LEFT))
while (len < field_width--)
*str++ = ' ';
for (i = 0; i < len; ++i)
*str++ = *s++;
while (len < field_width--)
*str++ = ' ';
continue;
case 'V': {
const char *vfmt = va_arg(args, const char *);
va_list *vargs = va_arg(args, va_list *);
int res = bvsnprintf(str, size, vfmt, *vargs);
if (res < 0)
return -1;
str += res;
size -= res;
continue;
}
case 'p':
if (field_width == -1) {
field_width = 2*sizeof(void *);
flags |= ZEROPAD;
}
str = number(str, (uintptr_t) va_arg(args, void *), 16,
field_width, precision, flags, size);
if (!str)
return -1;
continue;
case 'n':
if (qualifier == 'l') {
s64 * ip = va_arg(args, s64 *);
*ip = (str - buf);
} else {
int * ip = va_arg(args, int *);
*ip = (str - buf);
}
continue;
/* IP address */
case 'I':
if (fmt[1] == '4') {
/* Explicit IPv4 address */
ip4_addr a = va_arg(args, ip4_addr);
ip4_ntop(a, ipbuf);
i = IP4_MAX_TEXT_LENGTH;
fmt++;
} else if (fmt[1] == '6') {
/* Explicit IPv6 address */
ip6_addr a = va_arg(args, ip6_addr);
ip6_ntop(a, ipbuf);
i = IP6_MAX_TEXT_LENGTH;
fmt++;
} else {
/* Just IP address */
ip_addr a = va_arg(args, ip_addr);
if (ipa_is_ip4(a)) {
ip4_ntop(ipa_to_ip4(a), ipbuf);
i = IP4_MAX_TEXT_LENGTH;
} else {
ip6_ntop(ipa_to_ip6(a), ipbuf);
i = IP6_MAX_TEXT_LENGTH;
}
}
s = ipbuf;
if (field_width == 1)
field_width = i;
goto str;
/* Interface scope after link-local IP address */
case 'J':
iface = va_arg(args, struct iface *);
if (!iface)
continue;
if (!size)
return -1;
*str++ = '%';
start++;
size--;
s = iface->name;
goto str;
/* Router/Network ID - essentially IPv4 address in u32 value */
case 'R':
if (qualifier == 'l') {
X = va_arg(args, u64);
bsprintf(ipbuf, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
(uint) ((X >> 56) & 0xff),
(uint) ((X >> 48) & 0xff),
(uint) ((X >> 40) & 0xff),
(uint) ((X >> 32) & 0xff),
(uint) ((X >> 24) & 0xff),
(uint) ((X >> 16) & 0xff),
(uint) ((X >> 8) & 0xff),
(uint) (X & 0xff));
}
else
{
x = va_arg(args, u32);
ip4_ntop(ip4_from_u32(x), ipbuf);
}
s = ipbuf;
goto str;
case 't':
t = va_arg(args, btime);
t1 = t TO_S;
t2 = t - t1 S;
if (precision < 0)
precision = 3;
if (precision > 6)
precision = 6;
/* Compute field_width for second part */
if ((precision > 0) && (field_width > 0))
field_width -= (1 + precision);
if (field_width < 0)
field_width = 0;
/* Print seconds */
flags |= SIGN;
str = number(str, (u64) t1, 10, field_width, 0, flags, size);
if (!str)
return -1;
if (precision > 0)
{
size -= (str-start);
start = str;
if ((1 + precision) > size)
return -1;
/* Convert microseconds to requested precision */
for (i = precision; i < 6; i++)
t2 /= 10;
/* Print sub-seconds */
*str++ = '.';
str = number(str, (u64) t2, 10, precision, 0, ZEROPAD, size - 1);
if (!str)
return -1;
}
goto done;
/* integer number formats - set up the flags and "break" */
case 'o':
base = 8;
break;
case 'X':
flags |= LARGE;
/* fallthrough */
case 'x':
base = 16;
break;
case 'd':
case 'i':
flags |= SIGN;
case 'u':
break;
default:
if (size < 2)
return -1;
if (*fmt != '%')
*str++ = '%';
if (*fmt)
*str++ = *fmt;
else
--fmt;
continue;
}
if (flags & SIGN) {
/* Conversions valid per ISO C99 6.3.1.3 (2) */
if (qualifier == 'l')
num = (u64) va_arg(args, s64);
else if (qualifier == 'h')
num = (u64) (short) va_arg(args, int);
else
num = (u64) va_arg(args, int);
} else {
if (qualifier == 'l')
num = va_arg(args, u64);
else if (qualifier == 'h')
num = (unsigned short) va_arg(args, int);
else
num = va_arg(args, uint);
}
str = number(str, num, base, field_width, precision, flags, size);
if (!str)
return -1;
done: ;
}
if (!size)
return -1;
*str = '\0';
return str-buf;
}
/**
* bvsprintf - BIRD's vsprintf()
* @buf: buffer
* @fmt: format string
* @args: a list of arguments to be formatted
*
* This function is equivalent to bvsnprintf() with an infinite
* buffer size. Please use carefully only when you are absolutely
* sure the buffer won't overflow.
*/
int bvsprintf(char *buf, const char *fmt, va_list args)
{
return bvsnprintf(buf, 1000000000, fmt, args);
}
/**
* bsprintf - BIRD's sprintf()
* @buf: buffer
* @fmt: format string
*
* This function is equivalent to bvsnprintf() with an infinite
* buffer size and variable arguments instead of a &va_list.
* Please use carefully only when you are absolutely
* sure the buffer won't overflow.
*/
int bsprintf(char * buf, const char *fmt, ...)
{
va_list args;
int i;
va_start(args, fmt);
i=bvsnprintf(buf, 1000000000, fmt, args);
va_end(args);
return i;
}
/**
* bsnprintf - BIRD's snprintf()
* @buf: buffer
* @size: buffer size
* @fmt: format string
*
* This function is equivalent to bsnprintf() with variable arguments instead of a &va_list.
*/
int bsnprintf(char * buf, int size, const char *fmt, ...)
{
va_list args;
int i;
va_start(args, fmt);
i=bvsnprintf(buf, size, fmt, args);
va_end(args);
return i;
}
int
buffer_vprint(buffer *buf, const char *fmt, va_list args)
{
int i = bvsnprintf((char *) buf->pos, buf->end - buf->pos, fmt, args);
if ((i < 0) && (buf->pos < buf->end))
*buf->pos = 0;
buf->pos = (i >= 0) ? (buf->pos + i) : buf->end;
return i;
}
int
buffer_print(buffer *buf, const char *fmt, ...)
{
va_list args;
int i;
va_start(args, fmt);
i = bvsnprintf((char *) buf->pos, buf->end - buf->pos, fmt, args);
va_end(args);
if ((i < 0) && (buf->pos < buf->end))
*buf->pos = 0;
buf->pos = (i >= 0) ? (buf->pos + i) : buf->end;
return i;
}
void
buffer_puts(buffer *buf, const char *str)
{
byte *bp = buf->pos;
byte *be = buf->end - 1;
while (bp < be && *str)
*bp++ = *str++;
if (bp <= be)
*bp = 0;
buf->pos = (bp < be) ? bp : buf->end;
}
#define POOL_PRINTF_MAXBUF 1024
char *mb_vsprintf(pool *p, const char *fmt, va_list args)
{
char buf[POOL_PRINTF_MAXBUF];
int count = bvsnprintf(buf, POOL_PRINTF_MAXBUF, fmt, args);
if (count < 0)
bug("Attempted to mb_vsprintf() a too long string");
char *out = mb_alloc(p, count + 1);
memcpy(out, buf, count + 1);
return out;
}
char *mb_sprintf(pool *p, const char *fmt, ...)
{
va_list args;
char *out;
va_start(args, fmt);
out = mb_vsprintf(p, fmt, args);
va_end(args);
return out;
}
char *lp_vsprintf(linpool *p, const char *fmt, va_list args)
{
char buf[POOL_PRINTF_MAXBUF];
int count = bvsnprintf(buf, POOL_PRINTF_MAXBUF, fmt, args);
if (count < 0)
bug("Attempted to mb_vsprintf() a too long string");
char *out = lp_alloc(p, count + 1);
memcpy(out, buf, count + 1);
return out;
}
char *lp_sprintf(linpool *p, const char *fmt, ...)
{
va_list args;
char *out;
va_start(args, fmt);
out = lp_vsprintf(p, fmt, args);
va_end(args);
return out;
}
static const u64 decadic_multiplier[] = {
1, 10, 100, 1000,
10000, 100000, 1000000, 10000000,
#if 0
100000000, 1000000000, 10000000000, 100000000000,
1000000000000, 10000000000000, 100000000000000, 1000000000000000,
10000000000000000, 100000000000000000, 1000000000000000000,
#endif
};
static const u64 decmul_limit[] = {
~0ULL / 1, ~0ULL / 10,
~0ULL / 100, ~0ULL / 1000,
~0ULL / 10000, ~0ULL / 100000,
~0ULL / 1000000, ~0ULL / 10000000,
#if 0
~0ULL / 100000000, ~0ULL / 1000000000,
~0ULL / 10000000000, ~0ULL / 100000000000,
~0ULL / 1000000000000, ~0ULL / 10000000000000,
~0ULL / 100000000000000, ~0ULL / 1000000000000000,
~0ULL / 10000000000000000, ~0ULL / 100000000000000000,
~0ULL / 1000000000000000000,
#endif
};
STATIC_ASSERT(sizeof decadic_multiplier == sizeof decmul_limit);
char *fmt_order(u64 value, uint decimals, u64 kb_threshold)
{
bool too_big = (value + 512 < 512ULL);
u64 mv = value;
uint magnitude = 0;
while (mv > kb_threshold)
{
magnitude++;
mv = (mv + (too_big ? 0 : 512)) / 1024;
}
uint shift = magnitude * 10;
/* The trivial case */
if (magnitude == 0)
return tmp_sprintf("%lu ", value);
/* Now we can find the suffix and the main divisor */
ASSERT_DIE(magnitude < 7);
char suffix = " kMGTPE"[magnitude];
/* The value before the dot is available just by dividing */
u64 before_dot = value >> shift;
/* Remainder is more tricky. First we need to know it. */
u64 remainder = value - (before_dot << shift);
/* We would like to compute (remainder * decmul) / divisor
* in integers but it's tricky because of u64 limits. */
ASSERT_DIE(decimals < ARRAY_SIZE(decadic_multiplier));
u64 decmul = decadic_multiplier[decimals];
u64 product;
if (remainder < decmul_limit[decimals])
{
/* The easier version: Everything fits into u64 */
product = remainder * decmul;
product >>= shift - 1;
product++;
product >>= 1;
}
else
{
/* Harder version: We have to multiply by parts.
* Fortunately, decmul always fits into 32 bits. */
/* After this, product = lower + (upper << 32). */
u64 lower = (remainder & ((1ULL << 32) - 1)) * decmul;
u64 upper = (remainder >> 32) * decmul;
if (shift < 33)
{
/* Divide lower */
lower >>= shift - 1;
/* Add the full upper part, not shifted enough to lose any bits */
lower += upper << (33 - shift);
}
else
{
/* First move the shifted-out bits from upper to lower */
lower += (upper & ((1ULL << (shift - 32)) - 1)) << 32;
/* Then we can divide */
lower >>= shift - 1;
/* And add the shifted upper part */
lower += upper >> (shift - 33);
}
/* Now we finish the division by rounding */
product = (lower + 1) >> 1;
}
if (product == decmul)
{
product = 0;
before_dot++;
}
ASSERT_DIE(product < decmul);
/* And now we finally have all the numbers to print! */
if (decimals)
return tmp_sprintf("%lu.%0*lu %c",
before_dot, decimals, product, suffix
);
else
return tmp_sprintf("%lu %c", before_dot, suffix);
}
bird2-2.17.5/lib/printf_test.c 0000664 0000000 0000000 00000013536 15211753245 0016100 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- String Functions Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "lib/string.h"
#define BSPRINTF(nw, res, buf, fmt, ...) \
do { \
int n = bsprintf(buf, fmt, ##__VA_ARGS__); \
bt_assert_msg(n == nw, "fmt=\"%s\" returns n=%d, want %d", fmt, n, nw); \
bt_assert_msg(buf[n] == 0, "fmt=\"%s\" buf[%d] should be \'\\0\', found 0x%02x", fmt, n, buf[n]); \
bt_assert_msg(memcmp(buf, res, nw) == 0, "fmt=\"%s\" writes \"%*s\", want \"%*s\"", fmt, (n < nw ? n : nw), buf, nw, res); \
} while (0)
static int
t_simple(void)
{
char buf[256];
memset(buf, 0xa5, 256);
BSPRINTF(0, "", buf, "", NULL);
BSPRINTF(1, "%", buf, "%%", NULL);
BSPRINTF(2, "%%", buf, "%%%%", NULL);
BSPRINTF(1, "\x00", buf, "%c", 0);
BSPRINTF(1, "@", buf, "@", 64);
BSPRINTF(1, "\xff", buf, "%c", 0xff);
const char *io_error_str = lp_strdup(tmp_linpool, strerror(EIO));
const int io_error_len = strlen(io_error_str);
errno = EIO;
BSPRINTF(io_error_len, io_error_str, buf, "%m");
errno = 0;
BSPRINTF(io_error_len, io_error_str, buf, "%M", EIO);
BSPRINTF(11, "TeSt%StRiNg", buf, "%s", "TeSt%StRiNg");
if (sizeof(void *) == 4)
BSPRINTF(8, "1a15600d", buf, "%p", (void *) 0x1a15600d);
else
BSPRINTF(16, "00000fee1a15600d", buf, "%p", (void *) 0xfee1a15600d);
s64 ln = 0;
BSPRINTF(10, "TeStStRiNg", buf, "TeStS%lntRiNg", &ln);
bt_assert_msg(ln == 5, "fmt=\"TeStS%%lntRiNg\", &ln makes ln=%ld, want 5", ln);
BSPRINTF(2, "%d", buf, "%%d", 1);
BSPRINTF(1, "1", buf, "%d", 1);
BSPRINTF(2, "+1", buf, "%+d", 1);
BSPRINTF(2, " 1", buf, "% d", 1);
BSPRINTF(2, "-1", buf, "%d", -1);
BSPRINTF(11, "-2147483648", buf, "%d", INT32_MIN);
BSPRINTF(10, "2147483647", buf, "%d", INT32_MAX);
BSPRINTF(1, "0", buf, "%u", 0x0);
BSPRINTF(10, "4294967295", buf, "%u", 0xFFFFFFFF);
BSPRINTF(4, "-100", buf, "%ld", (s64) -100);
BSPRINTF(3, "100", buf, "%ld", (s64) 100);
BSPRINTF(20, "-9223372036854775808", buf, "%ld", INT64_MIN);
BSPRINTF(19, "9223372036854775807", buf, "%ld", INT64_MAX);
BSPRINTF(3, "0 8", buf, "%lu %lu", U64(0), U64(8));
BSPRINTF(20, "18446744073709551615", buf, "%lu", UINT64_MAX);
return 1;
}
static int
t_router_id(void)
{
char buf[256];
BSPRINTF(7, "1.2.3.4", buf, "%R", (u32) 0x01020304);
BSPRINTF(15, "240.224.208.192", buf, "%R", (u32) 0xF0E0D0C0);
BSPRINTF(23, "01:02:03:04:05:06:07:08", buf, "%lR", (u64) 0x0102030405060708);
BSPRINTF(23, "f0:e0:d0:c0:b0:a0:90:80", buf, "%lR", (u64) 0xF0E0D0C0B0A09080);
return 1;
}
static int
t_time(void)
{
char buf[256];
BSPRINTF(7, "123.456", buf, "%t", (btime) 123456789);
BSPRINTF(7, "123.456", buf, "%2t", (btime) 123456789);
BSPRINTF(8, " 123.456", buf, "%8t", (btime) 123456789);
BSPRINTF(4, " 123", buf, "%4.0t", (btime) 123456789);
BSPRINTF(8, "123.4567", buf, "%8.4t", (btime) 123456789);
BSPRINTF(9, "0123.4567", buf, "%09.4t", (btime) 123456789);
BSPRINTF(12, " 123.456789", buf, "%12.10t", (btime) 123456789);
BSPRINTF(8, " 123.004", buf, "%8t", (btime) 123004 MS);
return 1;
}
static int
t_bstrcmp(void)
{
bt_assert(bstrcmp("aa", "aa") == 0);
bt_assert(bstrcmp("aa", "bb") < 0);
bt_assert(bstrcmp("bb", "aa") > 0);
bt_assert(bstrcmp(NULL, NULL) == 0);
bt_assert(bstrcmp(NULL, "bb") == -1);
bt_assert(bstrcmp("bb", NULL) == 1);
return 1;
}
static int
t_fmt_order(void)
{
struct fmt_order_tv {
u64 value;
int decimals;
u64 threshold;
const char *expect;
} test_vectors [] = {
{ 9999, 1, 10000, "9999 " },
{ 10001, 1, 10000, "9.8 k" },
{ 10001, 2, 10000, "9.77 k" },
{ 10001, 3, 10000, "9.767 k" },
{ 1048575, 0, 10000, "1024 k" },
{ 1048575, 1, 10000, "1024.0 k" },
{ 1048575, 2, 10000, "1024.00 k" },
{ 1048575, 3, 10000, "1023.999 k" },
{ 1048575, 4, 10000, "1023.9990 k" },
{ 1048575, 5, 10000, "1023.99902 k" },
{ 1048575, 6, 10000, "1023.999023 k" },
{ 1048575, 0, 1000, "1 M" },
{ 1048575, 1, 1000, "1.0 M" },
{ 1048575, 2, 1000, "1.00 M" },
{ 1048575, 3, 1000, "1.000 M" },
{ 1048575, 4, 1000, "1.0000 M" },
{ 1048575, 5, 1000, "1.00000 M" },
{ 1048575, 6, 1000, "0.999999 M" },
{ 1048577, 6, 10000, "1024.000977 k" },
{ 1048577, 6, 1000, "1.000001 M" },
{ 1048577, 6, 100, "1.000001 M" },
{ 1048577, 6, 10, "1.000001 M" },
{ 1048577, 6, 1, "1.000001 M" },
{ 10000000000000, 6, 10000, "9313.225746 G" },
{ 10000000000000, 6, 1000, "9.094947 T" },
{ 123456789123456789, 0, 1000, "110 P" },
{ 123456789123456789, 4, 1000, "109.6517 P" },
{ 123456789123456789, 7, 1000, "109.6516559 P" },
{ 1234567890123456789, 0, 1000, "1 E" },
{ 1234567890123456789, 1, 1000, "1.1 E" },
{ 1234567890123456789, 2, 1000, "1.07 E" },
{ 1234567890123456789, 3, 1000, "1.071 E" },
{ 1234567890123456789, 4, 1000, "1.0708 E" },
{ 1234567890123456789, 5, 1000, "1.07082 E" },
{ 1234567890123456789, 6, 1000, "1.070817 E" },
{ 1234567890123456789, 7, 1000, "1.0708170 E" },
{ 9444732965739290427U, 3, 1000, "8.192 E" },
{ 9444732965739290427U, 6, 1000, "8.192000 E" },
{ 18446744073709551615U, 2, 1000, "16.00 E" },
};
for (int i = 0; i < (int)ARRAY_SIZE(test_vectors); i++)
{
const char *result = fmt_order(test_vectors[i].value, test_vectors[i].decimals, test_vectors[i].threshold);
const char *expect = test_vectors[i].expect;
bt_assert_msg(strncmp(result, expect, strlen(expect)) == 0,
"case %d, result \"%s\", expect \"%s\"", i, result, expect);
}
return 1;
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_simple, "printf without varargs");
bt_test_suite(t_router_id, "print router id");
bt_test_suite(t_time, "print time");
bt_test_suite(t_bstrcmp, "bstrcmp");
bt_test_suite(t_fmt_order, "fmt_order");
return bt_exit_value();
}
bird2-2.17.5/lib/resource.c 0000664 0000000 0000000 00000022521 15211753245 0015360 0 ustar 00root root 0000000 0000000 /*
* BIRD Resource Manager
*
* (c) 1998--2000 Martin Mares
* (c) 2021 Maria Matejka
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include
#include
#include
#include "nest/bird.h"
#include "lib/resource.h"
#include "lib/string.h"
/**
* DOC: Resource pools
*
* Resource pools (&pool) are just containers holding a list of
* other resources. Freeing a pool causes all the listed resources
* to be freed as well. Each existing &resource is linked to some pool
* except for a root pool which isn't linked anywhere, so all the
* resources form a tree structure with internal nodes corresponding
* to pools and leaves being the other resources.
*
* Example: Almost all modules of BIRD have their private pool which
* is freed upon shutdown of the module.
*/
struct pool {
resource r;
list inside;
const char *name;
};
static void pool_dump(struct dump_request *, resource *);
static void pool_free(resource *);
static resource *pool_lookup(resource *, unsigned long);
static struct resmem pool_memsize(resource *P);
static struct resclass pool_class = {
"Pool",
sizeof(pool),
pool_free,
pool_dump,
pool_lookup,
pool_memsize
};
pool root_pool;
/**
* rp_new - create a resource pool
* @p: parent pool
* @name: pool name (to be included in debugging dumps)
*
* rp_new() creates a new resource pool inside the specified
* parent pool.
*/
pool *
rp_new(pool *p, const char *name)
{
pool *z = ralloc(p, &pool_class);
z->name = name;
init_list(&z->inside);
return z;
}
pool *
rp_newf(pool *p, const char *fmt, ...)
{
pool *z = rp_new(p, NULL);
va_list args;
va_start(args, fmt);
z->name = mb_vsprintf(p, fmt, args);
va_end(args);
return z;
}
static void
pool_free(resource *P)
{
pool *p = (pool *) P;
resource *r, *rr;
r = HEAD(p->inside);
while (rr = (resource *) r->n.next)
{
r->class->free(r);
xfree(r);
r = rr;
}
}
static void
pool_dump(struct dump_request *dreq, resource *P)
{
pool *p = (pool *) P;
resource *r;
RDUMP("%s\n", p->name);
dreq->indent += 3;
WALK_LIST(r, p->inside)
rdump(dreq, r);
dreq->indent -= 3;
}
static struct resmem
pool_memsize(resource *P)
{
pool *p = (pool *) P;
resource *r;
struct resmem sum = {
.effective = 0,
.overhead = sizeof(pool) + ALLOC_OVERHEAD,
};
WALK_LIST(r, p->inside)
{
struct resmem add = rmemsize(r);
sum.effective += add.effective;
sum.overhead += add.overhead;
}
return sum;
}
static resource *
pool_lookup(resource *P, unsigned long a)
{
pool *p = (pool *) P;
resource *r, *q;
WALK_LIST(r, p->inside)
if (r->class->lookup && (q = r->class->lookup(r, a)))
return q;
return NULL;
}
/**
* rmove - move a resource
* @res: resource
* @p: pool to move the resource to
*
* rmove() moves a resource from one pool to another.
*/
void rmove(void *res, pool *p)
{
resource *r = res;
if (r)
{
if (r->n.next)
rem_node(&r->n);
add_tail(&p->inside, &r->n);
}
}
/**
* rfree - free a resource
* @res: resource
*
* rfree() frees the given resource and all information associated
* with it. In case it's a resource pool, it also frees all the objects
* living inside the pool.
*
* It works by calling a class-specific freeing function.
*/
void
rfree(void *res)
{
resource *r = res;
if (!r)
return;
if (r->n.next)
rem_node(&r->n);
r->class->free(r);
r->class = NULL;
xfree(r);
}
/**
* rdump - dump a resource
* @res: resource
*
* This function prints out all available information about the given
* resource to the debugging output.
*
* It works by calling a class-specific dump function.
*/
void
rdump(struct dump_request *dreq, void *res)
{
char x[16];
resource *r = res;
bsprintf(x, "%%%ds%%p ", dreq->indent);
RDUMP(x, "", r);
if (r)
{
RDUMP("%s ", r->class->name);
r->class->dump(dreq, r);
}
else
RDUMP("NULL\n");
}
void page_dump(struct dump_request *req);
void resource_dump(struct dump_request *req)
{
rdump(req, &root_pool);
page_dump(req);
}
struct resmem
rmemsize(void *res)
{
resource *r = res;
if (!r)
return (struct resmem) {};
if (!r->class->memsize)
return (struct resmem) {
.effective = r->class->size - sizeof(resource),
.overhead = ALLOC_OVERHEAD + sizeof(resource),
};
return r->class->memsize(r);
}
/**
* ralloc - create a resource
* @p: pool to create the resource in
* @c: class of the new resource
*
* This function is called by the resource classes to create a new
* resource of the specified class and link it to the given pool.
* Allocated memory is zeroed. Size of the resource structure is taken
* from the @size field of the &resclass.
*/
void *
ralloc(pool *p, struct resclass *c)
{
resource *r = xmalloc(c->size);
bzero(r, c->size);
r->class = c;
if (p)
add_tail(&p->inside, &r->n);
return r;
}
#if 0
/**
* rlookup - look up a memory location
* @a: memory address
*
* This function examines all existing resources to see whether
* the address @a is inside any resource. It's used for debugging
* purposes only.
*
* It works by calling a class-specific lookup function for each
* resource.
*/
void
rlookup(unsigned long a)
{
resource *r;
debug("Looking up %08lx\n", a);
if (r = pool_lookup(&root_pool.r, a))
rdump(r);
else
debug("Not found.\n");
}
#endif
/**
* resource_init - initialize the resource manager
*
* This function is called during BIRD startup. It initializes
* all data structures of the resource manager and creates the
* root pool.
*/
void
resource_init(void)
{
resource_sys_init();
root_pool.r.class = &pool_class;
root_pool.name = "Root";
init_list(&root_pool.inside);
tmp_init(&root_pool);
}
/**
* DOC: Memory blocks
*
* Memory blocks are pieces of contiguous allocated memory.
* They are a bit non-standard since they are represented not by a pointer
* to &resource, but by a void pointer to the start of data of the
* memory block. All memory block functions know how to locate the header
* given the data pointer.
*
* Example: All "unique" data structures such as hash tables are allocated
* as memory blocks.
*/
struct mblock {
resource r;
unsigned size;
max_align_t data_align[0];
byte data[0];
};
static void mbl_free(resource *r UNUSED)
{
}
static void mbl_debug(struct dump_request *dreq, resource *r)
{
struct mblock *m = (struct mblock *) r;
RDUMP("(size=%d)\n", m->size);
}
static resource *
mbl_lookup(resource *r, unsigned long a)
{
struct mblock *m = (struct mblock *) r;
if ((unsigned long) m->data <= a && (unsigned long) m->data + m->size > a)
return r;
return NULL;
}
static struct resmem
mbl_memsize(resource *r)
{
struct mblock *m = (struct mblock *) r;
return (struct resmem) {
.effective = m->size,
.overhead = ALLOC_OVERHEAD + sizeof(struct mblock),
};
}
static struct resclass mb_class = {
"Memory",
0,
mbl_free,
mbl_debug,
mbl_lookup,
mbl_memsize
};
/**
* mb_alloc - allocate a memory block
* @p: pool
* @size: size of the block
*
* mb_alloc() allocates memory of a given size and creates
* a memory block resource representing this memory chunk
* in the pool @p.
*
* Please note that mb_alloc() returns a pointer to the memory
* chunk, not to the resource, hence you have to free it using
* mb_free(), not rfree().
*/
void *
mb_alloc(pool *p, unsigned size)
{
struct mblock *b = xmalloc(sizeof(struct mblock) + size);
b->r.class = &mb_class;
b->r.n = (node) {};
add_tail(&p->inside, &b->r.n);
b->size = size;
return b->data;
}
/**
* mb_allocz - allocate and clear a memory block
* @p: pool
* @size: size of the block
*
* mb_allocz() allocates memory of a given size, initializes it to
* zeroes and creates a memory block resource representing this memory
* chunk in the pool @p.
*
* Please note that mb_allocz() returns a pointer to the memory
* chunk, not to the resource, hence you have to free it using
* mb_free(), not rfree().
*/
void *
mb_allocz(pool *p, unsigned size)
{
void *x = mb_alloc(p, size);
bzero(x, size);
return x;
}
/**
* mb_realloc - reallocate a memory block
* @m: memory block
* @size: new size of the block
*
* mb_realloc() changes the size of the memory block @m to a given size.
* The contents will be unchanged to the minimum of the old and new sizes;
* newly allocated memory will be uninitialized. Contrary to realloc()
* behavior, @m must be non-NULL, because the resource pool is inherited
* from it.
*
* Like mb_alloc(), mb_realloc() also returns a pointer to the memory
* chunk, not to the resource, hence you have to free it using
* mb_free(), not rfree().
*/
void *
mb_realloc(void *m, unsigned size)
{
struct mblock *b = SKIP_BACK(struct mblock, data, m);
b = xrealloc(b, sizeof(struct mblock) + size);
update_node(&b->r.n);
b->size = size;
return b->data;
}
/**
* mb_free - free a memory block
* @m: memory block
*
* mb_free() frees all memory associated with the block @m.
*/
void
mb_free(void *m)
{
if (!m)
return;
struct mblock *b = SKIP_BACK(struct mblock, data, m);
rfree(b);
}
#define STEP_UP(x) ((x) + (x)/2 + 4)
void
buffer_realloc(void **buf, unsigned *size, unsigned need, unsigned item_size)
{
unsigned nsize = MIN(*size, need);
while (nsize < need)
nsize = STEP_UP(nsize);
*buf = mb_realloc(*buf, nsize * item_size);
*size = nsize;
}
bird2-2.17.5/lib/resource.h 0000664 0000000 0000000 00000010571 15211753245 0015367 0 ustar 00root root 0000000 0000000 /*
* BIRD Resource Manager
*
* (c) 1998--1999 Martin Mares
* (c) 2021 Maria Matejka
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_RESOURCE_H_
#define _BIRD_RESOURCE_H_
#include "lib/lists.h"
struct resmem {
size_t effective; /* Memory actually used for data storage */
size_t overhead; /* Overhead memory imposed by allocator strategies */
};
/* Resource */
typedef struct resource {
node n; /* Inside resource pool */
struct resclass *class; /* Resource class */
} resource;
/* Resource class */
struct resclass {
char *name; /* Resource class name */
unsigned size; /* Standard size of single resource */
void (*free)(resource *); /* Freeing function */
void (*dump)(struct dump_request *, resource *); /* Dump to debug output */
resource *(*lookup)(resource *, unsigned long); /* Look up address (only for debugging) */
struct resmem (*memsize)(resource *); /* Return size of memory used by the resource, may be NULL */
};
/* Estimate of system allocator overhead per item, for memory consumtion stats */
#define ALLOC_OVERHEAD 16
/* Generic resource manipulation */
typedef struct pool pool;
void resource_init(void);
pool *rp_new(pool *, const char *); /* Create new pool */
pool *rp_newf(pool *, const char *, ...); /* Create a new pool with a formatted string as its name */
void rfree(void *); /* Free single resource */
struct dump_request;
void rdump(struct dump_request *, void *); /* Dump to debug output */
void resource_dump(struct dump_request *); /* Dump the root pool */
struct resmem rmemsize(void *res); /* Return size of memory used by the resource */
void rlookup(unsigned long); /* Look up address (only for debugging) */
void rmove(void *, pool *); /* Move to a different pool */
void *ralloc(pool *, struct resclass *);
extern pool root_pool;
/* Normal memory blocks */
void *mb_alloc(pool *, unsigned size) ALLOC_SIZE(2);
void *mb_allocz(pool *, unsigned size) ALLOC_SIZE(2);
void *mb_realloc(void *m, unsigned size) ALLOC_SIZE(2);
void mb_free(void *);
/* Memory pools with linear allocation */
typedef struct linpool linpool;
typedef struct lp_state {
void *current, *large;
byte *ptr;
uint total_large;
} lp_state;
linpool *lp_new(pool *);
void *lp_alloc(linpool *, unsigned size) ALLOC_SIZE(2); /* Aligned */
void *lp_allocu(linpool *, unsigned size) ALLOC_SIZE(2); /* Unaligned */
void *lp_allocz(linpool *, unsigned size) ALLOC_SIZE(2); /* With clear */
void lp_flush(linpool *); /* Free everything, but leave linpool */
void lp_save(linpool *m, lp_state *p); /* Save state */
void lp_restore(linpool *m, lp_state *p); /* Restore state */
extern _Thread_local linpool *tmp_linpool; /* Temporary linpool autoflushed regularily */
#define tmp_alloc(sz) lp_alloc(tmp_linpool, sz)
#define tmp_allocu(sz) lp_allocu(tmp_linpool, sz)
#define tmp_allocz(sz) lp_allocz(tmp_linpool, sz)
#define tmp_init(p) tmp_linpool = lp_new_default(p)
#define tmp_flush() lp_flush(tmp_linpool)
#define lp_new_default lp_new
/* Slabs */
typedef struct slab slab;
slab *sl_new(pool *, unsigned size);
void *sl_alloc(slab *);
void *sl_allocz(slab *);
void sl_free(void *);
/*
* Low-level memory allocation functions, please don't use
* outside resource manager and possibly sysdep code.
*/
void buffer_realloc(void **buf, unsigned *size, unsigned need, unsigned item_size);
/* Allocator of whole pages; for use in slabs and other high-level allocators. */
extern long page_size;
void *alloc_page(void);
void free_page(void *);
void resource_sys_init(void);
#ifdef HAVE_LIBDMALLOC
/*
* The standard dmalloc macros tend to produce lots of namespace
* conflicts and we use only xmalloc, xrealloc and xfree, so we
* can define the stubs ourselves.
*/
#define DMALLOC_DISABLE
#include
#define xmalloc(size) \
dmalloc_malloc(__FILE__, __LINE__, (size), DMALLOC_FUNC_MALLOC, 0, 1)
#define xrealloc(ptr, size) \
dmalloc_realloc(__FILE__, __LINE__, (ptr), (size), DMALLOC_FUNC_REALLOC, 1)
#define xfree(ptr) \
dmalloc_free(__FILE__, __LINE__, (ptr), DMALLOC_FUNC_FREE)
#else
/*
* Unfortunately, several libraries we might want to link to define
* their own xmalloc and we don't want to interfere with them, hence
* the renaming.
*/
#define xmalloc bird_xmalloc
#define xrealloc bird_xrealloc
void *xmalloc(unsigned);
void *xrealloc(void *, unsigned);
#define xfree(x) free(x)
#endif
#endif
bird2-2.17.5/lib/resource.sgml 0000664 0000000 0000000 00000003126 15211753245 0016100 0 ustar 00root root 0000000 0000000
Resources
Introduction
Most large software projects implemented in classical procedural
programming languages usually end up with lots of code taking care
of resource allocation and deallocation. Bugs in such code are often
very difficult to find, because they cause only `resource leakage',
that is keeping a lot of memory and other resources which nobody
references to.
We've tried to solve this problem by employing a resource tracking
system which keeps track of all the resources allocated by all the
modules of BIRD, deallocates everything automatically when a module
shuts down and it is able to print out the list of resources and
the corresponding modules they are allocated by.
Each allocated resource (from now we'll speak about allocated
resources only) is represented by a structure starting with a standard
header (struct There exist the following types of resources:
bird2-2.17.5/lib/sha1.c 0000664 0000000 0000000 00000016037 15211753245 0014372 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- SHA-1 Hash Function (FIPS 180-1, RFC 3174)
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Based on the code from libucw-6.4
* (c) 2008--2009 Martin Mares
*
* Based on the code from libgcrypt-1.2.3, which is
* (c) 1998, 2001, 2002, 2003 Free Software Foundation, Inc.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "lib/sha1.h"
#include "lib/unaligned.h"
void
sha1_init(struct hash_context *CTX)
{
struct sha1_context *ctx = (void *) CTX;
ctx->h0 = 0x67452301;
ctx->h1 = 0xefcdab89;
ctx->h2 = 0x98badcfe;
ctx->h3 = 0x10325476;
ctx->h4 = 0xc3d2e1f0;
ctx->nblocks = 0;
ctx->count = 0;
}
/*
* Transform the message X which consists of 16 32-bit-words
*/
static void
sha1_transform(struct sha1_context *ctx, const byte *data)
{
u32 a,b,c,d,e,tm;
u32 x[16];
/* Get values from the chaining vars. */
a = ctx->h0;
b = ctx->h1;
c = ctx->h2;
d = ctx->h3;
e = ctx->h4;
#ifdef CPU_BIG_ENDIAN
memcpy(x, data, 64);
#else
int i;
for (i = 0; i < 16; i++)
x[i] = get_u32(data+4*i);
#endif
#define K1 0x5A827999L
#define K2 0x6ED9EBA1L
#define K3 0x8F1BBCDCL
#define K4 0xCA62C1D6L
#define F1(x,y,z) ( z ^ ( x & ( y ^ z ) ) )
#define F2(x,y,z) ( x ^ y ^ z )
#define F3(x,y,z) ( ( x & y ) | ( z & ( x | y ) ) )
#define F4(x,y,z) ( x ^ y ^ z )
#define M(i) (tm = x[i&0x0f] ^ x[(i-14)&0x0f] ^ x[(i-8)&0x0f] ^ x[(i-3)&0x0f], (x[i&0x0f] = ROL(tm, 1)))
/* Bitwise rotation of an unsigned int to the left **/
#define ROL(x, bits) (((x) << (bits)) | ((uint)(x) >> (sizeof(uint)*8 - (bits))))
#define R(a, b, c, d, e, f, k, m) \
do \
{ \
e += ROL(a, 5) + f(b, c, d) + k + m; \
b = ROL(b, 30); \
} while(0)
R( a, b, c, d, e, F1, K1, x[ 0] );
R( e, a, b, c, d, F1, K1, x[ 1] );
R( d, e, a, b, c, F1, K1, x[ 2] );
R( c, d, e, a, b, F1, K1, x[ 3] );
R( b, c, d, e, a, F1, K1, x[ 4] );
R( a, b, c, d, e, F1, K1, x[ 5] );
R( e, a, b, c, d, F1, K1, x[ 6] );
R( d, e, a, b, c, F1, K1, x[ 7] );
R( c, d, e, a, b, F1, K1, x[ 8] );
R( b, c, d, e, a, F1, K1, x[ 9] );
R( a, b, c, d, e, F1, K1, x[10] );
R( e, a, b, c, d, F1, K1, x[11] );
R( d, e, a, b, c, F1, K1, x[12] );
R( c, d, e, a, b, F1, K1, x[13] );
R( b, c, d, e, a, F1, K1, x[14] );
R( a, b, c, d, e, F1, K1, x[15] );
R( e, a, b, c, d, F1, K1, M(16) );
R( d, e, a, b, c, F1, K1, M(17) );
R( c, d, e, a, b, F1, K1, M(18) );
R( b, c, d, e, a, F1, K1, M(19) );
R( a, b, c, d, e, F2, K2, M(20) );
R( e, a, b, c, d, F2, K2, M(21) );
R( d, e, a, b, c, F2, K2, M(22) );
R( c, d, e, a, b, F2, K2, M(23) );
R( b, c, d, e, a, F2, K2, M(24) );
R( a, b, c, d, e, F2, K2, M(25) );
R( e, a, b, c, d, F2, K2, M(26) );
R( d, e, a, b, c, F2, K2, M(27) );
R( c, d, e, a, b, F2, K2, M(28) );
R( b, c, d, e, a, F2, K2, M(29) );
R( a, b, c, d, e, F2, K2, M(30) );
R( e, a, b, c, d, F2, K2, M(31) );
R( d, e, a, b, c, F2, K2, M(32) );
R( c, d, e, a, b, F2, K2, M(33) );
R( b, c, d, e, a, F2, K2, M(34) );
R( a, b, c, d, e, F2, K2, M(35) );
R( e, a, b, c, d, F2, K2, M(36) );
R( d, e, a, b, c, F2, K2, M(37) );
R( c, d, e, a, b, F2, K2, M(38) );
R( b, c, d, e, a, F2, K2, M(39) );
R( a, b, c, d, e, F3, K3, M(40) );
R( e, a, b, c, d, F3, K3, M(41) );
R( d, e, a, b, c, F3, K3, M(42) );
R( c, d, e, a, b, F3, K3, M(43) );
R( b, c, d, e, a, F3, K3, M(44) );
R( a, b, c, d, e, F3, K3, M(45) );
R( e, a, b, c, d, F3, K3, M(46) );
R( d, e, a, b, c, F3, K3, M(47) );
R( c, d, e, a, b, F3, K3, M(48) );
R( b, c, d, e, a, F3, K3, M(49) );
R( a, b, c, d, e, F3, K3, M(50) );
R( e, a, b, c, d, F3, K3, M(51) );
R( d, e, a, b, c, F3, K3, M(52) );
R( c, d, e, a, b, F3, K3, M(53) );
R( b, c, d, e, a, F3, K3, M(54) );
R( a, b, c, d, e, F3, K3, M(55) );
R( e, a, b, c, d, F3, K3, M(56) );
R( d, e, a, b, c, F3, K3, M(57) );
R( c, d, e, a, b, F3, K3, M(58) );
R( b, c, d, e, a, F3, K3, M(59) );
R( a, b, c, d, e, F4, K4, M(60) );
R( e, a, b, c, d, F4, K4, M(61) );
R( d, e, a, b, c, F4, K4, M(62) );
R( c, d, e, a, b, F4, K4, M(63) );
R( b, c, d, e, a, F4, K4, M(64) );
R( a, b, c, d, e, F4, K4, M(65) );
R( e, a, b, c, d, F4, K4, M(66) );
R( d, e, a, b, c, F4, K4, M(67) );
R( c, d, e, a, b, F4, K4, M(68) );
R( b, c, d, e, a, F4, K4, M(69) );
R( a, b, c, d, e, F4, K4, M(70) );
R( e, a, b, c, d, F4, K4, M(71) );
R( d, e, a, b, c, F4, K4, M(72) );
R( c, d, e, a, b, F4, K4, M(73) );
R( b, c, d, e, a, F4, K4, M(74) );
R( a, b, c, d, e, F4, K4, M(75) );
R( e, a, b, c, d, F4, K4, M(76) );
R( d, e, a, b, c, F4, K4, M(77) );
R( c, d, e, a, b, F4, K4, M(78) );
R( b, c, d, e, a, F4, K4, M(79) );
/* Update chaining vars. */
ctx->h0 += a;
ctx->h1 += b;
ctx->h2 += c;
ctx->h3 += d;
ctx->h4 += e;
}
/*
* Update the message digest with the contents of BUF with length LEN.
*/
void
sha1_update(struct hash_context *CTX, const byte *buf, uint len)
{
struct sha1_context *ctx = (void *) CTX;
if (ctx->count)
{
/* Fill rest of internal buffer */
for (; len && ctx->count < SHA1_BLOCK_SIZE; len--)
ctx->buf[ctx->count++] = *buf++;
if (ctx->count < SHA1_BLOCK_SIZE)
return;
/* Process data from internal buffer */
sha1_transform(ctx, ctx->buf);
ctx->nblocks++;
ctx->count = 0;
}
if (!len)
return;
/* Process data from input buffer */
while (len >= SHA1_BLOCK_SIZE)
{
sha1_transform(ctx, buf);
ctx->nblocks++;
buf += SHA1_BLOCK_SIZE;
len -= SHA1_BLOCK_SIZE;
}
/* Copy remaining data to internal buffer */
memcpy(ctx->buf, buf, len);
ctx->count = len;
}
/*
* The routine final terminates the computation and returns the digest. The
* handle is prepared for a new cycle, but adding bytes to the handle will the
* destroy the returned buffer.
*
* Returns: 20 bytes representing the digest.
*/
byte *
sha1_final(struct hash_context *CTX)
{
struct sha1_context *ctx = (void *) CTX;
u32 t, msb, lsb;
sha1_update(CTX, NULL, 0); /* flush */
t = ctx->nblocks;
/* multiply by 64 to make a byte count */
lsb = t << 6;
msb = t >> 26;
/* add the count */
t = lsb;
if ((lsb += ctx->count) < t)
msb++;
/* multiply by 8 to make a bit count */
t = lsb;
lsb <<= 3;
msb <<= 3;
msb |= t >> 29;
if (ctx->count < 56)
{
/* enough room */
ctx->buf[ctx->count++] = 0x80; /* pad */
while (ctx->count < 56)
ctx->buf[ctx->count++] = 0; /* pad */
}
else
{
/* need one extra block */
ctx->buf[ctx->count++] = 0x80; /* pad character */
while (ctx->count < 64)
ctx->buf[ctx->count++] = 0;
sha1_update(CTX, NULL, 0); /* flush */
memset(ctx->buf, 0, 56); /* fill next block with zeroes */
}
/* append the 64 bit count */
ctx->buf[56] = msb >> 24;
ctx->buf[57] = msb >> 16;
ctx->buf[58] = msb >> 8;
ctx->buf[59] = msb;
ctx->buf[60] = lsb >> 24;
ctx->buf[61] = lsb >> 16;
ctx->buf[62] = lsb >> 8;
ctx->buf[63] = lsb;
sha1_transform(ctx, ctx->buf);
byte *p = ctx->buf;
#define X(a) do { put_u32(p, ctx->h##a); p += 4; } while(0)
X(0);
X(1);
X(2);
X(3);
X(4);
#undef X
return ctx->buf;
}
bird2-2.17.5/lib/sha1.h 0000664 0000000 0000000 00000003721 15211753245 0014373 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- SHA-1 Hash Function (FIPS 180-1, RFC 3174)
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Based on the code from libucw-6.4
* (c) 2008--2009 Martin Mares
*
* Based on the code from libgcrypt-1.2.3, which is
* (c) 1998, 2001, 2002, 2003 Free Software Foundation, Inc.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_SHA1_H_
#define _BIRD_SHA1_H_
#include "nest/bird.h"
#define SHA1_SIZE 20 /* Size of the SHA1 hash in its binary representation */
#define SHA1_HEX_SIZE 41 /* Buffer length for a string containing SHA1 in hexadecimal format. */
#define SHA1_BLOCK_SIZE 64 /* SHA1 splits input to blocks of this size. */
/*
* Internal SHA1 state.
* You should use it just as an opaque handle only.
*/
struct hash_context;
struct sha1_context {
u32 h0, h1, h2, h3, h4;
byte buf[SHA1_BLOCK_SIZE];
uint nblocks;
uint count;
};
void sha1_init(struct hash_context *ctx); /* Initialize new algorithm run in the @ctx context. **/
/*
* Push another @len bytes of data pointed to by @buf onto the SHA1 hash
* currently in @ctx. You can call this any times you want on the same hash (and
* you do not need to reinitialize it by sha1_init()). It has the same effect
* as concatenating all the data together and passing them at once.
*/
void sha1_update(struct hash_context *ctx, const byte *buf, uint len);
/*
* No more sha1_update() calls will be done. This terminates the hash and
* returns a pointer to it.
*
* Note that the pointer points into data in the @ctx context. If it ceases to
* exist, the pointer becomes invalid.
*/
byte *sha1_final(struct hash_context *ctx);
/*
* A convenience one-shot function for SHA1 hash. It is equivalent to this
* snippet of code:
*
* sha1_context ctx;
* sha1_init(&ctx);
* sha1_update(&ctx, buffer, length);
* memcpy(outbuf, sha1_final(&ctx), SHA1_SIZE);
*/
void sha1_hash_buffer(byte *outbuf, const byte *buffer, uint length);
#endif /* _BIRD_SHA1_H_ */
bird2-2.17.5/lib/sha256.c 0000664 0000000 0000000 00000016515 15211753245 0014547 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- SHA-256 and SHA-224 Hash Functions
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Based on the code from libgcrypt-1.6.0, which is
* (c) 2003, 2006, 2008, 2009 Free Software Foundation, Inc.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "lib/sha256.h"
#include "lib/unaligned.h"
// #define SHA256_UNROLLED
void
sha256_init(struct hash_context *CTX)
{
struct sha256_context *ctx = (void *) CTX;
ctx->h0 = 0x6a09e667;
ctx->h1 = 0xbb67ae85;
ctx->h2 = 0x3c6ef372;
ctx->h3 = 0xa54ff53a;
ctx->h4 = 0x510e527f;
ctx->h5 = 0x9b05688c;
ctx->h6 = 0x1f83d9ab;
ctx->h7 = 0x5be0cd19;
ctx->nblocks = 0;
ctx->count = 0;
}
void
sha224_init(struct hash_context *CTX)
{
struct sha224_context *ctx = (void *) CTX;
ctx->h0 = 0xc1059ed8;
ctx->h1 = 0x367cd507;
ctx->h2 = 0x3070dd17;
ctx->h3 = 0xf70e5939;
ctx->h4 = 0xffc00b31;
ctx->h5 = 0x68581511;
ctx->h6 = 0x64f98fa7;
ctx->h7 = 0xbefa4fa4;
ctx->nblocks = 0;
ctx->count = 0;
}
/* (4.2) same as SHA-1's F1. */
static inline u32
f1(u32 x, u32 y, u32 z)
{
return (z ^ (x & (y ^ z)));
}
/* (4.3) same as SHA-1's F3 */
static inline u32
f3(u32 x, u32 y, u32 z)
{
return ((x & y) | (z & (x|y)));
}
/* Bitwise rotation of an uint to the right */
static inline u32 ror(u32 x, int n)
{
return ((x >> (n&(32-1))) | (x << ((32-n)&(32-1))));
}
/* (4.4) */
static inline u32
sum0(u32 x)
{
return (ror(x, 2) ^ ror(x, 13) ^ ror(x, 22));
}
/* (4.5) */
static inline u32
sum1(u32 x)
{
return (ror(x, 6) ^ ror(x, 11) ^ ror(x, 25));
}
/*
Transform the message X which consists of 16 32-bit-words. See FIPS
180-2 for details. */
#define S0(x) (ror((x), 7) ^ ror((x), 18) ^ ((x) >> 3)) /* (4.6) */
#define S1(x) (ror((x), 17) ^ ror((x), 19) ^ ((x) >> 10)) /* (4.7) */
#define R(a,b,c,d,e,f,g,h,k,w) \
do \
{ \
t1 = (h) + sum1((e)) + f1((e),(f),(g)) + (k) + (w); \
t2 = sum0((a)) + f3((a),(b),(c)); \
h = g; \
g = f; \
f = e; \
e = d + t1; \
d = c; \
c = b; \
b = a; \
a = t1 + t2; \
} while (0)
/*
The SHA-256 core: Transform the message X which consists of 16
32-bit-words. See FIPS 180-2 for details.
*/
static uint
sha256_transform(struct sha256_context *ctx, const byte *data)
{
static const u32 K[64] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
};
u32 a,b,c,d,e,f,g,h,t1,t2;
u32 w[64];
int i;
a = ctx->h0;
b = ctx->h1;
c = ctx->h2;
d = ctx->h3;
e = ctx->h4;
f = ctx->h5;
g = ctx->h6;
h = ctx->h7;
for (i = 0; i < 16; i++)
w[i] = get_u32(data + i * 4);
for (; i < 64; i++)
w[i] = S1(w[i-2]) + w[i-7] + S0(w[i-15]) + w[i-16];
for (i = 0; i < 64;)
{
#ifndef SHA256_UNROLLED
R(a,b,c,d,e,f,g,h,K[i],w[i]);
i++;
#else /* Unrolled */
t1 = h + sum1(e) + f1(e, f, g) + K[i] + w[i];
t2 = sum0(a) + f3(a, b, c);
d += t1;
h = t1 + t2;
t1 = g + sum1(d) + f1(d, e, f) + K[i+1] + w[i+1];
t2 = sum0(h) + f3(h, a, b);
c += t1;
g = t1 + t2;
t1 = f + sum1(c) + f1(c, d, e) + K[i+2] + w[i+2];
t2 = sum0(g) + f3(g, h, a);
b += t1;
f = t1 + t2;
t1 = e + sum1(b) + f1(b, c, d) + K[i+3] + w[i+3];
t2 = sum0(f) + f3(f, g, h);
a += t1;
e = t1 + t2;
t1 = d + sum1(a) + f1(a, b, c) + K[i+4] + w[i+4];
t2 = sum0(e) + f3(e, f, g);
h += t1;
d = t1 + t2;
t1 = c + sum1(h) + f1(h, a, b) + K[i+5] + w[i+5];
t2 = sum0(d) + f3(d, e, f);
g += t1;
c = t1 + t2;
t1 = b + sum1(g) + f1(g, h, a) + K[i+6] + w[i+6];
t2 = sum0(c) + f3(c, d, e);
f += t1;
b = t1 + t2;
t1 = a + sum1(f) + f1(f, g, h) + K[i+7] + w[i+7];
t2 = sum0(b) + f3(b, c, d);
e += t1;
a = t1 + t2;
i += 8;
#endif
}
ctx->h0 += a;
ctx->h1 += b;
ctx->h2 += c;
ctx->h3 += d;
ctx->h4 += e;
ctx->h5 += f;
ctx->h6 += g;
ctx->h7 += h;
return /*burn_stack*/ 74*4+32;
}
#undef S0
#undef S1
#undef R
/* Common function to write a chunk of data to the transform function
of a hash algorithm. Note that the use of the term "block" does
not imply a fixed size block. Note that we explicitly allow to use
this function after the context has been finalized; the result does
not have any meaning but writing after finalize is sometimes
helpful to mitigate timing attacks. */
void
sha256_update(struct hash_context *CTX, const byte *buf, uint len)
{
struct sha256_context *ctx = (void *) CTX;
if (ctx->count)
{
/* Fill rest of internal buffer */
for (; len && ctx->count < SHA256_BLOCK_SIZE; len--)
ctx->buf[ctx->count++] = *buf++;
if (ctx->count < SHA256_BLOCK_SIZE)
return;
/* Process data from internal buffer */
sha256_transform(ctx, ctx->buf);
ctx->nblocks++;
ctx->count = 0;
}
if (!len)
return;
/* Process data from input buffer */
while (len >= SHA256_BLOCK_SIZE)
{
sha256_transform(ctx, buf);
ctx->nblocks++;
buf += SHA256_BLOCK_SIZE;
len -= SHA256_BLOCK_SIZE;
}
/* Copy remaining data to internal buffer */
memcpy(ctx->buf, buf, len);
ctx->count = len;
}
/*
* The routine finally terminates the computation and returns the digest. The
* handle is prepared for a new cycle, but adding bytes to the handle will the
* destroy the returned buffer.
*
* Returns: 32 bytes with the message the digest. 28 bytes for SHA-224.
*/
byte *
sha256_final(struct hash_context *CTX)
{
struct sha256_context *ctx = (void *) CTX;
u32 t, th, msb, lsb;
sha256_update(CTX, NULL, 0); /* flush */
t = ctx->nblocks;
th = 0;
/* multiply by 64 to make a byte count */
lsb = t << 6;
msb = (th << 6) | (t >> 26);
/* add the count */
t = lsb;
if ((lsb += ctx->count) < t)
msb++;
/* multiply by 8 to make a bit count */
t = lsb;
lsb <<= 3;
msb <<= 3;
msb |= t >> 29;
if (ctx->count < 56)
{
/* enough room */
ctx->buf[ctx->count++] = 0x80; /* pad */
while (ctx->count < 56)
ctx->buf[ctx->count++] = 0; /* pad */
}
else
{
/* need one extra block */
ctx->buf[ctx->count++] = 0x80; /* pad character */
while (ctx->count < 64)
ctx->buf[ctx->count++] = 0;
sha256_update(CTX, NULL, 0); /* flush */;
memset(ctx->buf, 0, 56 ); /* fill next block with zeroes */
}
/* append the 64 bit count */
put_u32(ctx->buf + 56, msb);
put_u32(ctx->buf + 60, lsb);
sha256_transform(ctx, ctx->buf);
byte *p = ctx->buf;
#define X(a) do { put_u32(p, ctx->h##a); p += 4; } while(0)
X(0);
X(1);
X(2);
X(3);
X(4);
X(5);
X(6);
X(7);
#undef X
return ctx->buf;
}
bird2-2.17.5/lib/sha256.h 0000664 0000000 0000000 00000002001 15211753245 0014535 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- SHA-256 and SHA-224 Hash Functions
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Based on the code from libgcrypt-1.6.0, which is
* (c) 2003, 2006, 2008, 2009 Free Software Foundation, Inc.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_SHA256_H_
#define _BIRD_SHA256_H_
#include "nest/bird.h"
#define SHA224_SIZE 28
#define SHA224_HEX_SIZE 57
#define SHA224_BLOCK_SIZE 64
#define SHA256_SIZE 32
#define SHA256_HEX_SIZE 65
#define SHA256_BLOCK_SIZE 64
struct hash_context;
struct sha256_context {
u32 h0, h1, h2, h3, h4, h5, h6, h7;
byte buf[SHA256_BLOCK_SIZE];
uint nblocks;
uint count;
};
#define sha224_context sha256_context
void sha256_init(struct hash_context *ctx);
void sha224_init(struct hash_context *ctx);
void sha256_update(struct hash_context *ctx, const byte *buf, uint len);
#define sha224_update sha256_update
byte *sha256_final(struct hash_context *ctx);
#define sha224_final sha256_final
#endif /* _BIRD_SHA256_H_ */
bird2-2.17.5/lib/sha512.c 0000664 0000000 0000000 00000030107 15211753245 0014533 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- SHA-512 and SHA-384 Hash Functions
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Based on the code from libgcrypt-1.6.0, which is
* (c) 2003, 2006, 2008, 2009 Free Software Foundation, Inc.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "lib/sha512.h"
#include "lib/unaligned.h"
// #define SHA512_UNROLLED
void
sha512_init(struct hash_context *CTX)
{
struct sha512_context *ctx = (void *) CTX;
ctx->h0 = U64(0x6a09e667f3bcc908);
ctx->h1 = U64(0xbb67ae8584caa73b);
ctx->h2 = U64(0x3c6ef372fe94f82b);
ctx->h3 = U64(0xa54ff53a5f1d36f1);
ctx->h4 = U64(0x510e527fade682d1);
ctx->h5 = U64(0x9b05688c2b3e6c1f);
ctx->h6 = U64(0x1f83d9abfb41bd6b);
ctx->h7 = U64(0x5be0cd19137e2179);
ctx->nblocks = 0;
ctx->count = 0;
}
void
sha384_init(struct hash_context *CTX)
{
struct sha384_context *ctx = (void *) CTX;
ctx->h0 = U64(0xcbbb9d5dc1059ed8);
ctx->h1 = U64(0x629a292a367cd507);
ctx->h2 = U64(0x9159015a3070dd17);
ctx->h3 = U64(0x152fecd8f70e5939);
ctx->h4 = U64(0x67332667ffc00b31);
ctx->h5 = U64(0x8eb44a8768581511);
ctx->h6 = U64(0xdb0c2e0d64f98fa7);
ctx->h7 = U64(0x47b5481dbefa4fa4);
ctx->nblocks = 0;
ctx->count = 0;
}
static inline u64
ROTR(u64 x, u64 n)
{
return ((x >> n) | (x << (64 - n)));
}
static inline u64
Ch(u64 x, u64 y, u64 z)
{
return ((x & y) ^ ( ~x & z));
}
static inline u64
Maj(u64 x, u64 y, u64 z)
{
return ((x & y) ^ (x & z) ^ (y & z));
}
static inline u64
sum0(u64 x)
{
return (ROTR(x, 28) ^ ROTR(x, 34) ^ ROTR(x, 39));
}
static inline u64
sum1(u64 x)
{
return (ROTR(x, 14) ^ ROTR(x, 18) ^ ROTR(x, 41));
}
static const u64 k[] =
{
U64(0x428a2f98d728ae22), U64(0x7137449123ef65cd),
U64(0xb5c0fbcfec4d3b2f), U64(0xe9b5dba58189dbbc),
U64(0x3956c25bf348b538), U64(0x59f111f1b605d019),
U64(0x923f82a4af194f9b), U64(0xab1c5ed5da6d8118),
U64(0xd807aa98a3030242), U64(0x12835b0145706fbe),
U64(0x243185be4ee4b28c), U64(0x550c7dc3d5ffb4e2),
U64(0x72be5d74f27b896f), U64(0x80deb1fe3b1696b1),
U64(0x9bdc06a725c71235), U64(0xc19bf174cf692694),
U64(0xe49b69c19ef14ad2), U64(0xefbe4786384f25e3),
U64(0x0fc19dc68b8cd5b5), U64(0x240ca1cc77ac9c65),
U64(0x2de92c6f592b0275), U64(0x4a7484aa6ea6e483),
U64(0x5cb0a9dcbd41fbd4), U64(0x76f988da831153b5),
U64(0x983e5152ee66dfab), U64(0xa831c66d2db43210),
U64(0xb00327c898fb213f), U64(0xbf597fc7beef0ee4),
U64(0xc6e00bf33da88fc2), U64(0xd5a79147930aa725),
U64(0x06ca6351e003826f), U64(0x142929670a0e6e70),
U64(0x27b70a8546d22ffc), U64(0x2e1b21385c26c926),
U64(0x4d2c6dfc5ac42aed), U64(0x53380d139d95b3df),
U64(0x650a73548baf63de), U64(0x766a0abb3c77b2a8),
U64(0x81c2c92e47edaee6), U64(0x92722c851482353b),
U64(0xa2bfe8a14cf10364), U64(0xa81a664bbc423001),
U64(0xc24b8b70d0f89791), U64(0xc76c51a30654be30),
U64(0xd192e819d6ef5218), U64(0xd69906245565a910),
U64(0xf40e35855771202a), U64(0x106aa07032bbd1b8),
U64(0x19a4c116b8d2d0c8), U64(0x1e376c085141ab53),
U64(0x2748774cdf8eeb99), U64(0x34b0bcb5e19b48a8),
U64(0x391c0cb3c5c95a63), U64(0x4ed8aa4ae3418acb),
U64(0x5b9cca4f7763e373), U64(0x682e6ff3d6b2b8a3),
U64(0x748f82ee5defb2fc), U64(0x78a5636f43172f60),
U64(0x84c87814a1f0ab72), U64(0x8cc702081a6439ec),
U64(0x90befffa23631e28), U64(0xa4506cebde82bde9),
U64(0xbef9a3f7b2c67915), U64(0xc67178f2e372532b),
U64(0xca273eceea26619c), U64(0xd186b8c721c0c207),
U64(0xeada7dd6cde0eb1e), U64(0xf57d4f7fee6ed178),
U64(0x06f067aa72176fba), U64(0x0a637dc5a2c898a6),
U64(0x113f9804bef90dae), U64(0x1b710b35131c471b),
U64(0x28db77f523047d84), U64(0x32caab7b40c72493),
U64(0x3c9ebe0a15c9bebc), U64(0x431d67c49c100d4c),
U64(0x4cc5d4becb3e42b6), U64(0x597f299cfc657e2a),
U64(0x5fcb6fab3ad6faec), U64(0x6c44198c4a475817)
};
/*
* Transform the message W which consists of 16 64-bit-words
*/
static uint
sha512_transform(struct sha512_context *ctx, const byte *data)
{
u64 a, b, c, d, e, f, g, h;
u64 w[16];
uint t;
/* get values from the chaining vars */
a = ctx->h0;
b = ctx->h1;
c = ctx->h2;
d = ctx->h3;
e = ctx->h4;
f = ctx->h5;
g = ctx->h6;
h = ctx->h7;
for (t = 0; t < 16; t++)
w[t] = get_u64(data + t * 8);
#define S0(x) (ROTR((x),1) ^ ROTR((x),8) ^ ((x)>>7))
#define S1(x) (ROTR((x),19) ^ ROTR((x),61) ^ ((x)>>6))
for (t = 0; t < 80 - 16; )
{
u64 t1, t2;
/* Performance on a AMD Athlon(tm) Dual Core Processor 4050e
with gcc 4.3.3 using gcry_md_hash_buffer of each 10000 bytes
initialized to 0,1,2,3...255,0,... and 1000 iterations:
Not unrolled with macros: 440ms
Unrolled with macros: 350ms
Unrolled with inline: 330ms
*/
#ifndef SHA512_UNROLLED
t1 = h + sum1(e) + Ch(e, f, g) + k[t] + w[t%16];
w[t%16] += S1(w[(t - 2)%16]) + w[(t - 7)%16] + S0(w[(t - 15)%16]);
t2 = sum0(a) + Maj(a, b, c);
h = g;
g = f;
f = e;
e = d + t1;
d = c;
c = b;
b = a;
a = t1 + t2;
t++;
#else /* Unrolled */
t1 = h + sum1(e) + Ch(e, f, g) + k[t] + w[0];
w[0] += S1(w[14]) + w[9] + S0(w[1]);
t2 = sum0(a) + Maj(a, b, c);
d += t1;
h = t1 + t2;
t1 = g + sum1(d) + Ch(d, e, f) + k[t+1] + w[1];
w[1] += S1(w[15]) + w[10] + S0(w[2]);
t2 = sum0(h) + Maj(h, a, b);
c += t1;
g = t1 + t2;
t1 = f + sum1(c) + Ch(c, d, e) + k[t+2] + w[2];
w[2] += S1(w[0]) + w[11] + S0(w[3]);
t2 = sum0(g) + Maj(g, h, a);
b += t1;
f = t1 + t2;
t1 = e + sum1(b) + Ch(b, c, d) + k[t+3] + w[3];
w[3] += S1(w[1]) + w[12] + S0(w[4]);
t2 = sum0(f) + Maj(f, g, h);
a += t1;
e = t1 + t2;
t1 = d + sum1(a) + Ch(a, b, c) + k[t+4] + w[4];
w[4] += S1(w[2]) + w[13] + S0(w[5]);
t2 = sum0(e) + Maj(e, f, g);
h += t1;
d = t1 + t2;
t1 = c + sum1(h) + Ch(h, a, b) + k[t+5] + w[5];
w[5] += S1(w[3]) + w[14] + S0(w[6]);
t2 = sum0(d) + Maj(d, e, f);
g += t1;
c = t1 + t2;
t1 = b + sum1(g) + Ch(g, h, a) + k[t+6] + w[6];
w[6] += S1(w[4]) + w[15] + S0(w[7]);
t2 = sum0(c) + Maj(c, d, e);
f += t1;
b = t1 + t2;
t1 = a + sum1(f) + Ch(f, g, h) + k[t+7] + w[7];
w[7] += S1(w[5]) + w[0] + S0(w[8]);
t2 = sum0(b) + Maj(b, c, d);
e += t1;
a = t1 + t2;
t1 = h + sum1(e) + Ch(e, f, g) + k[t+8] + w[8];
w[8] += S1(w[6]) + w[1] + S0(w[9]);
t2 = sum0(a) + Maj(a, b, c);
d += t1;
h = t1 + t2;
t1 = g + sum1(d) + Ch(d, e, f) + k[t+9] + w[9];
w[9] += S1(w[7]) + w[2] + S0(w[10]);
t2 = sum0(h) + Maj(h, a, b);
c += t1;
g = t1 + t2;
t1 = f + sum1(c) + Ch(c, d, e) + k[t+10] + w[10];
w[10] += S1(w[8]) + w[3] + S0(w[11]);
t2 = sum0(g) + Maj(g, h, a);
b += t1;
f = t1 + t2;
t1 = e + sum1(b) + Ch(b, c, d) + k[t+11] + w[11];
w[11] += S1(w[9]) + w[4] + S0(w[12]);
t2 = sum0(f) + Maj(f, g, h);
a += t1;
e = t1 + t2;
t1 = d + sum1(a) + Ch(a, b, c) + k[t+12] + w[12];
w[12] += S1(w[10]) + w[5] + S0(w[13]);
t2 = sum0(e) + Maj(e, f, g);
h += t1;
d = t1 + t2;
t1 = c + sum1(h) + Ch(h, a, b) + k[t+13] + w[13];
w[13] += S1(w[11]) + w[6] + S0(w[14]);
t2 = sum0(d) + Maj(d, e, f);
g += t1;
c = t1 + t2;
t1 = b + sum1(g) + Ch(g, h, a) + k[t+14] + w[14];
w[14] += S1(w[12]) + w[7] + S0(w[15]);
t2 = sum0(c) + Maj(c, d, e);
f += t1;
b = t1 + t2;
t1 = a + sum1(f) + Ch(f, g, h) + k[t+15] + w[15];
w[15] += S1(w[13]) + w[8] + S0(w[0]);
t2 = sum0(b) + Maj(b, c, d);
e += t1;
a = t1 + t2;
t += 16;
#endif
}
for (; t < 80; )
{
u64 t1, t2;
#ifndef SHA512_UNROLLED
t1 = h + sum1(e) + Ch(e, f, g) + k[t] + w[t%16];
t2 = sum0(a) + Maj(a, b, c);
h = g;
g = f;
f = e;
e = d + t1;
d = c;
c = b;
b = a;
a = t1 + t2;
t++;
#else /* Unrolled */
t1 = h + sum1(e) + Ch(e, f, g) + k[t] + w[0];
t2 = sum0(a) + Maj(a, b, c);
d += t1;
h = t1 + t2;
t1 = g + sum1(d) + Ch(d, e, f) + k[t+1] + w[1];
t2 = sum0(h) + Maj(h, a, b);
c += t1;
g = t1 + t2;
t1 = f + sum1(c) + Ch(c, d, e) + k[t+2] + w[2];
t2 = sum0(g) + Maj(g, h, a);
b += t1;
f = t1 + t2;
t1 = e + sum1(b) + Ch(b, c, d) + k[t+3] + w[3];
t2 = sum0(f) + Maj(f, g, h);
a += t1;
e = t1 + t2;
t1 = d + sum1(a) + Ch(a, b, c) + k[t+4] + w[4];
t2 = sum0(e) + Maj(e, f, g);
h += t1;
d = t1 + t2;
t1 = c + sum1(h) + Ch(h, a, b) + k[t+5] + w[5];
t2 = sum0(d) + Maj(d, e, f);
g += t1;
c = t1 + t2;
t1 = b + sum1(g) + Ch(g, h, a) + k[t+6] + w[6];
t2 = sum0(c) + Maj(c, d, e);
f += t1;
b = t1 + t2;
t1 = a + sum1(f) + Ch(f, g, h) + k[t+7] + w[7];
t2 = sum0(b) + Maj(b, c, d);
e += t1;
a = t1 + t2;
t1 = h + sum1(e) + Ch(e, f, g) + k[t+8] + w[8];
t2 = sum0(a) + Maj(a, b, c);
d += t1;
h = t1 + t2;
t1 = g + sum1(d) + Ch(d, e, f) + k[t+9] + w[9];
t2 = sum0(h) + Maj(h, a, b);
c += t1;
g = t1 + t2;
t1 = f + sum1(c) + Ch(c, d, e) + k[t+10] + w[10];
t2 = sum0(g) + Maj(g, h, a);
b += t1;
f = t1 + t2;
t1 = e + sum1(b) + Ch(b, c, d) + k[t+11] + w[11];
t2 = sum0(f) + Maj(f, g, h);
a += t1;
e = t1 + t2;
t1 = d + sum1(a) + Ch(a, b, c) + k[t+12] + w[12];
t2 = sum0(e) + Maj(e, f, g);
h += t1;
d = t1 + t2;
t1 = c + sum1(h) + Ch(h, a, b) + k[t+13] + w[13];
t2 = sum0(d) + Maj(d, e, f);
g += t1;
c = t1 + t2;
t1 = b + sum1(g) + Ch(g, h, a) + k[t+14] + w[14];
t2 = sum0(c) + Maj(c, d, e);
f += t1;
b = t1 + t2;
t1 = a + sum1(f) + Ch(f, g, h) + k[t+15] + w[15];
t2 = sum0(b) + Maj(b, c, d);
e += t1;
a = t1 + t2;
t += 16;
#endif
}
/* Update chaining vars. */
ctx->h0 += a;
ctx->h1 += b;
ctx->h2 += c;
ctx->h3 += d;
ctx->h4 += e;
ctx->h5 += f;
ctx->h6 += g;
ctx->h7 += h;
return /* burn_stack */ (8 + 16) * sizeof(u64) + sizeof(u32) + 3 * sizeof(void*);
}
void
sha512_update(struct hash_context *CTX, const byte *buf, uint len)
{
struct sha512_context *ctx = (void *) CTX;
if (ctx->count)
{
/* Fill rest of internal buffer */
for (; len && ctx->count < SHA512_BLOCK_SIZE; len--)
ctx->buf[ctx->count++] = *buf++;
if (ctx->count < SHA512_BLOCK_SIZE)
return;
/* Process data from internal buffer */
sha512_transform(ctx, ctx->buf);
ctx->nblocks++;
ctx->count = 0;
}
if (!len)
return;
/* Process data from input buffer */
while (len >= SHA512_BLOCK_SIZE)
{
sha512_transform(ctx, buf);
ctx->nblocks++;
buf += SHA512_BLOCK_SIZE;
len -= SHA512_BLOCK_SIZE;
}
/* Copy remaining data to internal buffer */
memcpy(ctx->buf, buf, len);
ctx->count = len;
}
/*
* The routine final terminates the computation and returns the digest. The
* handle is prepared for a new cycle, but adding bytes to the handle will the
* destroy the returned buffer.
*
* Returns: 64 bytes representing the digest. When used for sha384, we take the
* first 48 of those bytes.
*/
byte *
sha512_final(struct hash_context *CTX)
{
struct sha512_context *ctx = (void *) CTX;
u64 t, th, msb, lsb;
sha512_update(CTX, NULL, 0); /* flush */
t = ctx->nblocks;
th = 0;
/* multiply by 128 to make a byte count */
lsb = t << 7;
msb = (th << 7) | (t >> 57);
/* add the count */
t = lsb;
if ((lsb += ctx->count) < t)
msb++;
/* multiply by 8 to make a bit count */
t = lsb;
lsb <<= 3;
msb <<= 3;
msb |= t >> 61;
if (ctx->count < 112)
{
/* enough room */
ctx->buf[ctx->count++] = 0x80; /* pad */
while(ctx->count < 112)
ctx->buf[ctx->count++] = 0; /* pad */
}
else
{
/* need one extra block */
ctx->buf[ctx->count++] = 0x80; /* pad character */
while(ctx->count < 128)
ctx->buf[ctx->count++] = 0;
sha512_update(CTX, NULL, 0); /* flush */
memset(ctx->buf, 0, 112); /* fill next block with zeroes */
}
/* append the 128 bit count */
put_u64(ctx->buf + 112, msb);
put_u64(ctx->buf + 120, lsb);
sha512_transform(ctx, ctx->buf);
byte *p = ctx->buf;
#define X(a) do { put_u64(p, ctx->h##a); p += 8; } while(0)
X(0);
X(1);
X(2);
X(3);
X(4);
X(5);
X(6);
X(7);
#undef X
return ctx->buf;
}
bird2-2.17.5/lib/sha512.h 0000664 0000000 0000000 00000002002 15211753245 0014531 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- SHA-512 and SHA-384 Hash Functions
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Based on the code from libgcrypt-1.6.0, which is
* (c) 2003, 2006, 2008, 2009 Free Software Foundation, Inc.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_SHA512_H_
#define _BIRD_SHA512_H_
#include "nest/bird.h"
#define SHA384_SIZE 48
#define SHA384_HEX_SIZE 97
#define SHA384_BLOCK_SIZE 128
#define SHA512_SIZE 64
#define SHA512_HEX_SIZE 129
#define SHA512_BLOCK_SIZE 128
struct hash_context;
struct sha512_context {
u64 h0, h1, h2, h3, h4, h5, h6, h7;
byte buf[SHA512_BLOCK_SIZE];
uint nblocks;
uint count;
};
#define sha384_context sha512_context
void sha512_init(struct hash_context *ctx);
void sha384_init(struct hash_context *ctx);
void sha512_update(struct hash_context *ctx, const byte *buf, uint len);
#define sha384_update sha512_update
byte *sha512_final(struct hash_context *ctx);
#define sha384_final sha512_final
#endif /* _BIRD_SHA512_H_ */
bird2-2.17.5/lib/slab.c 0000664 0000000 0000000 00000022243 15211753245 0014453 0 ustar 00root root 0000000 0000000 /*
* BIRD Resource Manager -- A SLAB-like Memory Allocator
*
* Heavily inspired by the original SLAB paper by Jeff Bonwick.
*
* (c) 1998--2000 Martin Mares
* (c) 2020 Maria Matejka
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
/**
* DOC: Slabs
*
* Slabs are collections of memory blocks of a fixed size.
* They support very fast allocation and freeing of such blocks, prevent memory
* fragmentation and optimize L2 cache usage. Slabs have been invented by Jeff Bonwick
* and published in USENIX proceedings as `The Slab Allocator: An Object-Caching Kernel
* Memory Allocator'. Our implementation follows this article except that we don't use
* constructors and destructors.
*
* When the |DEBUGGING| switch is turned on, we automatically fill all
* newly allocated and freed blocks with a special pattern to make detection
* of use of uninitialized or already freed memory easier.
*
* Example: Nodes of a FIB are allocated from a per-FIB Slab.
*/
#include
#include
#include "nest/bird.h"
#include "lib/resource.h"
#include "lib/string.h"
#include "lib/tlists.h"
#undef FAKE_SLAB /* Turn on if you want to debug memory allocations */
#ifdef DEBUGGING
#define POISON /* Poison all regions after they are freed */
#endif
static void slab_free(resource *r);
static void slab_dump(struct dump_request *dreq, resource *r);
static resource *slab_lookup(resource *r, unsigned long addr);
static struct resmem slab_memsize(resource *r);
#ifdef FAKE_SLAB
/*
* Fake version used for debugging.
*/
struct slab {
resource r;
uint size;
list objs;
};
static struct resclass sl_class = {
"FakeSlab",
sizeof(struct slab),
slab_free,
slab_dump,
NULL,
slab_memsize
};
struct sl_obj {
node n;
max_align_t data_align[0];
byte data[0];
};
slab *
sl_new(pool *p, uint size)
{
slab *s = ralloc(p, &sl_class);
s->size = size;
init_list(&s->objs);
return s;
}
void *
sl_alloc(slab *s)
{
struct sl_obj *o = xmalloc(sizeof(struct sl_obj) + s->size);
add_tail(&s->objs, &o->n);
return o->data;
}
void *
sl_allocz(slab *s)
{
void *obj = sl_alloc(s);
memset(obj, 0, s->size);
return obj;
}
void
sl_free(void *oo)
{
struct sl_obj *o = SKIP_BACK(struct sl_obj, data, oo);
rem_node(&o->n);
xfree(o);
}
static void
slab_free(resource *r)
{
slab *s = (slab *) r;
struct sl_obj *o, *p;
for(o = HEAD(s->objs); p = (struct sl_obj *) o->n.next; o = p)
xfree(o);
}
static void
slab_dump(resource *r)
{
slab *s = (slab *) r;
int cnt = 0;
struct sl_obj *o;
WALK_LIST(o, s->objs)
cnt++;
debug("(%d objects per %d bytes)\n", cnt, s->size);
}
static struct resmem
slab_memsize(resource *r)
{
slab *s = (slab *) r;
size_t cnt = 0;
struct sl_obj *o;
WALK_LIST(o, s->objs)
cnt++;
return (struct resmem) {
.effective = cnt * s->size,
.overhead = ALLOC_OVERHEAD + sizeof(struct slab) + cnt * ALLOC_OVERHEAD,
};
}
#else
/*
* Real efficient version.
*/
#define MAX_EMPTY_HEADS 1
enum sl_head_state {
slh_empty = 2,
slh_partial = 0,
slh_full = 1,
} PACKED;
struct sl_head {
struct slab *slab;
TLIST_NODE(sl_head, struct sl_head) n;
u16 num_full;
enum sl_head_state state;
u32 used_bits[0];
};
#define TLIST_PREFIX sl_head
#define TLIST_TYPE struct sl_head
#define TLIST_ITEM n
#define TLIST_WANT_WALK
#define TLIST_WANT_ADD_HEAD
#include "lib/tlists.h"
struct slab {
resource r;
uint obj_size, head_size, head_bitfield_len;
uint objs_per_slab, num_empty_heads, data_size;
struct sl_head_list empty_heads, partial_heads, full_heads;
};
static struct resclass sl_class = {
"Slab",
sizeof(struct slab),
slab_free,
slab_dump,
slab_lookup,
slab_memsize
};
#define SL_GET_HEAD(x) ((struct sl_head *) (((uintptr_t) (x)) & ~(page_size-1)))
#define SL_HEAD_CHANGE_STATE(_s, _h, _from, _to) ({ \
ASSERT_DIE(_h->state == slh_##_from); \
sl_head_rem_node(&_s->_from##_heads, _h); \
sl_head_add_head(&_s->_to##_heads, _h); \
_h->state = slh_##_to; \
})
/**
* sl_new - create a new Slab
* @p: resource pool
* @size: block size
*
* This function creates a new Slab resource from which
* objects of size @size can be allocated.
*/
slab *
sl_new(pool *p, uint size)
{
slab *s = ralloc(p, &sl_class);
uint align = CPU_STRUCT_ALIGN;
s->data_size = size;
size = (size + align - 1) / align * align;
s->obj_size = size;
s->head_size = sizeof(struct sl_head);
do {
s->objs_per_slab = (page_size - s->head_size) / size;
s->head_bitfield_len = (s->objs_per_slab + 31) / 32;
s->head_size = (
sizeof(struct sl_head)
+ sizeof(u32) * s->head_bitfield_len
+ align - 1)
/ align * align;
} while (s->objs_per_slab * size + s->head_size > page_size);
if (!s->objs_per_slab)
bug("Slab: object too large");
s->num_empty_heads = 0;
return s;
}
/**
* sl_alloc - allocate an object from Slab
* @s: slab
*
* sl_alloc() allocates space for a single object from the
* Slab and returns a pointer to the object.
*/
void *
sl_alloc(slab *s)
{
struct sl_head *h;
redo:
if (!(h = s->partial_heads.first))
goto no_partial;
okay:
for (uint i=0; ihead_bitfield_len; i++)
if (~h->used_bits[i])
{
uint pos = u32_ctz(~h->used_bits[i]);
if (i * 32 + pos >= s->objs_per_slab)
break;
h->used_bits[i] |= 1 << pos;
h->num_full++;
void *out = ((void *) h) + s->head_size + (i * 32 + pos) * s->obj_size;
#ifdef POISON
memset(out, 0xcd, s->data_size);
#endif
return out;
}
SL_HEAD_CHANGE_STATE(s, h, partial, full);
goto redo;
no_partial:
if (h = s->empty_heads.first)
{
SL_HEAD_CHANGE_STATE(s, h, empty, partial);
s->num_empty_heads--;
goto okay;
}
h = alloc_page();
ASSERT_DIE(SL_GET_HEAD(h) == h);
#ifdef POISON
memset(h, 0xba, page_size);
#endif
memset(h, 0, s->head_size);
h->slab = s;
sl_head_add_head(&s->partial_heads, h);
goto okay;
}
/**
* sl_allocz - allocate an object from Slab and zero it
* @s: slab
*
* sl_allocz() allocates space for a single object from the
* Slab and returns a pointer to the object after zeroing out
* the object memory.
*/
void *
sl_allocz(slab *s)
{
void *obj = sl_alloc(s);
memset(obj, 0, s->data_size);
return obj;
}
/**
* sl_free - return a free object back to a Slab
* @s: slab
* @oo: object returned by sl_alloc()
*
* This function frees memory associated with the object @oo
* and returns it back to the Slab @s.
*/
void
sl_free(void *oo)
{
struct sl_head *h = SL_GET_HEAD(oo);
struct slab *s = h->slab;
#ifdef POISON
memset(oo, 0xdb, s->data_size);
#endif
uint offset = oo - ((void *) h) - s->head_size;
ASSERT_DIE(offset % s->obj_size == 0);
uint pos = offset / s->obj_size;
ASSERT_DIE(pos < s->objs_per_slab);
h->used_bits[pos / 32] &= ~(1 << (pos % 32));
if ((h->num_full-- == s->objs_per_slab) && (h->state == slh_full))
SL_HEAD_CHANGE_STATE(s, h, full, partial);
else if (!h->num_full)
{
sl_head_rem_node(&s->partial_heads, h);
if (s->num_empty_heads >= MAX_EMPTY_HEADS)
{
#ifdef POISON
memset(h, 0xde, page_size);
#endif
free_page(h);
}
else
{
sl_head_add_head(&s->empty_heads, h);
h->state = slh_empty;
s->num_empty_heads++;
}
}
}
static void
slab_free(resource *r)
{
slab *s = (slab *) r;
WALK_TLIST_DELSAFE(sl_head, h, &s->empty_heads)
free_page(h);
WALK_TLIST_DELSAFE(sl_head, h, &s->partial_heads)
free_page(h);
WALK_TLIST_DELSAFE(sl_head, h, &s->full_heads)
free_page(h);
}
static void
slab_dump(struct dump_request *dreq, resource *r)
{
slab *s = (slab *) r;
int ec=0, pc=0, fc=0;
RDUMP("(%d objs per %d bytes in page)\n",
s->objs_per_slab, s->obj_size);
RDUMP("%*sempty:\n", dreq->indent+3, "");
WALK_TLIST(sl_head, h, &s->empty_heads)
{
RDUMP("%*s%p\n", dreq->indent+6, "", h);
ec++;
}
RDUMP("%*spartial:\n", dreq->indent+3, "");
WALK_TLIST(sl_head, h, &s->partial_heads)
{
RDUMP("%*s%p (", dreq->indent+6, "", h);
for (uint i=1; i<=s->head_bitfield_len; i++)
RDUMP("%08x", h->used_bits[s->head_bitfield_len-i]);
RDUMP(")\n");
pc++;
}
RDUMP("%*sfull:\n", dreq->indent+3, "");
WALK_TLIST(sl_head, h, &s->full_heads)
{
RDUMP("%*s%p\n", dreq->indent+6, "", h);
fc++;
}
RDUMP("%*sempty=%d partial=%d total=%d\n", dreq->indent+3, "", ec, pc, fc);
}
static struct resmem
slab_memsize(resource *r)
{
slab *s = (slab *) r;
size_t heads = 0;
WALK_TLIST(sl_head, h, &s->full_heads)
heads++;
size_t items = heads * s->objs_per_slab;
WALK_TLIST(sl_head, h, &s->partial_heads)
{
heads++;
items += h->num_full;
}
WALK_TLIST(sl_head, h, &s->empty_heads)
heads++;
size_t eff = items * s->data_size;
return (struct resmem) {
.effective = eff,
.overhead = ALLOC_OVERHEAD + sizeof(struct slab) + heads * page_size - eff,
};
}
static resource *
slab_lookup(resource *r, unsigned long a)
{
slab *s = (slab *) r;
WALK_TLIST(sl_head, h, &s->partial_heads)
if ((unsigned long) h < a && (unsigned long) h + page_size < a)
return r;
WALK_TLIST(sl_head, h, &s->full_heads)
if ((unsigned long) h < a && (unsigned long) h + page_size < a)
return r;
return NULL;
}
#endif
bird2-2.17.5/lib/slab_test.c 0000664 0000000 0000000 00000006624 15211753245 0015517 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Slab Alloc / Dealloc Tests
*
* (c) 2022 Maria Matejka
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "lib/resource.h"
#include "lib/bitops.h"
static const int sizes[] = {
8, 12, 18, 27, 41, 75, 131, 269,
};
#define TEST_SIZE 1024 * 128
#define ITEMS(sz) TEST_SIZE / ( (sz) >> u32_log2((sz))/2 )
struct test_request {
int size;
enum strategy {
TEST_NONE,
TEST_FORWARDS,
TEST_BACKWARDS,
TEST_RANDOM,
TEST_MIXED,
TEST__MAX,
} strategy;
};
const char * const strategy_name[TEST__MAX] = {
[TEST_FORWARDS] = "forwards",
[TEST_BACKWARDS] = "backwards",
[TEST_RANDOM] = "random",
[TEST_MIXED] = "mixed",
};
static inline byte *test_alloc(slab *s, int sz, struct resmem *sliz)
{
byte *out = sl_alloc(s);
for (int p=0; p < sz; p++)
out[p] = p & 0xff;
struct resmem ns = rmemsize((resource *) s);
bt_assert(sliz->effective + sz == ns.effective);
bt_assert((sliz->overhead - sz - ns.overhead) % page_size == 0);
*sliz = ns;
return out;
}
static inline void test_free(slab *s, byte *block, int sz, struct resmem *sliz)
{
for (int p=0; p < sz; p++)
{
bt_assert(block[p] == (p & 0xff));
block[p]++;
}
sl_free(block);
struct resmem ns = rmemsize((resource *) s);
bt_assert(sliz->effective - sz == ns.effective);
bt_assert((sliz->overhead + sz - ns.overhead) % page_size == 0);
*sliz = ns;
}
static inline struct resmem get_memsize(slab *s)
{
struct resmem sz = rmemsize((resource *) s);
bt_assert(sz.effective == 0);
return sz;
}
static int
t_slab(const void *data)
{
const struct test_request *tr = data;
int sz = tr->size;
slab *s = sl_new(&root_pool, sz);
struct resmem sliz = get_memsize(s);
int n = ITEMS(sz);
byte **block = mb_alloc(&root_pool, n * sizeof(*block));
switch (tr->strategy) {
case TEST_FORWARDS:
for (int i = 0; i < n; i++)
block[i] = test_alloc(s, sz, &sliz);
for (int i = 0; i < n; i++)
test_free(s, block[i], sz, &sliz);
break;
case TEST_BACKWARDS:
for (int i = 0; i < n; i++)
block[i] = test_alloc(s, sz, &sliz);
for (int i = n - 1; i >= 0; i--)
test_free(s, block[i], sz, &sliz);
break;
case TEST_RANDOM:
for (int i = 0; i < n; i++)
block[i] = test_alloc(s, sz, &sliz);
for (int i = 0; i < n; i++)
{
int pos = bt_random() % (n - i);
test_free(s, block[pos], sz, &sliz);
if (pos != n - i - 1)
block[pos] = block[n - i - 1];
}
break;
case TEST_MIXED:
{
int cur = 0;
int pending = n;
while (cur + pending > 0) {
int action = bt_random() % (cur + pending);
if (action < cur) {
test_free(s, block[action], sz, &sliz);
if (action != --cur)
block[action] = block[cur];
} else {
block[cur++] = test_alloc(s, sz, &sliz);
pending--;
}
}
break;
}
default: bug("This shouldn't happen");
}
mb_free(block);
return 1;
}
int main(int argc, char *argv[])
{
bt_init(argc, argv);
struct test_request tr;
for (uint i = 0; i < sizeof(sizes) / sizeof(*sizes); i++)
for (uint strategy = TEST_FORWARDS; strategy < TEST__MAX; strategy++)
{
tr = (struct test_request) {
.size = sizes[i],
.strategy = strategy,
};
bt_test_suite_arg(t_slab, &tr, "Slab allocator test, size=%d, strategy=%s",
tr.size, strategy_name[strategy]);
}
return bt_exit_value();
}
bird2-2.17.5/lib/slist_test.c 0000664 0000000 0000000 00000016471 15211753245 0015735 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Safe Linked Lists Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "lib/slists.h"
#define MAX_NUM 1000
static snode nodes[MAX_NUM];
static slist lst;
static void
show_list(void)
{
bt_debug("\n");
bt_debug("list.null is at %p and point to %p \n", &lst.null, lst.null);
bt_debug("list.head is at %p and point to %p \n", &lst.head, lst.head);
bt_debug("list.tail is at %p and point to %p \n", &lst.tail, lst.tail);
bt_debug("list.tail_readers is at %p and point to %p \n", &lst.tail_readers, lst.tail_readers);
int i;
for (i = 0; i < MAX_NUM; i++)
bt_debug("n[%3i] is at %p, .prev (%p) points to %p, .next (%p) points to %p, .readers (%p) points to %p \n",
i, &nodes[i], &(nodes[i].prev), nodes[i].prev, &(nodes[i].next), nodes[i].next, &(nodes[i].readers), nodes[i].readers);
}
static int
is_filled_list_well_linked(void)
{
int i;
bt_assert(lst.head == &nodes[0]);
bt_assert(lst.tail == &nodes[MAX_NUM-1]);
bt_assert((void *) nodes[0].prev == (void *) &lst.head);
bt_assert((void *) nodes[MAX_NUM-1].next == (void *) &lst.null);
for (i = 0; i < MAX_NUM; i++)
{
if (i < (MAX_NUM-1))
bt_assert(nodes[i].next == &nodes[i+1]);
if (i > 0)
bt_assert(nodes[i].prev == &nodes[i-1]);
}
return 1;
}
static int
is_empty_list_well_unlinked(void)
{
bt_assert(lst.head == SNODE &lst.null);
bt_assert(lst.tail == SNODE &lst.head);
bt_assert(EMPTY_SLIST(lst));
return 1;
}
static void
init_list__(slist *l, struct snode nodes[])
{
s_init_list(l);
int i;
for (i = 0; i < MAX_NUM; i++)
{
nodes[i].next = NULL;
nodes[i].prev = NULL;
}
}
static void
init_list_(void)
{
init_list__(&lst, nodes);
}
static int
t_add_tail(void)
{
int i;
init_list_();
for (i = 0; i < MAX_NUM; i++)
{
s_add_tail(&lst, &nodes[i]);
bt_debug(".");
bt_assert(lst.tail == &nodes[i]);
bt_assert(lst.head == &nodes[0]);
bt_assert((void *) nodes[i].next == (void *) &lst.null);
if (i > 0)
{
bt_assert(nodes[i-1].next == &nodes[i]);
bt_assert(nodes[i].prev == &nodes[i-1]);
}
}
bt_assert(is_filled_list_well_linked());
return 1;
}
static int
t_add_head(void)
{
int i;
init_list_();
for (i = MAX_NUM-1; i >= 0; i--)
{
s_add_head(&lst, &nodes[i]);
bt_debug(".");
bt_assert(lst.head == &nodes[i]);
bt_assert(lst.tail == &nodes[MAX_NUM-1]);
if (i < MAX_NUM-1)
{
bt_assert(nodes[i+1].prev == &nodes[i]);
bt_assert(nodes[i].next == &nodes[i+1]);
}
}
bt_assert(is_filled_list_well_linked());
return 1;
}
static void
insert_node_(snode *n, snode *after)
{
s_insert_node(n, after);
bt_debug(".");
}
static int
t_insert_node(void)
{
int i;
init_list_();
// add first node
insert_node_(&nodes[0], SNODE &lst.head);
// add odd nodes
for (i = 2; i < MAX_NUM; i+=2)
insert_node_(&nodes[i], &nodes[i-2]);
// add even nodes
for (i = 1; i < MAX_NUM; i+=2)
insert_node_(&nodes[i], &nodes[i-1]);
bt_debug("\n");
bt_assert(is_filled_list_well_linked());
return 1;
}
static void
fill_list2(slist *l, snode nodes[])
{
int i;
for (i = 0; i < MAX_NUM; i++)
s_add_tail(l, &nodes[i]);
}
static void
fill_list(void)
{
fill_list2(&lst, SNODE nodes);
}
static int
t_remove_node(void)
{
int i;
init_list_();
/* Fill & Remove & Check */
fill_list();
for (i = 0; i < MAX_NUM; i++)
s_rem_node(&nodes[i]);
bt_assert(is_empty_list_well_unlinked());
/* Fill & Remove the half of nodes & Check & Remove the rest nodes & Check */
fill_list();
for (i = 0; i < MAX_NUM; i+=2)
s_rem_node(&nodes[i]);
int tail_node_index = (MAX_NUM % 2) ? MAX_NUM - 2 : MAX_NUM - 1;
bt_assert(lst.head == &nodes[1]);
bt_assert(lst.tail == &nodes[tail_node_index]);
bt_assert(nodes[tail_node_index].next == SNODE &lst.null);
for (i = 1; i < MAX_NUM; i+=2)
{
if (i > 1)
bt_assert(nodes[i].prev == &nodes[i-2]);
if (i < tail_node_index)
bt_assert(nodes[i].next == &nodes[i+2]);
}
for (i = 1; i < MAX_NUM; i+=2)
s_rem_node(&nodes[i]);
bt_assert(is_empty_list_well_unlinked());
return 1;
}
static int
t_add_tail_list(void)
{
snode nodes2[MAX_NUM];
slist l2;
init_list__(&lst, SNODE &nodes);
fill_list2(&lst, SNODE &nodes);
init_list__(&l2, SNODE &nodes2);
fill_list2(&l2, SNODE &nodes2);
s_add_tail_list(&lst, &l2);
bt_assert(nodes[MAX_NUM-1].next == &nodes2[0]);
bt_assert(nodes2[0].prev == &nodes[MAX_NUM-1]);
bt_assert(lst.tail == &nodes2[MAX_NUM-1]);
return 1;
}
void
dump(const char *str, slist *a)
{
snode *x;
bt_debug("%s \n", str);
for (x = SHEAD(*a); x; x = x->next)
{
siterator *i, *j;
bt_debug("%p", x);
j = (siterator *) x;
for (i = x->readers; i; i = i->next)
{
if (i->prev != j)
bt_debug(" ???");
j = i;
bt_debug(" [%p:%p]", i, i->node);
}
bt_debug("\n");
}
bt_debug("---\n");
}
static int
t_iterator_walk(void)
{
snode *node;
siterator iter;
init_list_();
fill_list();
int k;
int i = 0;
show_list();
s_init(&iter, &lst);
WALK_SLIST(node, lst)
{
s_get(&iter);
s_put(&iter, node);
bt_debug("node->readers: %p, iter: %p, nodes[%d].readers: %p, node: %p, nodes[i]: %p, node->next: %p \n",
node->readers, &iter, i, nodes[i].readers, node, &(nodes[i]), node->next);
bt_assert(node->readers == &iter);
bt_assert(node->readers == nodes[i].readers);
bt_assert(node == &(nodes[i]));
for (k = 0; k < MAX_NUM; k++)
if (k != i)
bt_assert(nodes[k].readers == NULL);
dump("",&lst);
i++;
}
return 1;
}
static int
t_original(void)
{
slist a, b;
snode *x, *y;
siterator i, j;
s_init_list(&a);
s_init_list(&b);
x = xmalloc(sizeof(*x));
s_add_tail(&a, x);
x = xmalloc(sizeof(*x));
s_add_tail(&a, x);
x = xmalloc(sizeof(*x));
s_add_tail(&a, x);
dump("1", &a);
s_init(&i, &a);
s_init(&j, &a);
dump("2", &a);
x = s_get(&i);
bt_debug("Got %p\n", x);
dump("3", &a);
s_put(&i, x->next);
dump("4", &a);
y = s_get(&j);
while (y)
{
s_put(&j, y);
dump("5*", &a);
y = s_get(&j)->next;
}
dump("5 done", &a);
s_rem_node(a.head->next);
dump("6 (deletion)", &a);
s_put(&i, s_get(&i)->next);
dump("6 (relink)", &a);
x = xmalloc(sizeof(*x));
s_add_tail(&b, x);
dump("7 (second list)", &b);
s_add_tail_list(&b, &a);
dump("8 (after merge)", &b);
return 1;
}
static int
t_safe_del_walk(void)
{
init_list_();
fill_list();
show_list();
snode *node, *node_next;
WALK_SLIST_DELSAFE(node,node_next, lst)
{
bt_debug("Will remove node %p \n", node);
s_rem_node(SNODE node);
}
bt_assert(is_empty_list_well_unlinked());
return 1;
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_add_tail, "Adding nodes to tail of list");
bt_test_suite(t_add_head, "Adding nodes to head of list");
bt_test_suite(t_insert_node, "Inserting nodes to list");
bt_test_suite(t_remove_node, "Removing nodes from list");
bt_test_suite(t_add_tail_list, "At the tail of a list adding the another list");
bt_test_suite(t_iterator_walk, "Iterator walk");
bt_test_suite(t_safe_del_walk, "WALK_SLIST_DELSAFE and s_rem_node all nodes");
bt_test_suite(t_original, "The original BIRD test suit for SLIST");
return bt_exit_value();
}
bird2-2.17.5/lib/slists.c 0000664 0000000 0000000 00000004362 15211753245 0015055 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Safe Linked Lists
*
* (c) 1998 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#define _BIRD_SLISTS_C_
#include "nest/bird.h"
#include "lib/slists.h"
static inline void
s_merge(snode *from, snode *to)
{
siterator *f, *g;
if (!(f = from->readers))
return;
if (!(g = to->readers))
{
/* Fast path */
to->readers = f;
f->prev = (siterator *) to;
fixup:
while (f && f->node)
{
f->node = NULL;
f = f->next;
}
return;
}
/* Really merging */
while (g->next)
g = g->next;
g->next = f;
f->prev = g;
goto fixup;
}
snode *
s_get(siterator *i)
{
siterator *f, *g;
snode *n;
if (!(n = i->node))
{
/*
* No node found. We have to walk the iterator list backwards
* to find where are we linked.
*/
f = i;
while (!f->null)
f = f->prev;
n = (snode *) f;
}
f = i->prev; /* Maybe the snode itself */
g = i->next;
f->next = g;
if (g)
g->prev = f;
i->prev = NULL;
i->next = NULL;
return n;
}
void
s_put(siterator *i, snode *n)
{
siterator *f;
i->node = n;
if (f = n->readers)
f->prev = i;
i->next = f;
n->readers = i;
i->prev = (siterator *) n;
i->null = NULL;
}
void
s_add_tail(slist *l, snode *n)
{
snode *z = l->tail;
n->next = (snode *) &l->null;
n->prev = z;
z->next = n;
l->tail = n;
n->readers = NULL;
}
void
s_add_head(slist *l, snode *n)
{
snode *z = l->head;
n->next = z;
n->prev = (snode *) &l->head;
z->prev = n;
l->head = n;
n->readers = NULL;
}
void
s_insert_node(snode *n, snode *after)
{
snode *z = after->next;
n->next = z;
n->prev = after;
after->next = n;
z->prev = n;
n->readers = NULL;
}
void
s_rem_node(snode *n)
{
snode *z = n->prev;
snode *x = n->next;
z->next = x;
x->prev = z;
s_merge(n, x);
}
void
s_init_list(slist *l)
{
l->head = (snode *) &l->null;
l->null = NULL;
l->tail = (snode *) &l->head;
l->tail_readers = NULL;
}
void
s_add_tail_list(slist *to, slist *l)
{
snode *p = to->tail;
snode *q = l->head;
p->next = q;
q->prev = p;
q = l->tail;
q->next = (snode *) &to->null;
to->tail = q;
s_merge((snode *) &l->null, (snode *) &to->null);
}
bird2-2.17.5/lib/slists.h 0000664 0000000 0000000 00000005263 15211753245 0015063 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Safe Linked Lists
*
* (c) 1998 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_SLISTS_H_
#define _BIRD_SLISTS_H_
/*
* These linked lists work in a way similar to standard lists defined
* in lib/lists.h, but in addition to all usual list functions they
* provide fast deletion/insertion/everything-safe asynchronous
* walking.
*
* Example:
* slist l;
* siterator i;
* snode *n;
*
* s_init(&i, &l); // Initialize iteration
* ...
* n = s_get(&i); // Some time later, fetch present
* // value of the iterator and unlink it
* // from the list.
* while (n->next) {
* ...
* if (decided_to_stop) {
* s_put(&i, n); // Store current position (maybe even
* // that we stay at list end)
* return; // and return
* }
* ...
* }
* // After finishing, don't link the iterator back
*/
typedef struct snode {
struct snode *next, *prev;
struct siterator *readers;
} snode;
typedef struct slist { /* In fact two overlayed snodes */
struct snode *head, *null, *tail;
struct siterator *tail_readers;
} slist;
typedef struct siterator {
/*
* Caution: Layout of this structure depends hard on layout of the
* snode. Our `next' must be at position of snode `readers'
* field, our `null' must be at position of `prev' and it must
* contain NULL in order to distinguish between siterator
* and snode (snodes with NULL `prev' field never carry
* iterators). You are not expected to understand this.
*/
struct siterator *prev, *null, *next;
/*
* For recently merged nodes this can be NULL, but then it's NULL
* for all successors as well. This is done to speed up iterator
* merging when there are lots of deletions.
*/
snode *node;
} siterator;
#define SNODE (snode *)
#define SHEAD(list) ((void *)((list).head))
#define STAIL(list) ((void *)((list).tail))
#define SNODE_NEXT(n) ((void *)((SNODE (n))->next))
#define SNODE_VALID(n) ((SNODE (n))->next)
#define WALK_SLIST(n,list) for(n=SHEAD(list); SNODE_VALID(n); n=SNODE_NEXT(n))
#define WALK_SLIST_DELSAFE(n,nxt,list) \
for(n=SHEAD(list); nxt=SNODE_NEXT(n); n=(void *) nxt)
#define EMPTY_SLIST(list) (!(list).head->next)
void s_add_tail(slist *, snode *);
void s_add_head(slist *, snode *);
void s_rem_node(snode *);
void s_add_tail_list(slist *, slist *);
void s_init_list(slist *);
void s_insert_node(snode *, snode *);
snode *s_get(siterator *);
void s_put(siterator *, snode *n);
static inline void s_init(siterator *i, slist *l) { s_put(i, SHEAD(*l)); }
static inline int s_is_used(siterator *i) { return (i->prev != NULL); }
#endif
bird2-2.17.5/lib/socket.h 0000664 0000000 0000000 00000021122 15211753245 0015022 0 ustar 00root root 0000000 0000000 /*
* BIRD Socket Interface
*
* (c) 1998--2004 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_SOCKET_H_
#define _BIRD_SOCKET_H_
#include
#include "lib/resource.h"
#ifdef HAVE_LIBSSH
#define LIBSSH_LEGACY_0_4
#include
#endif
#ifdef HAVE_LIBSSH
struct ssh_sock {
const char *username; /* (Required) SSH user name */
const char *server_hostkey_path; /* (Optional) Filepath to the SSH public key of remote side, can be knownhost file */
const char *client_privkey_path; /* (Optional) Filepath to the SSH private key of BIRD */
const char *subsystem; /* (Optional) Name of SSH subsytem */
ssh_session session; /* Internal */
ssh_channel channel; /* Internal */
int state; /* Internal */
#define SK_SSH_CONNECT 0 /* Start state */
#define SK_SSH_SERVER_KNOWN 1 /* Internal */
#define SK_SSH_USERAUTH 2 /* Internal */
#define SK_SSH_CHANNEL 3 /* Internal */
#define SK_SSH_SESSION 4 /* Internal */
#define SK_SSH_SUBSYSTEM 5 /* Internal */
#define SK_SSH_ESTABLISHED 6 /* Final state */
};
#endif
struct ao_key
{
int send_id;
int recv_id;
const char *key;
uint keylen;
int algorithm;
int preference;
};
struct ao_config
{
struct ao_key key;
struct ao_config *next;
};
struct ao_info
{
int current_key;
int rnext_key;
u64 pkt_good;
u64 pkt_bad;
};
#define AO_MAX_KEY_LENGTH 80 /* See sysdep/linux/tcp-ao.h */
typedef struct birdsock {
resource r;
pool *pool; /* Pool where incoming connections should be allocated (for SK_xxx_PASSIVE) */
int type; /* Socket type */
int subtype; /* Socket subtype */
void *data; /* User data */
ip_addr saddr, daddr; /* IPA_NONE = unspecified */
const char *host; /* Alternative to daddr, NULL = unspecified */
uint sport, dport; /* 0 = unspecified (for IP: protocol type) */
int tos; /* TOS / traffic class, -1 = default */
int priority; /* Local socket priority, -1 = default */
int ttl; /* Time To Live, -1 = default */
u32 flags;
struct iface *iface; /* Interface; specify this for broad/multicast sockets */
struct iface *vrf; /* Related VRF instance, NULL if global */
byte *rbuf, *rpos; /* NULL=allocate automatically */
uint fast_rx; /* RX has higher priority in event loop */
uint rbsize;
int (*rx_hook)(struct birdsock *, uint size); /* NULL=receiving turned off, returns 1 to clear rx buffer */
byte *tbuf, *tpos; /* NULL=allocate automatically */
byte *ttx; /* Internal */
uint tbsize;
void (*tx_hook)(struct birdsock *);
void (*err_hook)(struct birdsock *, int); /* errno or zero if EOF */
/* Information about received datagrams (UDP, RAW), valid in rx_hook */
ip_addr faddr, laddr; /* src (From) and dst (Local) address of the datagram */
uint fport; /* src port of the datagram */
uint lifindex; /* local interface that received the datagram */
/* laddr and lifindex are valid only if SKF_LADDR_RX flag is set to request it */
int af; /* System-dependend adress family (e.g. AF_INET) */
int fd; /* System-dependent data */
int index; /* Index in poll buffer */
int rcv_ttl; /* TTL of last received datagram */
node n;
void *rbuf_alloc, *tbuf_alloc;
const char *password; /* Password for MD5 authentication (for SK_TCP_ACTIVE) */
const struct ao_key **ao_keys_init; /* Keys for TCP-AO authentication (for SK_TCP_ACTIVE) */
int ao_keys_num; /* Number of keys in ao_keys_init */
// int use_ao; /* This is the only reliable flag saying whether the socket uses TCP-AO */
const char *err; /* Error message */
struct ssh_sock *ssh; /* Used in SK_SSH */
} sock;
sock *sock_new(pool *); /* Allocate new socket */
#define sk_new(X) sock_new(X) /* Wrapper to avoid name collision with OpenSSL */
int sk_open(sock *); /* Open socket */
int sk_rx_ready(sock *s);
int sk_send(sock *, uint len); /* Send data, <0=err, >0=ok, 0=sleep */
int sk_send_to(sock *, uint len, ip_addr to, uint port); /* sk_send to given destination */
void sk_reallocate(sock *); /* Free and allocate tbuf & rbuf */
void sk_set_rbsize(sock *s, uint val); /* Resize RX buffer */
void sk_set_tbsize(sock *s, uint val); /* Resize TX buffer, keeping content */
void sk_set_tbuf(sock *s, void *tbuf); /* Switch TX buffer, NULL-> return to internal */
void sk_dump_all(struct dump_request *);
void sk_dump_ao_all(struct dump_request *);
int sk_is_ipv4(sock *s); /* True if socket is IPv4 */
int sk_is_ipv6(sock *s); /* True if socket is IPv6 */
static inline int sk_tx_buffer_empty(sock *sk)
{ return sk->tbuf == sk->tpos; }
int sk_setup_multicast(sock *s); /* Prepare UDP or IP socket for multicasting */
int sk_join_group(sock *s, ip_addr maddr); /* Join multicast group on sk iface */
int sk_leave_group(sock *s, ip_addr maddr); /* Leave multicast group on sk iface */
int sk_setup_broadcast(sock *s);
int sk_set_ttl(sock *s, int ttl); /* Set transmit TTL for given socket */
int sk_set_min_ttl(sock *s, int ttl); /* Set minimal accepted TTL for given socket */
int sk_set_md5_auth(sock *s, ip_addr local, ip_addr remote, int pxlen, struct iface *ifa, const char *passwd, int setkey);
bool tcp_ao_alg_known(int algorithm);
int sk_get_ao_info(sock *s, struct ao_info *val);
int sk_get_active_ao_keys(sock *s, int *current_key, int *rnext_key);
int sk_add_ao_key(sock *s, ip_addr prefix, int pxlen, struct iface *ifa, const struct ao_key *key, bool current, bool rnext);
int sk_delete_ao_key(sock *s, ip_addr prefix, int pxlen, struct iface *ifa, const struct ao_key *key, const struct ao_key *current, const struct ao_key *rnext);
int sk_set_rnext_ao_key(sock *s, const struct ao_key *key);
int sk_check_ao_keys(sock *s, const struct ao_key **keys, int num, const char *name);
void sk_dump_ao_info(sock *s, struct dump_request *dreq);
void sk_dump_ao_keys(sock *s, struct dump_request *dreq);
int sk_set_ipv6_checksum(sock *s, int offset);
int sk_set_icmp6_filter(sock *s, int p1, int p2);
void sk_log_error(sock *s, const char *p);
byte * sk_rx_buffer(sock *s, int *len); /* Temporary */
extern int sk_priority_control; /* Suggested priority for control traffic, should be sysdep define */
/* Socket flags */
#define SKF_V6ONLY 0x02 /* Use IPV6_V6ONLY socket option */
#define SKF_LADDR_RX 0x04 /* Report local address for RX packets */
#define SKF_TTL_RX 0x08 /* Report TTL / Hop Limit for RX packets */
#define SKF_BIND 0x10 /* Bind datagram socket to given source address */
#define SKF_HIGH_PORT 0x20 /* Choose port from high range if possible */
#define SKF_FREEBIND 0x40 /* Allow socket to bind to a nonlocal address */
#define SKF_CONNECT 0x80 /* Connect datagram socket to given dst address/port */
#define SKF_THREAD 0x100 /* Socked used in thread, Do not add to main loop */
#define SKF_TRUNCATED 0x200 /* Received packet was truncated, set by IO layer */
#define SKF_HDRINCL 0x400 /* Used internally */
#define SKF_PKTINFO 0x800 /* Used internally */
#define SKF_UDP6_NO_CSUM_RX 0x1000 /* Accept zero checksums for received UDPv6 packets */
/*
* Socket types SA SP DA DP IF TTL SendTo (?=may, -=must not, *=must)
*/
#define SK_TCP_PASSIVE 0 /* ? * - - - ? - */
#define SK_TCP_ACTIVE 1 /* ? ? * * - ? - */
#define SK_TCP 2
#define SK_UDP 3 /* ? ? ? ? ? ? ? */
#define SK_IP 5 /* ? - ? * ? ? ? */
#define SK_MAGIC 7 /* Internal use by sysdep code */
#define SK_UNIX_PASSIVE 8
#define SK_UNIX 9
#define SK_SSH_ACTIVE 10 /* - - * * - ? - DA = host */
#define SK_SSH 11
/*
* Socket subtypes
*/
#define SK_IPV4 1
#define SK_IPV6 2
/*
* For TCP/IP sockets, Address family (IPv4 or IPv6) can be specified either
* explicitly (SK_IPV4 or SK_IPV6) or implicitly (based on saddr, daddr). But
* these specifications must be consistent.
*
* For SK_UDP or SK_IP sockets setting DA/DP allows to use sk_send(), otherwise
* sk_send_to() must be used.
*
* For SK_IP sockets setting DP specifies protocol number, which is used for
* both receiving and sending.
*
* For multicast on SK_UDP or SK_IP sockets set IF and TTL, call
* sk_setup_multicast() to enable multicast on that socket, and then use
* sk_join_group() and sk_leave_group() to manage a set of received multicast
* groups.
*
* For datagram (SK_UDP, SK_IP) sockets, there are two ways to handle source
* address. The socket could be bound to it using bind() syscall, but that also
* forbids the reception of multicast packets, or the address could be set on
* per-packet basis using platform dependent options (but these are not
* available in some corner cases). The first way is used when SKF_BIND is
* specified, the second way is used otherwise.
*/
#endif
bird2-2.17.5/lib/string.h 0000664 0000000 0000000 00000004426 15211753245 0015050 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- String Functions
*
* (c) 1998 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_STRING_H_
#define _BIRD_STRING_H_
#include
#include
#include
#include "lib/resource.h"
int bsprintf(char *str, const char *fmt, ...);
int bvsprintf(char *str, const char *fmt, va_list args);
int bsnprintf(char *str, int size, const char *fmt, ...) ACCESS_WRITE(1, 2);
int bvsnprintf(char *str, int size, const char *fmt, va_list args) ACCESS_WRITE(1, 2);
char *mb_sprintf(pool *p, const char *fmt, ...);
char *mb_vsprintf(pool *p, const char *fmt, va_list args);
char *lp_sprintf(linpool *p, const char *fmt, ...);
char *lp_vsprintf(linpool *p, const char *fmt, va_list args);
#define tmp_sprintf(...) lp_sprintf(tmp_linpool, __VA_ARGS__)
#define tmp_vsprintf(...) lp_vsprintf(tmp_linpool, __VA_ARGS__)
int buffer_vprint(buffer *buf, const char *fmt, va_list args);
int buffer_print(buffer *buf, const char *fmt, ...);
void buffer_puts(buffer *buf, const char *str);
u64 bstrtoul10(const char *str, char **end);
u64 bstrtoul16(const char *str, char **end);
byte bstrtobyte16(const char *str);
char *fmt_order(u64 value, uint decimals, u64 kb_threshold);
int bstrhextobin(const char *s, byte *b);
int bstrbintohex(const byte *b, size_t len, char *buf, size_t size, char delim) ACCESS_READ(1, 2) ACCESS_WRITE(3, 4);
int patmatch(const byte *pat, const byte *str);
static inline char *xbasename(const char *str)
{
char *s = strrchr(str, '/');
return s ? s+1 : (char *) str;
}
static inline char *
xstrdup(const char *c)
{
size_t l = strlen(c) + 1;
char *z = xmalloc(l);
memcpy(z, c, l);
return z;
}
static inline char *
lp_strdup(linpool *lp, const char *c)
{
size_t l = strlen(c) + 1;
char *z = lp_allocu(lp, l);
memcpy(z, c, l);
return z;
}
static inline void
memset32(void *D, u32 val, uint n)
{
u32 *dst = D;
uint i;
for (i = 0; i < n; i++)
dst[i] = val;
}
static inline int
bstrcmp(const char *s1, const char *s2)
{
if (s1 && s2)
return strcmp(s1, s2);
else
return !s2 - !s1;
}
static inline void *
bmemcpy(void *dest, const void *src, size_t n)
{
if (n)
return memcpy(dest, src, n);
else
return dest;
}
#define ROUTER_ID_64_LENGTH 23
#endif
bird2-2.17.5/lib/strtoul.c 0000664 0000000 0000000 00000004356 15211753245 0015253 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Parse numbers
*
* (c) 2019 Maria Matejka
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "nest/bird.h"
#include "lib/string.h"
#include
#define ULI_MAX_DIV10 (UINT64_MAX / 10)
#define ULI_MAX_MOD10 (UINT64_MAX % 10)
u64
bstrtoul10(const char *str, char **end)
{
u64 out = 0;
for (*end = (char *) str; (**end >= '0') && (**end <= '9'); (*end)++) {
u64 digit = **end - '0';
if ((out > ULI_MAX_DIV10) ||
(out == ULI_MAX_DIV10) && (digit > ULI_MAX_MOD10)) {
errno = ERANGE;
return UINT64_MAX;
}
out *= 10;
out += (**end) - '0';
}
return out;
}
u64
bstrtoul16(const char *str, char **end)
{
u64 out = 0;
for (int i=0; i<=(64/4); i++) {
switch (str[i]) {
case '0' ... '9':
out *= 16;
out += str[i] - '0';
break;
case 'a' ... 'f':
out *= 16;
out += str[i] + 10 - 'a';
break;
case 'A' ... 'F':
out *= 16;
out += str[i] + 10 - 'A';
break;
default:
*end = (char *) &(str[i]);
return out;
}
}
errno = ERANGE;
return UINT64_MAX;
}
static int
fromxdigit(char c)
{
switch (c)
{
case '0' ... '9':
return c - '0';
case 'a' ... 'f':
return c + 10 - 'a';
case 'A' ... 'F':
return c + 10 - 'A';
default:
return -1;
}
}
int
bstrhextobin(const char *s, byte *b)
{
int len = 0;
int hi = 0;
for (; *s; s++)
{
int v = fromxdigit(*s);
if (v < 0)
{
if (strchr(" -.:", *s) && !hi)
continue;
else
return -1;
}
if (len == INT32_MAX)
return -1;
if (b)
{
if (!hi)
b[len] = (v << 4);
else
b[len] |= v;
}
len += hi;
hi = !hi;
}
return !hi ? len : -1;
}
static char
toxdigit(uint b)
{
if (b < 10)
return ('0' + b);
else if (b < 16)
return ('a' + b - 10);
else
return 0;
}
int
bstrbintohex(const byte *b, size_t len, char *buf, size_t size, char delim)
{
ASSERT(size >= 6);
char *bound = buf + size - 3;
size_t i;
for (i = 0; i < len; i++)
{
if (buf > bound)
{
strcpy(buf - 4, "...");
return -1;
}
uint x = b[i];
buf[0] = toxdigit(x >> 4);
buf[1] = toxdigit(x & 0xF);
buf[2] = delim;
buf += 3;
}
buf[i ? -1 : 0] = 0;
return 0;
}
bird2-2.17.5/lib/tbf.c 0000664 0000000 0000000 00000001170 15211753245 0014301 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Token Bucket Filter
*
* (c) 2014 Ondrej Zajicek
* (c) 2014 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "nest/bird.h"
#include "lib/timer.h"
int
tbf_limit(struct tbf *f)
{
btime delta = current_time() - f->timestamp;
if (delta > 0)
{
u64 next = f->count + delta * f->rate;
u64 burst = (u64) f->burst << 20;
f->count = MIN(next, burst);
f->timestamp += delta;
}
if (f->count < 1000000)
{
f->drop++;
return 1;
}
else
{
f->count -= 1000000;
f->drop = 0;
return 0;
}
}
bird2-2.17.5/lib/timer.c 0000664 0000000 0000000 00000017565 15211753245 0014665 0 ustar 00root root 0000000 0000000 /*
* BIRD -- Timers
*
* (c) 2013--2017 Ondrej Zajicek
* (c) 2013--2017 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
/**
* DOC: Timers
*
* Timers are resources which represent a wish of a module to call a function at
* the specified time. The timer code does not guarantee exact timing, only that
* a timer function will not be called before the requested time.
*
* In BIRD, time is represented by values of the &btime type which is signed
* 64-bit integer interpreted as a relative number of microseconds since some
* fixed time point in past. The current time can be obtained by current_time()
* function with reasonable accuracy and is monotonic. There is also a current
* 'wall-clock' real time obtainable by current_real_time() reported by OS.
*
* Each timer is described by a &timer structure containing a pointer to the
* handler function (@hook), data private to this function (@data), time the
* function should be called at (@expires, 0 for inactive timers), for the other
* fields see |timer.h|.
*/
#include
#include
#include
#include "nest/bird.h"
#include "lib/heap.h"
#include "lib/resource.h"
#include "lib/timer.h"
struct timeloop main_timeloop;
#ifdef USE_PTHREADS
#include
/* Data accessed and modified from proto/bfd/io.c */
pthread_key_t current_time_key;
static inline struct timeloop *
timeloop_current(void)
{
return pthread_getspecific(current_time_key);
}
static inline void
timeloop_init_current(void)
{
pthread_key_create(¤t_time_key, NULL);
pthread_setspecific(current_time_key, &main_timeloop);
}
void wakeup_kick_current(void);
#else
/* Just use main timelooop */
static inline struct timeloop * timeloop_current(void) { return &main_timeloop; }
static inline void timeloop_init_current(void) { }
#endif
btime
current_time(void)
{
return timeloop_current()->last_time;
}
btime
current_real_time(void)
{
struct timeloop *loop = timeloop_current();
if (!loop->real_time)
times_update_real_time(loop);
return loop->real_time;
}
#define TIMER_LESS(a,b) ((a)->expires < (b)->expires)
#define TIMER_SWAP(heap,a,b,t) (t = heap[a], heap[a] = heap[b], heap[b] = t, \
heap[a]->index = (a), heap[b]->index = (b))
static void
tm_free(resource *r)
{
timer *t = (void *) r;
tm_stop(t);
}
static void
tm_dump(struct dump_request *dreq, resource *r)
{
timer *t = (void *) r;
RDUMP("(code %p, data %p, ", t->hook, t->data);
if (t->randomize)
RDUMP("rand %d, ", t->randomize);
if (t->recurrent)
RDUMP("recur %ld, ", t->recurrent);
if (t->expires)
RDUMP("expires in %ld ms)\n", (t->expires - current_time()) TO_MS);
else
RDUMP("inactive)\n");
}
static struct resclass tm_class = {
"Timer",
sizeof(timer),
tm_free,
tm_dump,
NULL,
NULL
};
timer *
tm_new(pool *p)
{
timer *t = ralloc(p, &tm_class);
t->index = -1;
return t;
}
void
tm_set(timer *t, btime when)
{
struct timeloop *loop = timeloop_current();
uint tc = timers_count(loop);
if (!t->expires)
{
t->index = ++tc;
t->expires = when;
BUFFER_PUSH(loop->timers) = t;
HEAP_INSERT(loop->timers.data, tc, timer *, TIMER_LESS, TIMER_SWAP);
}
else if (t->expires < when)
{
t->expires = when;
HEAP_INCREASE(loop->timers.data, tc, timer *, TIMER_LESS, TIMER_SWAP, t->index);
}
else if (t->expires > when)
{
t->expires = when;
HEAP_DECREASE(loop->timers.data, tc, timer *, TIMER_LESS, TIMER_SWAP, t->index);
}
#ifdef CONFIG_BFD
/* Hack to notify BFD loops */
if ((loop != &main_timeloop) && (t->index == 1))
wakeup_kick_current();
#endif
}
void
tm_start(timer *t, btime after)
{
tm_set(t, current_time() + MAX(after, 0));
}
void
tm_stop(timer *t)
{
if (!t->expires)
return;
struct timeloop *loop = timeloop_current();
uint tc = timers_count(loop);
HEAP_DELETE(loop->timers.data, tc, timer *, TIMER_LESS, TIMER_SWAP, t->index);
BUFFER_POP(loop->timers);
t->index = -1;
t->expires = 0;
}
void
timers_init(struct timeloop *loop, pool *p)
{
times_init(loop);
BUFFER_INIT(loop->timers, p, 4);
BUFFER_PUSH(loop->timers) = NULL;
}
void io_log_event(void *hook, void *data);
void
timers_fire(struct timeloop *loop)
{
btime base_time;
timer *t;
times_update(loop);
base_time = loop->last_time;
while (t = timers_first(loop))
{
if (t->expires > base_time)
return;
if (t->recurrent)
{
btime when = t->expires + t->recurrent;
if (when <= loop->last_time)
when = loop->last_time + t->recurrent;
if (t->randomize)
when += random() % (t->randomize + 1);
tm_set(t, when);
}
else
tm_stop(t);
/* This is ugly hack, we want to log just timers executed from the main I/O loop */
if (loop == &main_timeloop)
io_log_event(t->hook, t->data);
t->hook(t);
tmp_flush();
}
}
void
timer_init(void)
{
timers_init(&main_timeloop, &root_pool);
timeloop_init_current();
}
/**
* tm_parse_time - parse a date and time
* @x: time string
*
* tm_parse_time() takes a textual representation of a date and time
* (yyyy-mm-dd[ hh:mm:ss[.sss]]) and converts it to the corresponding value of
* type &btime.
*/
btime
tm_parse_time(const char *x)
{
struct tm tm = {};
int usec, n1, n2, n3, r;
r = sscanf(x, "%d-%d-%d%n %d:%d:%d%n.%d%n",
&tm.tm_year, &tm.tm_mon, &tm.tm_mday, &n1,
&tm.tm_hour, &tm.tm_min, &tm.tm_sec, &n2,
&usec, &n3);
if ((r == 3) && !x[n1])
tm.tm_hour = tm.tm_min = tm.tm_sec = usec = 0;
else if ((r == 6) && !x[n2])
usec = 0;
else if ((r == 7) && !x[n3])
{
/* Convert subsecond digits to proper precision */
int digits = n3 - n2 - 1;
if ((usec < 0) || (usec > 999999) || (digits < 1) || (digits > 6))
return 0;
while (digits++ < 6)
usec *= 10;
}
else
return 0;
tm.tm_mon--;
tm.tm_year -= 1900;
s64 ts = mktime(&tm);
if ((ts == (s64) (time_t) -1) || (ts < 0) || (ts > ((s64) 1 << 40)))
return 0;
return ts S + usec;
}
/**
* tm_format_time - convert date and time to textual representation
* @x: destination buffer of size %TM_DATETIME_BUFFER_SIZE
* @fmt: specification of resulting textual representation of the time
* @t: time
*
* This function formats the given relative time value @t to a textual
* date/time representation (dd-mm-yyyy hh:mm:ss) in real time.
*/
void
tm_format_time(char *x, struct timeformat *fmt, btime t)
{
btime dt = current_time() - t;
btime rt = current_real_time() - dt;
int v1 = !fmt->limit || (dt < fmt->limit);
if (!tm_format_real_time(x, TM_DATETIME_BUFFER_SIZE, v1 ? fmt->fmt1 : fmt->fmt2, rt))
strcpy(x, "");
}
/* Replace %f in format string with usec scaled to requested precision */
static int
strfusec(char *buf, int size, const char *fmt, uint usec)
{
char *str = buf;
int parity = 0;
while (*fmt)
{
if (!size)
return 0;
if ((fmt[0] == '%') && (!parity) &&
((fmt[1] == 'f') || (fmt[1] >= '1') && (fmt[1] <= '6') && (fmt[2] == 'f')))
{
int digits = (fmt[1] == 'f') ? 6 : (fmt[1] - '0');
uint d = digits, u = usec;
/* Convert microseconds to requested precision */
while (d++ < 6)
u /= 10;
int num = bsnprintf(str, size, "%0*u", digits, u);
if (num < 0)
return 0;
fmt += (fmt[1] == 'f') ? 2 : 3;
ADVANCE(str, size, num);
}
else
{
/* Handle '%%' expression */
parity = (*fmt == '%') ? !parity : 0;
*str++ = *fmt++;
size--;
}
}
if (!size)
return 0;
*str = 0;
return str - buf;
}
int
tm_format_real_time(char *x, size_t max, const char *fmt, btime t)
{
s64 t1 = t TO_S;
s64 t2 = t - t1 S;
time_t ts = t1;
struct tm tm;
if (!localtime_r(&ts, &tm))
return 0;
size_t tbuf_size = MIN(max, 4096);
byte *tbuf = alloca(tbuf_size);
if (!strfusec(tbuf, tbuf_size, fmt, t2))
return 0;
if (!strftime(x, max, tbuf, &tm))
return 0;
return 1;
}
bird2-2.17.5/lib/timer.h 0000664 0000000 0000000 00000005600 15211753245 0014655 0 ustar 00root root 0000000 0000000 /*
* BIRD -- Timers
*
* (c) 2013--2017 Ondrej Zajicek
* (c) 2013--2017 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_TIMER_H_
#define _BIRD_TIMER_H_
#include "nest/bird.h"
#include "lib/buffer.h"
#include "lib/resource.h"
typedef struct timer
{
resource r;
void (*hook)(struct timer *);
void *data;
btime expires; /* 0=inactive */
btime recurrent; /* Timer recurrence */
uint randomize; /* Amount of randomization */
int index;
} timer;
struct timeloop
{
BUFFER_(timer *) timers;
btime last_time;
btime real_time;
};
static inline uint timers_count(struct timeloop *loop)
{ return loop->timers.used - 1; }
static inline timer *timers_first(struct timeloop *loop)
{ return (loop->timers.used > 1) ? loop->timers.data[1] : NULL; }
extern struct timeloop main_timeloop;
btime current_time(void);
btime current_real_time(void);
/* In sysdep code */
btime current_time_now(void);
//#define now (current_time() TO_S)
//#define now_real (current_real_time() TO_S)
extern btime boot_time;
timer *tm_new(pool *p);
void tm_set(timer *t, btime when);
void tm_start(timer *t, btime after);
void tm_stop(timer *t);
static inline int
tm_active(timer *t)
{
return t->expires != 0;
}
static inline btime
tm_remains(timer *t)
{
btime now_ = current_time();
return (t->expires > now_) ? (t->expires - now_) : 0;
}
static inline timer *
tm_new_init(pool *p, void (*hook)(struct timer *), void *data, btime rec, uint rand)
{
timer *t = tm_new(p);
t->hook = hook;
t->data = data;
t->recurrent = rec;
t->randomize = rand;
return t;
}
static inline void
tm_set_max(timer *t, btime when)
{
if (when > t->expires)
tm_set(t, when);
}
static inline void
tm_start_max(timer *t, btime after)
{
btime rem = tm_remains(t);
tm_start(t, MAX_(rem, after));
}
/* In sysdep code */
void times_init(struct timeloop *loop);
void times_update(struct timeloop *loop);
void times_update_real_time(struct timeloop *loop);
/* For I/O loop */
void timers_init(struct timeloop *loop, pool *p);
void timers_fire(struct timeloop *loop);
void timer_init(void);
struct timeformat {
const char *fmt1, *fmt2;
btime limit;
};
#define TM_ISO_SHORT_S (struct timeformat){"%T", "%F", (s64) (20*3600) S_}
#define TM_ISO_SHORT_MS (struct timeformat){"%T.%3f", "%F", (s64) (20*3600) S_}
#define TM_ISO_SHORT_US (struct timeformat){"%T.%6f", "%F", (s64) (20*3600) S_}
#define TM_ISO_LONG_S (struct timeformat){"%F %T", NULL, 0}
#define TM_ISO_LONG_MS (struct timeformat){"%F %T.%3f", NULL, 0}
#define TM_ISO_LONG_US (struct timeformat){"%F %T.%6f", NULL, 0}
#define TM_DATETIME_BUFFER_SIZE 32 /* Buffer size required by tm_format_time() */
btime tm_parse_time(const char *x);
void tm_format_time(char *x, struct timeformat *fmt, btime t);
int tm_format_real_time(char *x, size_t max, const char *fmt, btime t);
#endif
bird2-2.17.5/lib/tlists.h 0000664 0000000 0000000 00000014237 15211753245 0015065 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- Typed Linked Lists
*
* (c) 2022 Maria Matejka
*
* Can be freely distributed and used under the terms of the GNU GPL.
*
*
* This implementation of linked lists forces its members to be
* typed. On the other hand, it needs to be implemented as ugly macros to
* keep the needed genericity.
*
* Usage:
* 1. Include this file
* 2. Define the node structure
* 3. For every list type you need to define:
* A. #define TLIST_PREFIX and other macros
* B. Include this file once again
*
* Macros to define:
* TLIST_PREFIX: prefix to prepend to everything generated
* TLIST_TYPE: the actual node type
* TLIST_ITEM: where the tlist structure is
* TLIST_WANT_WALK: if defined, generates a helper functions for list walking macros
* TLIST_WANT_ADD_HEAD: if defined, TLIST_PREFIX_add_head() is generated to
* add an item to the beginning of the list
* TLIST_WANT_ADD_TAIL: if defined, TLIST_PREFIX_add_tail() is generated to
* add an item to the end of the list
*
* TLIST_PREFIX_rem_node() is generated always.
*
* All these macros are #undef-ed by including this file.
*
* Example:
*
* #include "lib/tlists.h"
*
* struct foo {
* ...
* TLIST_NODE(bar, struct foo) baz;
* ...
* };
*
* #define TLIST_PREFIX bar
* #define TLIST_TYPE struct foo
* #define TLIST_ITEM baz
*
* #define TLIST_WANT_WALK
* #define TLIST_WANT_ADD_HEAD
*
* #include "lib/tlists.h"
*
* ...
* (end of example)
*
*/
#ifdef _BIRD_LIB_TLISTS_H_
# ifdef TLIST_PREFIX
/* Check for mandatory arguments */
#ifndef TLIST_TYPE
#error "TLIST_TYPE must be defined"
#endif
#ifndef TLIST_ITEM
#error "TLIST_ITEM must be defined"
#endif
#ifndef TLIST_PREFIX
#error "TLIST_PREFIX must be defined"
#endif
#define TLIST_NAME(x) MACRO_CONCAT_AFTER(TLIST_PREFIX,_##x)
#ifndef TLIST_LIST_STRUCT
#define TLIST_LIST_STRUCT struct TLIST_NAME(list)
#endif
#ifndef TLIST_DEFINED_BEFORE
TLIST_STRUCT_DEF(TLIST_PREFIX, TLIST_TYPE);
#endif
static inline TLIST_LIST_STRUCT * TLIST_NAME(enlisted)(TLIST_TYPE *node)
{
return node->TLIST_ITEM.list;
}
#ifdef TLIST_WANT_WALK
static inline struct TLIST_NAME(node) * TLIST_NAME(node_get)(TLIST_TYPE *node)
{ return &(node->TLIST_ITEM); }
#endif
#if defined(TLIST_WANT_ADD_HEAD) || defined(TLIST_WANT_ADD_AFTER)
static inline void TLIST_NAME(add_head)(TLIST_LIST_STRUCT *list, TLIST_TYPE *node)
{
ASSERT_DIE(!TLIST_NAME(enlisted)(node));
node->TLIST_ITEM.list = list;
if (node->TLIST_ITEM.next = list->first)
list->first->TLIST_ITEM.prev = node;
else
list->last = node;
list->first = node;
}
#endif
#ifdef TLIST_WANT_ADD_TAIL
static inline void TLIST_NAME(add_tail)(TLIST_LIST_STRUCT *list, TLIST_TYPE *node)
{
ASSERT_DIE(!TLIST_NAME(enlisted)(node));
node->TLIST_ITEM.list = list;
if (node->TLIST_ITEM.prev = list->last)
list->last->TLIST_ITEM.next = node;
else
list->first = node;
list->last = node;
}
#endif
#ifdef TLIST_WANT_UPDATE_NODE
static inline void TLIST_NAME(update_node)(TLIST_LIST_STRUCT *list, TLIST_TYPE *node)
{
ASSERT_DIE(TLIST_NAME(enlisted)(node) == list);
if (node->TLIST_ITEM.prev)
node->TLIST_ITEM.prev->TLIST_ITEM.next = node;
else
list->first = node;
if (node->TLIST_ITEM.next)
node->TLIST_ITEM.next->TLIST_ITEM.prev = node;
else
list->last = node;
}
#endif
#ifdef TLIST_WANT_ADD_AFTER
static inline void TLIST_NAME(add_after)(TLIST_LIST_STRUCT *list, TLIST_TYPE *node, TLIST_TYPE *after)
{
ASSERT_DIE(!TLIST_NAME(enlisted)(node));
/* Adding to beginning */
if (!(node->TLIST_ITEM.prev = after))
return TLIST_NAME(add_head)(list, node);
/* OK, Adding after a real node */
node->TLIST_ITEM.list = list;
/* There is another node after the anchor */
if (node->TLIST_ITEM.next = after->TLIST_ITEM.next)
/* Link back */
node->TLIST_ITEM.next->TLIST_ITEM.prev = node;
else
/* Or we are adding the last node */
list->last = node;
/* Link forward from "after" */
after->TLIST_ITEM.next = node;
}
#endif
static inline void TLIST_NAME(rem_node)(TLIST_LIST_STRUCT *list, TLIST_TYPE *node)
{
ASSERT_DIE(TLIST_NAME(enlisted)(node) == list);
if (node->TLIST_ITEM.prev)
node->TLIST_ITEM.prev->TLIST_ITEM.next = node->TLIST_ITEM.next;
else
{
ASSERT_DIE(list->first == node);
list->first = node->TLIST_ITEM.next;
}
if (node->TLIST_ITEM.next)
node->TLIST_ITEM.next->TLIST_ITEM.prev = node->TLIST_ITEM.prev;
else
{
ASSERT_DIE(list->last == node);
list->last = node->TLIST_ITEM.prev;
}
node->TLIST_ITEM.next = node->TLIST_ITEM.prev = NULL;
node->TLIST_ITEM.list = NULL;
}
#undef TLIST_PREFIX
#undef TLIST_NAME
#undef TLIST_LIST_STRUCT
#undef TLIST_TYPE
#undef TLIST_ITEM
#undef TLIST_WANT_ADD_HEAD
#undef TLIST_WANT_ADD_TAIL
#undef TLIST_WANT_UPDATE_NODE
#undef TLIST_DEFINED_BEFORE
# endif
#else
#define _BIRD_LIB_TLISTS_H_
#include "lib/macro.h"
#if defined(TLIST_NAME) || defined(TLIST_PREFIX)
#error "You should first include lib/tlists.h without requesting a TLIST"
#endif
#define TLIST_LIST(_name) struct _name##_list
#define TLIST_STRUCT_DEF(_name, _type) TLIST_LIST(_name) { _type *first, *last; }
#define TLIST_NODE_IN(_name, _type) { _type *next; _type *prev; TLIST_LIST(_name) *list; }
#define TLIST_NODE(_name, _type) struct _name##_node TLIST_NODE_IN(_name, _type)
#define TLIST_DEFAULT_NODE struct MACRO_CONCAT_AFTER(TLIST_PREFIX,_node) \
TLIST_NODE_IN(TLIST_PREFIX,TLIST_TYPE) TLIST_ITEM
/* Use ->first and ->last to access HEAD and TAIL */
#define THEAD(_name, _list) (_list)->first
#define TTAIL(_name, _list) (_list)->last
/* Walkaround macros: simple and resilient to node removal */
#define WALK_TLIST(_name, _node, _list) \
for (typeof((_list)->first) _node = (_list)->first; \
_node; _node = _name##_node_get((_node))->next)
#define WALK_TLIST_DELSAFE(_name, _node, _list) \
for (typeof((_list)->first) _node = (_list)->first, \
_helper = _node ? _name##_node_get((_list)->first)->next : NULL; \
_node; \
(_node = _helper) ? (_helper = _name##_node_get(_helper)->next) : 0)
/* Empty check */
#define EMPTY_TLIST(_name, _list) (!(_list)->first)
/* List length */
#define TLIST_LENGTH(_name, _list) ({ uint _len = 0; WALK_TLIST(_name, _, _list) _len++; _len; })
#endif
bird2-2.17.5/lib/unaligned.h 0000664 0000000 0000000 00000004004 15211753245 0015500 0 ustar 00root root 0000000 0000000 /*
* Unaligned Data Accesses -- Generic Version, Network Order
*
* (c) 2000 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_UNALIGNED_H_
#define _BIRD_UNALIGNED_H_
/*
* We don't do any clever tricks with unaligned accesses since it's
* virtually impossible to figure out what alignment does the CPU want
* (unaligned accesses can be emulated by the OS which makes them work,
* but unusably slow). We use memcpy and hope GCC will optimize it out
* if possible.
*/
#include "sysdep/unix/endian.h"
#include "lib/string.h"
static inline u8
get_u8(const void *p)
{
return * (u8 *) p;
}
static inline u16
get_u16(const void *p)
{
u16 x;
memcpy(&x, p, 2);
return ntohs(x);
}
static inline u32
get_u24(const void *P)
{
const byte *p = P;
return (p[0] << 16) + (p[1] << 8) + p[2];
}
static inline u32
get_u32(const void *p)
{
u32 x;
memcpy(&x, p, 4);
return ntohl(x);
}
static inline u64
get_u64(const void *p)
{
u32 xh, xl;
memcpy(&xh, p, 4);
memcpy(&xl, p+4, 4);
return (((u64) ntohl(xh)) << 32) | ntohl(xl);
}
static inline void
put_u8(void *p, u8 x)
{
memcpy(p, &x, 1);
}
static inline void
put_u16(void *p, u16 x)
{
x = htons(x);
memcpy(p, &x, 2);
}
static inline void
put_u24(void *p, u32 x)
{
x = htonl(x);
memcpy(p, ((char *) &x) + 1, 3);
}
static inline void
put_u32(void *p, u32 x)
{
x = htonl(x);
memcpy(p, &x, 4);
}
static inline void
put_u64(void *p, u64 x)
{
u32 xh, xl;
xh = htonl(x >> 32);
xl = htonl((u32) x);
memcpy(p, &xh, 4);
memcpy(p+4, &xl, 4);
}
static inline void
get_u32s(const void *p, u32 *x, int n)
{
int i;
memcpy(x, p, 4*n);
for (i = 0; i < n; i++)
x[i] = ntohl(x[i]);
}
static inline void
put_u32s(void *p, const u32 *x, int n)
{
int i;
for (i = 0; i < n; i++)
put_u32((byte *) p + 4*i, x[i]);
}
static inline u32
get_u32he(const void *p)
{
u32 x;
memcpy(&x, p, 4);
return x;
}
static inline void
put_u32he(void *p, u32 x)
{
memcpy(p, &x, 4);
}
#endif
bird2-2.17.5/lib/xmalloc.c 0000664 0000000 0000000 00000002212 15211753245 0015163 0 ustar 00root root 0000000 0000000 /*
* BIRD Library -- malloc() With Checking
*
* (c) 1998--2000 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include
#include "nest/bird.h"
#include "lib/resource.h"
#ifndef HAVE_LIBDMALLOC
/**
* xmalloc - malloc with checking
* @size: block size
*
* This function is equivalent to malloc() except that in case of
* failure it calls die() to quit the program instead of returning
* a %NULL pointer.
*
* Wherever possible, please use the memory resources instead.
*/
void *
xmalloc(uint size)
{
void *p = malloc(size);
if (p)
return p;
die("Unable to allocate %d bytes of memory", size);
}
/**
* xrealloc - realloc with checking
* @ptr: original memory block
* @size: block size
*
* This function is equivalent to realloc() except that in case of
* failure it calls die() to quit the program instead of returning
* a %NULL pointer.
*
* Wherever possible, please use the memory resources instead.
*/
void *
xrealloc(void *ptr, uint size)
{
void *p = realloc(ptr, size);
if (p)
return p;
die("Unable to allocate %d bytes of memory", size);
}
#endif
bird2-2.17.5/misc/ 0000775 0000000 0000000 00000000000 15211753245 0013550 5 ustar 00root root 0000000 0000000 bird2-2.17.5/misc/Makefile 0000664 0000000 0000000 00000000110 15211753245 0015200 0 ustar 00root root 0000000 0000000 all: ips
ips: ips.c
gcc ips.c -o ips -lm -O2 -Wall
clean:
rm -f ips
bird2-2.17.5/misc/bird.init 0000775 0000000 0000000 00000003312 15211753245 0015357 0 ustar 00root root 0000000 0000000 #! /bin/sh
#
# bird Starts the Internet Routing Daemon.
#
# Author: Ondrej Feela Filip,
#
# chkconfig: - 32 75
# description: Internet routing daemon supporting IPv4 routing protocols:
# BGP4, RIPv2 and OSPFv2.
#
# processname: bird
# config: /etc/bird.conf
# Source function library.
. /etc/rc.d/init.d/functions
[ -f /etc/sysconfig/network ] || exit 0
. /etc/sysconfig/network
BIRD4="yes"
BIRD6="yes"
BIRD4ARGS=
BIRD6ARGS=
[ -f /etc/bird.conf ] || BIRD4="no"
[ -f /usr/sbin/bird ] || BIRD4="no"
[ "${NETWORKING}" = "yes" ] || BIRD4="no"
[ -f /etc/bird6.conf ] || BIRD6="no"
[ -f /usr/sbin/bird6 ] || BIRD6="no"
[ "${NETWORKING_IPV6}" = "yes" ] || BIRD6="no"
[ -e /etc/sysconfig/bird ] && . /etc/sysconfig/bird
RETVAL=0
# See how we were called.
case "$1" in
start)
if [ "$BIRD4" = "yes" ]
then
echo -n "Starting BIRD for IPv4: "
daemon bird ${BIRD4ARGS}
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && touch /var/lock/subsys/bird
fi
if [ "$BIRD6" = "yes" ]
then
echo -n "Starting BIRD for IPv6: "
daemon bird6 ${BIRD6ARGS}
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && touch /var/lock/subsys/bird6
fi
;;
stop)
echo -n "Stopping BIRD for IPv4: "
killproc bird
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/bird
echo -n "Stopping BIRD for IPv6: "
killproc bird6
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/bird6
;;
status)
status bird
status bird6
RETVAL=$?
;;
restart)
$0 stop
$0 start
RETVAL=$?
;;
reload)
killproc bird -HUP
RETVAL=$?
echo
echo -n "Reloading BIRD for IPv6: "
killproc bird6 -HUP
RETVAL=$?
echo
;;
*)
echo "Usage: bird.init {start|stop|status|restart|reload}"
exit 1
esac
exit $RETVAL
bird2-2.17.5/misc/cisco2list 0000775 0000000 0000000 00000000754 15211753245 0015562 0 ustar 00root root 0000000 0000000 #!/usr/bin/perl
#
# Convert Cisco routing table listing to list of prefixes
#
$loc = ($ARGV[0] eq "-l"); # Print only local prefixes
while () {
($loc ? /^[OR]\s/ : /^B\s/) || next;
/^[ORB]( E[12])?\s+(\d+\.\d+\.\d+\.\d+)(\s|\/\d+\s)/ || die "Cannot parse $_";
$net = $2;
$len = $3;
if ($len =~ /^\s*$/) {
# Magic rule :)
$len = ($net =~ /\.0$/) ? 24 : 32;
}
$len =~ s/^\///;
$net =~ /(\d+)\.(\d+)\.(\d+)\.(\d+)/;
printf "%02x%02x%02x%02x/%d\n", $1, $2, $3, $4, $len;
}
bird2-2.17.5/misc/ips.c 0000664 0000000 0000000 00000004173 15211753245 0014514 0 ustar 00root root 0000000 0000000 #include
#include
#include
#include
int h[65536];
/*
* Probability analysis of hashing function:
*
* Let n be number of items and k number of boxes. For uniform distribution
* we get:
*
* Expected value of "item i is in given box": Xi = 1/k
* Expected number of items in given box: a = EX = E(sum Xi) = sum E(Xi) = n/k
* Expected square value: E(X^2) = E((sum Xi)^2) = E((sum_i Xi^2) + (sum_i,j i<>j XiXj)) =
* = sum_i E(Xi^2) + sum_i,j i<>j E(XiXj) =
* = sum_i E(Xi) [Xi is binary] + sum_i,j i<>j E(XiXj) [those are independent] =
* = n/k + n*(n-1)/k^2
* Variance: var X = E(X^2) - (EX)^2 = n/k + n*(n-1)/k^2 - n^2/k^2 =
* = n/k - n/k^2 = a * (1-1/k)
* Probability of fixed box being zero: Pz = ((k-1)/k)^n = (1-1/k)^n = (1-1/k)^(ak) =
* = ((1-1/k)^k)^a which we can approximate by e^-a.
*/
uint hf(uint n)
{
#if 0
n = (n ^ (n >> 16)) & 0xffff;
n = (n ^ (n << 8)) & 0xffff;
#elif 1
n = (n >> 16) ^ n;
n = (n ^ (n << 10)) & 0xffff;
#elif 0
n = (n >> 16) ^ n;
n *= 259309;
#elif 0
n ^= (n >> 20);
n ^= (n >> 10);
n ^= (n >> 5);
#elif 0
n = (n * 259309) + ((n >> 16) * 123479);
#else
return random();
#endif
return n;
}
int
main(int argc, char **argv)
{
int cnt=0;
int i;
int bits = atol(argv[1]);
int z = 1 << bits;
int max = atol(argv[2]);
while (max--)
{
uint i, e;
if (scanf("%x/%d", &i, &e) != 2)
{
if (feof(stdin))
break;
else
fprintf(stderr, "BUGGG\n");
}
// i >>= (32-e);
// i |= (i >> e);
cnt++;
h[(hf(i) >> 1*(16 - bits)) & (z-1)]++;
}
// printf(">>> %d addresses\n", cnt);
#if 0
for(i=0; i max) max=h[i];
delta += (h[i] - avg) * (h[i] - avg);
if (!h[i]) zer++;
}
printf("size=%5d, min=%d, max=%2d, delta=%-7.6g (%-7.6g), avg=%-5.3g, zero=%g%% (%g%%)\n", z, min, max, delta/z, exdelta, avg, zer/(double)z*100, exzer*100);
}
#endif
return 0;
}
bird2-2.17.5/misc/stats 0000775 0000000 0000000 00000000246 15211753245 0014636 0 ustar 00root root 0000000 0000000 #!/bin/sh
make ips
echo "Global tables:"
for a in 4 5 6 7 8 9 10 11 12 13 14 15 ; do
./ips $@
prepare: $(o)proto-build.c
tests_src := a-set_test.c a-path_test.c rt-fib_test.c
tests_targets := $(tests_targets) $(tests-target-files)
tests_objs := $(tests_objs) $(src-o-files)
bird2-2.17.5/nest/a-path.c 0000664 0000000 0000000 00000043357 15211753245 0015120 0 ustar 00root root 0000000 0000000 /*
* BIRD -- Path Operations
*
* (c) 2000 Martin Mares
* (c) 2000 Pavel Machek
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "nest/bird.h"
#include "nest/route.h"
#include "nest/attrs.h"
#include "lib/resource.h"
#include "lib/unaligned.h"
#include "lib/string.h"
#include "filter/data.h"
// static inline void put_as(byte *data, u32 as) { put_u32(data, as); }
// static inline u32 get_as(byte *data) { return get_u32(data); }
#define put_as put_u32
#define get_as get_u32
#define BS 4 /* Default block size of ASN (autonomous system number) */
#define BAD(DSC, VAL) ({ err_dsc = DSC; err_val = VAL; goto bad; })
int
as_path_valid(byte *data, uint len, int bs, int sets, int confed, char *err, uint elen)
{
byte *pos = data;
char *err_dsc = NULL;
uint err_val = 0;
while (len)
{
if (len < 2)
BAD("segment framing error", 0);
/* Process one AS path segment */
uint type = pos[0];
uint slen = 2 + bs * pos[1];
if (len < slen)
BAD("segment framing error", len);
switch (type)
{
case AS_PATH_SET:
if (!sets)
BAD("AS_SET segment", type);
break;
case AS_PATH_SEQUENCE:
break;
case AS_PATH_CONFED_SEQUENCE:
if (!confed)
BAD("AS_CONFED_SEQUENCE segment", type);
break;
case AS_PATH_CONFED_SET:
if (!sets || !confed)
BAD("AS_CONFED_SET segment", type);
break;
default:
BAD("unknown segment", type);
}
if (pos[1] == 0)
BAD("zero-length segment", type);
pos += slen;
len -= slen;
}
return 1;
bad:
if (err)
if (bsnprintf(err, elen, "%s (%u) at %d", err_dsc, err_val, (int) (pos - data)) < 0)
err[0] = 0;
return 0;
}
int
as_path_16to32(byte *dst, const byte *src, uint len)
{
byte *dst0 = dst;
const byte *end = src + len;
uint i, n;
while (src < end)
{
n = src[1];
*dst++ = *src++;
*dst++ = *src++;
for (i = 0; i < n; i++)
{
put_u32(dst, get_u16(src));
src += 2;
dst += 4;
}
}
return dst - dst0;
}
int
as_path_32to16(byte *dst, const byte *src, uint len)
{
byte *dst0 = dst;
const byte *end = src + len;
uint i, n;
while (src < end)
{
n = src[1];
*dst++ = *src++;
*dst++ = *src++;
for (i = 0; i < n; i++)
{
put_u16(dst, get_u32(src));
src += 4;
dst += 2;
}
}
return dst - dst0;
}
int
as_path_contains_as4(const struct adata *path)
{
const byte *pos = path->data;
const byte *end = pos + path->length;
uint i, n;
while (pos < end)
{
n = pos[1];
pos += 2;
for (i = 0; i < n; i++)
{
if (get_as(pos) > 0xFFFF)
return 1;
pos += BS;
}
}
return 0;
}
int
as_path_contains_confed(const struct adata *path)
{
const byte *pos = path->data;
const byte *end = pos + path->length;
while (pos < end)
{
uint type = pos[0];
uint slen = 2 + BS * pos[1];
if ((type == AS_PATH_CONFED_SEQUENCE) ||
(type == AS_PATH_CONFED_SET))
return 1;
pos += slen;
}
return 0;
}
int
as_path_contains_set(const struct adata *path)
{
const byte *pos = path->data;
const byte *end = pos + path->length;
while (pos < end)
{
uint type = pos[0];
uint slen = 2 + BS * pos[1];
if ((type == AS_PATH_SET) ||
(type == AS_PATH_CONFED_SET))
return 1;
pos += slen;
}
return 0;
}
struct adata *
as_path_strip_confed(struct linpool *pool, const struct adata *path)
{
struct adata *res = lp_alloc_adata(pool, path->length);
const byte *src = path->data;
const byte *end = src + path->length;
byte *dst = res->data;
while (src < end)
{
uint type = src[0];
uint slen = 2 + BS * src[1];
/* Copy regular segments */
if ((type == AS_PATH_SET) || (type == AS_PATH_SEQUENCE))
{
memcpy(dst, src, slen);
dst += slen;
}
src += slen;
}
/* Fix the result length */
res->length = dst - res->data;
return res;
}
struct adata *
as_path_prepend2(struct linpool *pool, const struct adata *op, int seq, u32 as)
{
struct adata *np;
const byte *pos = op->data;
uint len = op->length;
if (len && (pos[0] == seq) && (pos[1] < 255))
{
/* Starting with matching segment => just prepend the AS number */
np = lp_alloc_adata(pool, len + BS);
np->data[0] = seq;
np->data[1] = pos[1] + 1;
put_as(np->data + 2, as);
uint dlen = BS * pos[1];
memcpy(np->data + 2 + BS, pos + 2, dlen);
ADVANCE(pos, len, 2 + dlen);
}
else
{
/* Create a new path segment */
np = lp_alloc_adata(pool, len + 2 + BS);
np->data[0] = seq;
np->data[1] = 1;
put_as(np->data + 2, as);
}
if (len)
{
byte *dst = np->data + 2 + BS * np->data[1];
memcpy(dst, pos, len);
}
return np;
}
struct adata *
as_path_to_old(struct linpool *pool, const struct adata *path)
{
struct adata *res = lp_alloc_adata(pool, path->length);
byte *pos = res->data;
byte *end = pos + res->length;
uint i, n;
u32 as;
/* Copy the whole path */
memcpy(res->data, path->data, path->length);
/* Replace 32-bit AS numbers with AS_TRANS */
while (pos < end)
{
n = pos[1];
pos += 2;
for (i = 0; i < n; i++)
{
as = get_as(pos);
if (as > 0xFFFF)
put_as(pos, AS_TRANS);
pos += BS;
}
}
return res;
}
/*
* Cut the path to the length @num, measured to the usual path metric. Note that
* AS_CONFED_* segments have zero length and must be added if they are on edge.
*/
struct adata *
as_path_cut(struct linpool *pool, const struct adata *path, uint num)
{
const byte *pos = path->data;
const byte *end = pos + path->length;
while (pos < end)
{
uint t = pos[0];
uint l = pos[1];
uint n = 0;
switch (t)
{
case AS_PATH_SET: n = 1; break;
case AS_PATH_SEQUENCE: n = l; break;
case AS_PATH_CONFED_SEQUENCE: n = 0; break;
case AS_PATH_CONFED_SET: n = 0; break;
default: bug("as_path_cut: Invalid path segment");
}
/* Cannot add whole segment, so try partial one and finish */
if (num < n)
{
const byte *nend = pos;
if (num)
nend += 2 + BS * num;
struct adata *res = lp_alloc_adata(pool, path->length);
res->length = nend - (const byte *) path->data;
memcpy(res->data, path->data, res->length);
if (num)
{
byte *dpos = ((byte *) res->data) + (pos - (const byte *) path->data);
dpos[1] = num;
}
return res;
}
num -= n;
pos += 2 + BS * l;
}
struct adata *res = lp_alloc_adata(pool, path->length);
res->length = path->length;
memcpy(res->data, path->data, res->length);
return res;
}
/*
* Merge (concatenate) paths @p1 and @p2 and return the result.
* In contrast to other as_path_* functions, @p1 and @p2 may be reused.
*/
const struct adata *
as_path_merge(struct linpool *pool, const struct adata *p1, const struct adata *p2)
{
if (p1->length == 0)
return p2;
if (p2->length == 0)
return p1;
struct adata *res = lp_alloc_adata(pool, p1->length + p2->length);
memcpy(res->data, p1->data, p1->length);
memcpy(res->data + p1->length, p2->data, p2->length);
return res;
}
void
as_path_format(const struct adata *path, byte *bb, uint size)
{
buffer buf = { .start = bb, .pos = bb, .end = bb + size }, *b = &buf;
const byte *pos = path->data;
const byte *end = pos + path->length;
const char *ops, *cls;
b->pos[0] = 0;
while (pos < end)
{
uint type = pos[0];
uint len = pos[1];
pos += 2;
switch (type)
{
case AS_PATH_SET: ops = "{"; cls = "}"; break;
case AS_PATH_SEQUENCE: ops = NULL; cls = NULL; break;
case AS_PATH_CONFED_SEQUENCE: ops = "("; cls = ")"; break;
case AS_PATH_CONFED_SET: ops = "({"; cls = "})"; break;
default: bug("Invalid path segment");
}
if (ops)
buffer_puts(b, ops);
while (len--)
{
buffer_print(b, len ? "%u " : "%u", get_as(pos));
pos += BS;
}
if (cls)
buffer_puts(b, cls);
if (pos < end)
buffer_puts(b, " ");
}
/* Handle overflow */
if (b->pos == b->end)
strcpy(b->end - 12, "...");
}
int
as_path_getlen(const struct adata *path)
{
const byte *pos = path->data;
const byte *end = pos + path->length;
uint res = 0;
while (pos < end)
{
uint t = pos[0];
uint l = pos[1];
uint n = 0;
switch (t)
{
case AS_PATH_SET: n = 1; break;
case AS_PATH_SEQUENCE: n = l; break;
case AS_PATH_CONFED_SEQUENCE: n = 0; break;
case AS_PATH_CONFED_SET: n = 0; break;
default: bug("as_path_getlen: Invalid path segment");
}
res += n;
pos += 2 + BS * l;
}
return res;
}
int
as_path_get_last(const struct adata *path, u32 *orig_as)
{
const byte *pos = path->data;
const byte *end = pos + path->length;
int found = 0;
u32 val = 0;
while (pos < end)
{
uint type = pos[0];
uint len = pos[1];
pos += 2;
if (!len)
continue;
switch (type)
{
case AS_PATH_SET:
case AS_PATH_CONFED_SET:
found = 0;
break;
case AS_PATH_SEQUENCE:
case AS_PATH_CONFED_SEQUENCE:
val = get_as(pos + BS * (len - 1));
found = 1;
break;
default:
bug("Invalid path segment");
}
pos += BS * len;
}
if (found)
*orig_as = val;
return found;
}
u32
as_path_get_last_nonaggregated(const struct adata *path)
{
const byte *pos = path->data;
const byte *end = pos + path->length;
u32 val = 0;
while (pos < end)
{
uint type = pos[0];
uint len = pos[1];
pos += 2;
if (!len)
continue;
switch (type)
{
case AS_PATH_SET:
case AS_PATH_CONFED_SET:
return val;
case AS_PATH_SEQUENCE:
case AS_PATH_CONFED_SEQUENCE:
val = get_as(pos + BS * (len - 1));
break;
default:
bug("Invalid path segment");
}
pos += BS * len;
}
return val;
}
int
as_path_get_first(const struct adata *path, u32 *last_as)
{
const u8 *p = path->data;
if ((path->length == 0) || (p[0] != AS_PATH_SEQUENCE) || (p[1] == 0))
return 0;
*last_as = get_as(p+2);
return 1;
}
int
as_path_get_first_regular(const struct adata *path, u32 *last_as)
{
const byte *pos = path->data;
const byte *end = pos + path->length;
while (pos < end)
{
uint type = pos[0];
uint len = pos[1];
pos += 2;
switch (type)
{
case AS_PATH_SET:
return 0;
case AS_PATH_SEQUENCE:
if (len == 0)
return 0;
*last_as = get_as(pos);
return 1;
case AS_PATH_CONFED_SEQUENCE:
case AS_PATH_CONFED_SET:
break;
default:
bug("Invalid path segment");
}
pos += BS * len;
}
return 0;
}
int
as_path_contains(const struct adata *path, u32 as, int min)
{
const u8 *p = path->data;
const u8 *q = p+path->length;
int num = 0;
int i, n;
while (pdata;
const u8 *q = p+path->length;
int i, n;
while (ptype == T_SET) || (set->type == T_INT));
if (!path)
return NULL;
int len = path->length;
const u8 *p = path->data;
const u8 *q = path->data + len;
u8 *d, *d2;
int i, bt, sn, dn;
u8 buf[len];
d = buf;
while (ptype == T_SET)
{
struct f_val v = { .type = T_INT, .val.i = as};
match = !!find_tree(set->val.t, &v);
}
else /* T_INT */
match = (as == set->val.i);
if (match == pos)
{
put_as(d2, as);
d2 += BS;
dn++;
}
p += BS;
}
if (dn > 0)
{
/* Nonempty block, set block header and advance */
d[0] = bt;
d[1] = dn;
d = d2;
}
}
uint nl = d - buf;
if (nl == path->length)
return path;
struct adata *res = lp_alloc(pool, sizeof(struct adata) + nl);
res->length = nl;
memcpy(res->data, buf, nl);
return res;
}
int
as_path_compare(const struct adata *path1, const struct adata *path2)
{
uint pos1 = 0;
uint pos2 = 0;
uint val1 = 0;
uint val2 = 0;
while (1)
{
int res1 = as_path_walk(path1, &pos1, &val1);
int res2 = as_path_walk(path2, &pos2, &val2);
if (res1 == 0 && res2 == 0)
return 0;
if (val1 == val2)
continue;
return val1 < val2 ? -1 : 1;
}
}
int
as_path_walk(const struct adata *path, uint *pos, uint *val)
{
if (!path)
return 0;
const u8 *p = path->data;
const u8 *q = p + path->length;
uint n, x = *pos;
while (p < q)
{
n = p[1];
p += 2;
if (x < n)
{
*val = get_as(p + x * BS);
*pos += 1;
return 1;
}
p += n * BS;
x -= n;
}
return 0;
}
struct pm_pos
{
u8 set;
u8 mark;
union
{
const char *sp;
u32 asn;
} val;
};
static int
parse_path(const struct adata *path, struct pm_pos *pp)
{
const byte *pos = path->data;
const byte *end = pos + path->length;
struct pm_pos *op = pp;
uint i;
while (pos < end)
{
uint type = pos[0];
uint len = pos[1];
pos += 2;
switch (type)
{
case AS_PATH_SET:
case AS_PATH_CONFED_SET:
pp->set = 1;
pp->mark = 0;
pp->val.sp = pos - 1;
pp++;
pos += BS * len;
break;
case AS_PATH_SEQUENCE:
case AS_PATH_CONFED_SEQUENCE:
for (i = 0; i < len; i++)
{
pp->set = 0;
pp->mark = 0;
pp->val.asn = get_as(pos);
pp++;
pos += BS;
}
break;
default:
bug("Invalid path segment");
}
}
return pp - op;
}
static int
pm_match_val(const struct pm_pos *pos, u32 asn, u32 asn2)
{
u32 gas;
if (! pos->set)
return ((pos->val.asn >= asn) && (pos->val.asn <= asn2));
const u8 *p = pos->val.sp;
int len = *p++;
int i;
for (i = 0; i < len; i++)
{
gas = get_as(p + i * BS);
if ((gas >= asn) && (gas <= asn2))
return 1;
}
return 0;
}
static int
pm_match_set(const struct pm_pos *pos, const struct f_tree *set)
{
struct f_val asn = { .type = T_INT };
if (! pos->set)
{
asn.val.i = pos->val.asn;
return !!find_tree(set, &asn);
}
const u8 *p = pos->val.sp;
int len = *p++;
int i;
for (i = 0; i < len; i++)
{
asn.val.i = get_as(p + i * BS);
if (find_tree(set, &asn))
return 1;
}
return 0;
}
static inline int
pm_match(const struct pm_pos *pos, const struct f_path_mask_item *mask, u32 asn, u32 asn2)
{
return ((mask->kind == PM_QUESTION) ||
((mask->kind != PM_ASN_SET) ?
pm_match_val(pos, asn, asn2) :
pm_match_set(pos, mask->set)));
}
static void
pm_mark(struct pm_pos *pos, int *i, int plen, int *nl, int *nh)
{
int j = *i;
if (pos[j].set)
do { pos[j].mark = 1; j++; }
while ((j < plen) && pos[j].set);
else
j++;
pos[j].mark = 1;
/* Update low, high based on first and last marked pos */
int l = pos[*i].set ? *i : j;
*nl = (*nl < 0) ? l : MIN(*nl, l);
*nh = MAX(*nh, j);
*i = j;
}
/* AS path matching is nontrivial. Because AS path can
* contain sets, it is not a plain wildcard matching. A set
* in an AS path is interpreted as it might represent any
* sequence of AS numbers from that set (possibly with
* repetitions). So it is also a kind of a pattern,
* more complicated than a path mask.
*
* The algorithm for AS path matching is a variant
* of nondeterministic finite state machine, where
* positions in AS path are states, and items in
* path mask are input for that finite state machine.
* During execution of the algorithm we maintain a set
* of marked states - a state is marked if it can be
* reached by any walk through NFSM with regard to
* currently processed part of input. When we process
* next part of mask, we advance each marked state.
* We start with marked first position, when we
* run out of marked positions, we reject. When
* we process the whole mask, we accept if final position
* (auxiliary position after last real position in AS path)
* is marked.
*/
int
as_path_match(const struct adata *path, const struct f_path_mask *mask)
{
struct pm_pos *pos = tmp_alloc((sizeof *pos) * (path->length / BS + 1));
int plen = parse_path(path, pos);
int l, h, i, nh, nl, last, loop;
u32 val = 0;
u32 val2 = 0;
/* l and h are bound of interval of positions where
are marked states */
pos[plen].set = 0;
pos[plen].mark = 0;
l = h = loop = 0;
pos[0].mark = 1;
for (uint m=0; m < mask->len; m++)
{
/* We remove this mark to not step after pos[plen] */
pos[plen].mark = 0;
switch (mask->item[m].kind)
{
case PM_ASTERISK:
for (i = l; i <= plen; i++)
pos[i].mark = 1;
h = plen;
break;
case PM_LOOP:
loop = 1;
break;
case PM_ASN: /* Define single ASN as ASN..ASN - very narrow interval */
val2 = val = mask->item[m].asn;
goto step;
case PM_ASN_EXPR:
bug("Expressions should be evaluated on AS path mask construction.");
case PM_ASN_RANGE:
val = mask->item[m].from;
val2 = mask->item[m].to;
goto step;
case PM_QUESTION:
case PM_ASN_SET:
step:
nh = nl = -1;
last = plen;
for (i = h; i >= l; i--)
if (pos[i].mark)
{
pos[i].mark = 0;
int j = i;
match:
if (pm_match(pos + j, &mask->item[m], val, val2))
{
pm_mark(pos, &j, plen, &nl, &nh);
if (loop && (j < last))
goto match;
}
last = i;
}
if (nh < 0)
return 0;
h = nh;
l = nl;
loop = 0;
break;
}
}
return pos[plen].mark;
}
bird2-2.17.5/nest/a-path_test.c 0000664 0000000 0000000 00000013327 15211753245 0016151 0 ustar 00root root 0000000 0000000 /*
* BIRD -- Path Operations Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "test/bt-utils.h"
#include "nest/route.h"
#include "nest/attrs.h"
#include "lib/resource.h"
#include "filter/data.h"
#define TESTS_NUM 30
#define AS_PATH_LENGTH 1000
#if AS_PATH_LENGTH > AS_PATH_MAXLEN
#warning "AS_PATH_LENGTH should be <= AS_PATH_MAXLEN"
#endif
static int
t_as_path_match(void)
{
int round;
for (round = 0; round < TESTS_NUM; round++)
{
struct adata empty_as_path = {};
struct adata *as_path = &empty_as_path;
u32 first_prepended, last_prepended;
first_prepended = last_prepended = 0;
struct f_path_mask *mask = alloca(sizeof(struct f_path_mask) + AS_PATH_LENGTH * sizeof(struct f_path_mask_item));
mask->len = AS_PATH_LENGTH;
for (int i = AS_PATH_LENGTH - 1; i >= 0; i--)
{
u32 val = bt_random();
as_path = as_path_prepend(tmp_linpool, as_path, val);
bt_debug("Prepending ASN: %10u \n", val);
if (i == 0)
last_prepended = val;
if (i == AS_PATH_LENGTH-1)
first_prepended = val;
mask->item[i].kind = PM_ASN;
mask->item[i].asn = val;
}
bt_assert_msg(as_path_match(as_path, mask), "Mask should match with AS path");
u32 asn;
bt_assert(as_path_get_first(as_path, &asn));
bt_assert_msg(asn == last_prepended, "as_path_get_first() should return the last prepended ASN");
bt_assert(as_path_get_last(as_path, &asn));
bt_assert_msg(asn == first_prepended, "as_path_get_last() should return the first prepended ASN");
tmp_flush();
}
return 1;
}
static int
t_path_format(void)
{
struct adata empty_as_path = {};
struct adata *as_path = &empty_as_path;
uint i;
for (i = 4294967285; i <= 4294967294; i++)
{
as_path = as_path_prepend(tmp_linpool, as_path, i);
bt_debug("Prepending ASN: %10u \n", i);
}
#define BUFFER_SIZE 120
byte buf[BUFFER_SIZE] = {};
as_path_format(&empty_as_path, buf, BUFFER_SIZE);
bt_assert_msg(strcmp(buf, "") == 0, "Buffer(%zu): '%s'", strlen(buf), buf);
as_path_format(as_path, buf, BUFFER_SIZE);
bt_assert_msg(strcmp(buf, "4294967294 4294967293 4294967292 4294967291 4294967290 4294967289 4294967288 4294967287 4294967286 4294967285") == 0, "Buffer(%zu): '%s'", strlen(buf), buf);
#define SMALL_BUFFER_SIZE 25
byte buf2[SMALL_BUFFER_SIZE] = {};
as_path_format(as_path, buf2, SMALL_BUFFER_SIZE);
bt_assert_msg(strcmp(buf2, "4294967294 42...") == 0, "Small Buffer(%zu): '%s'", strlen(buf2), buf2);
tmp_flush();
return 1;
}
static int
count_asn_in_array(const u32 *array, u32 asn)
{
int counts_of_contains = 0;
int u;
for (u = 0; u < AS_PATH_LENGTH; u++)
if (array[u] == asn)
counts_of_contains++;
return counts_of_contains;
}
static int
t_path_include(void)
{
struct adata empty_as_path = {};
struct adata *as_path = &empty_as_path;
u32 as_nums[AS_PATH_LENGTH] = {};
int i;
for (i = 0; i < AS_PATH_LENGTH; i++)
{
u32 val = bt_random();
as_nums[i] = val;
as_path = as_path_prepend(tmp_linpool, as_path, val);
}
for (i = 0; i < AS_PATH_LENGTH; i++)
{
int counts_of_contains = count_asn_in_array(as_nums, as_nums[i]);
bt_assert_msg(as_path_contains(as_path, as_nums[i], counts_of_contains), "AS Path should contains %d-times number %d", counts_of_contains, as_nums[i]);
struct f_val v = { .type = T_INT, .val.i = as_nums[i] };
bt_assert(as_path_filter(tmp_linpool, as_path, &v, 0) != NULL);
bt_assert(as_path_filter(tmp_linpool, as_path, &v, 1) != NULL);
}
for (i = 0; i < 10000; i++)
{
u32 test_val = bt_random();
int counts_of_contains = count_asn_in_array(as_nums, test_val);
int result = as_path_contains(as_path, test_val, (counts_of_contains == 0 ? 1 : counts_of_contains));
if (counts_of_contains)
bt_assert_msg(result, "As path should contain %d-times the number %u", counts_of_contains, test_val);
else
bt_assert_msg(result == 0, "As path should not contain the number %u", test_val);
}
tmp_flush();
return 1;
}
#if 0
static int
t_as_path_converting(void)
{
struct adata empty_as_path = {};
struct adata *as_path = &empty_as_path;
#define AS_PATH_LENGTH_FOR_CONVERTING_TEST 10
int i;
for (i = 0; i < AS_PATH_LENGTH_FOR_CONVERTING_TEST; i++)
as_path = as_path_prepend(tmp_linpool, as_path, i);
bt_debug("data length: %u \n", as_path->length);
byte buffer[100] = {};
int used_size = as_path_convert_to_new(as_path, buffer, AS_PATH_LENGTH_FOR_CONVERTING_TEST-1);
bt_debug("as_path_convert_to_new: len %d \n%s\n", used_size, buffer);
for (i = 0; i < used_size; i++)
{
bt_debug("\\03%d", buffer[i]);
}
bt_debug("\n");
bt_assert(memcmp(buffer,
"\032\039\030\030\030\030\030\030\030\039\030\030\030\030\030\030\030\038\030\030\030\030\030\030"
"\030\037\030\030\030\030\030\030\030\036\030\030\030\030",
38));
bzero(buffer, sizeof(buffer));
int new_used;
used_size = as_path_convert_to_old(as_path, buffer, &new_used);
bt_debug("as_path_convert_to_old: len %d, new_used: %d \n", used_size, new_used);
for (i = 0; i < used_size; i++)
{
bt_debug("\\03%d", buffer[i]);
}
bt_debug("\n");
bt_assert(memcmp(buffer,
"\032\0310\030\039\030\038\030\037\030\036\030\035\030\034\030\033\030\032\030\031\030\030",
22));
return 1;
}
#endif
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_as_path_match, "Testing AS path matching and some a-path utilities.");
bt_test_suite(t_path_format, "Testing formating as path into byte buffer");
bt_test_suite(t_path_include, "Testing including a AS number in AS path");
// bt_test_suite(t_as_path_converting, "Testing as_path_convert_to_*() output constancy");
return bt_exit_value();
}
bird2-2.17.5/nest/a-set.c 0000664 0000000 0000000 00000034703 15211753245 0014752 0 ustar 00root root 0000000 0000000 /*
* BIRD -- Set/Community-list Operations
*
* (c) 2000 Martin Mares
* (c) 2000 Pavel Machek
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include
#include "nest/bird.h"
#include "nest/route.h"
#include "nest/attrs.h"
#include "lib/resource.h"
#include "lib/string.h"
/**
* int_set_format - format an &set for printing
* @set: set attribute to be formatted
* @way: style of format (0 for router ID list, 1 for community list)
* @from: starting position in set
* @buf: destination buffer
* @size: size of buffer
*
* This function takes a set attribute and formats it. @way specifies
* the style of format (router ID / community). @from argument can be
* used to specify the first printed value for the purpose of printing
* untruncated sets even with smaller buffers. If the output fits in
* the buffer, 0 is returned, otherwise the position of the first not
* printed item is returned. This value can be used as @from argument
* in subsequent calls. If truncated output suffices, -1 can be
* instead used as @from, in that case " ..." is eventually added at
* the buffer to indicate truncation.
*/
int
int_set_format(const struct adata *set, enum isf_way way, int from, byte *buf, uint size)
{
u32 *z = (u32 *) set->data;
byte *end = buf + size - 24;
int from2 = MAX(from, 0);
int to = set->length / 4;
int i;
for (i = from2; i < to; i++)
{
if (buf > end)
{
if (from < 0)
strcpy(buf, " ...");
else
*buf = 0;
return i;
}
if (i > from2)
*buf++ = ' ';
switch (way)
{
case ISF_COMMUNITY_LIST:
buf += bsprintf(buf, "(%d,%d)", z[i] >> 16, z[i] & 0xffff);
break;
case ISF_ROUTER_ID:
buf += bsprintf(buf, "%R", z[i]);
break;
case ISF_NUMBERS:
buf += bsprintf(buf, "%u", z[i]);
break;
}
}
*buf = 0;
return 0;
}
int
ec_format(byte *buf, u64 ec)
{
u32 type, key, val;
char tbuf[16];
const char *kind;
type = ec >> 48;
kind = ec_subtype_str(type & 0xf0ff);
if (!kind) {
bsprintf(tbuf, "unknown 0x%x", type);
kind = tbuf;
}
switch (ec >> 56)
{
/* RFC 4360 3.1. Two-Octet AS Specific Extended Community */
case 0x00:
case 0x40:
key = (ec >> 32) & 0xFFFF;
val = ec;
return bsprintf(buf, "(%s, %u, %u)", kind, key, val);
/* RFC 4360 3.2. IPv4 Address Specific Extended Community */
case 0x01:
case 0x41:
key = ec >> 16;
val = ec & 0xFFFF;
return bsprintf(buf, "(%s, %R, %u)", kind, key, val);
/* RFC 5668 4-Octet AS Specific BGP Extended Community */
case 0x02:
case 0x42:
key = ec >> 16;
val = ec & 0xFFFF;
return bsprintf(buf, "(%s, %u, %u)", kind, key, val);
/* Generic format for unknown kinds of extended communities */
default:
key = ec >> 32;
val = ec;
return bsprintf(buf, "(generic, 0x%x, 0x%x)", key, val);
}
}
int
ec_set_format(const struct adata *set, int from, byte *buf, uint size)
{
u32 *z = int_set_get_data(set);
byte *end = buf + size - 64;
int from2 = MAX(from, 0);
int to = int_set_get_size(set);
int i;
for (i = from2; i < to; i += 2)
{
if (buf > end)
{
if (from < 0)
strcpy(buf, " ...");
else
*buf = 0;
return i;
}
if (i > from2)
*buf++ = ' ';
buf += ec_format(buf, ec_get(z, i));
}
*buf = 0;
return 0;
}
int
lc_format(byte *buf, lcomm lc)
{
return bsprintf(buf, "(%u, %u, %u)", lc.asn, lc.ldp1, lc.ldp2);
}
int
lc_set_format(const struct adata *set, int from, byte *buf, uint bufsize)
{
u32 *d = (u32 *) set->data;
byte *end = buf + bufsize - 64;
int from2 = MAX(from, 0);
int to = set->length / 4;
int i;
for (i = from2; i < to; i += 3)
{
if (buf > end)
{
if (from < 0)
strcpy(buf, "...");
else
buf[-1] = 0;
return i;
}
buf += bsprintf(buf, "(%u, %u, %u)", d[i], d[i+1], d[i+2]);
*buf++ = ' ';
}
if (i != from2)
buf--;
*buf = 0;
return 0;
}
int
int_set_contains(const struct adata *list, u32 val)
{
if (!list)
return 0;
u32 *l = (u32 *) list->data;
int len = int_set_get_size(list);
int i;
for (i = 0; i < len; i++)
if (*l++ == val)
return 1;
return 0;
}
int
ec_set_contains(const struct adata *list, u64 val)
{
if (!list)
return 0;
u32 *l = int_set_get_data(list);
int len = int_set_get_size(list);
u32 eh = ec_hi(val);
u32 el = ec_lo(val);
int i;
for (i=0; i < len; i += 2)
if (l[i] == eh && l[i+1] == el)
return 1;
return 0;
}
int
lc_set_contains(const struct adata *list, lcomm val)
{
if (!list)
return 0;
u32 *l = int_set_get_data(list);
int len = int_set_get_size(list);
int i;
for (i = 0; i < len; i += 3)
if (lc_match(l, i, val))
return 1;
return 0;
}
const struct adata *
int_set_prepend(struct linpool *pool, const struct adata *list, u32 val)
{
struct adata *res;
int len;
if (int_set_contains(list, val))
return list;
len = list ? list->length : 0;
res = lp_alloc(pool, sizeof(struct adata) + len + 4);
res->length = len + 4;
if (list)
memcpy(res->data + 4, list->data, list->length);
* (u32 *) res->data = val;
return res;
}
const struct adata *
int_set_add(struct linpool *pool, const struct adata *list, u32 val)
{
struct adata *res;
int len;
if (int_set_contains(list, val))
return list;
len = list ? list->length : 0;
res = lp_alloc(pool, sizeof(struct adata) + len + 4);
res->length = len + 4;
if (list)
memcpy(res->data, list->data, list->length);
* (u32 *) (res->data + len) = val;
return res;
}
const struct adata *
ec_set_add(struct linpool *pool, const struct adata *list, u64 val)
{
if (ec_set_contains(list, val))
return list;
int olen = list ? list->length : 0;
struct adata *res = lp_alloc(pool, sizeof(struct adata) + olen + 8);
res->length = olen + 8;
if (list)
memcpy(res->data, list->data, list->length);
u32 *l = (u32 *) (res->data + olen);
l[0] = ec_hi(val);
l[1] = ec_lo(val);
return res;
}
const struct adata *
lc_set_add(struct linpool *pool, const struct adata *list, lcomm val)
{
if (lc_set_contains(list, val))
return list;
int olen = list ? list->length : 0;
struct adata *res = lp_alloc(pool, sizeof(struct adata) + olen + LCOMM_LENGTH);
res->length = olen + LCOMM_LENGTH;
if (list)
memcpy(res->data, list->data, list->length);
lc_put((u32 *) (res->data + olen), val);
return res;
}
const struct adata *
int_set_del(struct linpool *pool, const struct adata *list, u32 val)
{
if (!int_set_contains(list, val))
return list;
struct adata *res;
res = lp_alloc(pool, sizeof(struct adata) + list->length - 4);
res->length = list->length - 4;
u32 *l = int_set_get_data(list);
u32 *k = int_set_get_data(res);
int len = int_set_get_size(list);
int i;
for (i = 0; i < len; i++)
if (l[i] != val)
*k++ = l[i];
return res;
}
const struct adata *
ec_set_del(struct linpool *pool, const struct adata *list, u64 val)
{
if (!ec_set_contains(list, val))
return list;
struct adata *res;
res = lp_alloc(pool, sizeof(struct adata) + list->length - 8);
res->length = list->length - 8;
u32 *l = int_set_get_data(list);
u32 *k = int_set_get_data(res);
int len = int_set_get_size(list);
u32 eh = ec_hi(val);
u32 el = ec_lo(val);
int i;
for (i=0; i < len; i += 2)
if (! (l[i] == eh && l[i+1] == el))
{
*k++ = l[i];
*k++ = l[i+1];
}
return res;
}
const struct adata *
lc_set_del(struct linpool *pool, const struct adata *list, lcomm val)
{
if (!lc_set_contains(list, val))
return list;
struct adata *res;
res = lp_alloc(pool, sizeof(struct adata) + list->length - LCOMM_LENGTH);
res->length = list->length - LCOMM_LENGTH;
u32 *l = int_set_get_data(list);
u32 *k = int_set_get_data(res);
int len = int_set_get_size(list);
int i;
for (i=0; i < len; i += 3)
if (! lc_match(l, i, val))
k = lc_copy(k, l+i);
return res;
}
const struct adata *
int_set_union(struct linpool *pool, const struct adata *l1, const struct adata *l2)
{
if (!l1)
return l2;
if (!l2)
return l1;
struct adata *res;
int len = int_set_get_size(l2);
u32 *l = int_set_get_data(l2);
u32 tmp[len];
u32 *k = tmp;
int i;
for (i = 0; i < len; i++)
if (!int_set_contains(l1, l[i]))
*k++ = l[i];
if (k == tmp)
return l1;
len = (k - tmp) * 4;
res = lp_alloc(pool, sizeof(struct adata) + l1->length + len);
res->length = l1->length + len;
memcpy(res->data, l1->data, l1->length);
memcpy(res->data + l1->length, tmp, len);
return res;
}
const struct adata *
ec_set_union(struct linpool *pool, const struct adata *l1, const struct adata *l2)
{
if (!l1)
return l2;
if (!l2)
return l1;
struct adata *res;
int len = int_set_get_size(l2);
u32 *l = int_set_get_data(l2);
u32 tmp[len];
u32 *k = tmp;
int i;
for (i = 0; i < len; i += 2)
if (!ec_set_contains(l1, ec_get(l, i)))
{
*k++ = l[i];
*k++ = l[i+1];
}
if (k == tmp)
return l1;
len = (k - tmp) * 4;
res = lp_alloc(pool, sizeof(struct adata) + l1->length + len);
res->length = l1->length + len;
memcpy(res->data, l1->data, l1->length);
memcpy(res->data + l1->length, tmp, len);
return res;
}
const struct adata *
lc_set_union(struct linpool *pool, const struct adata *l1, const struct adata *l2)
{
if (!l1)
return l2;
if (!l2)
return l1;
struct adata *res;
int len = int_set_get_size(l2);
u32 *l = int_set_get_data(l2);
u32 tmp[len];
u32 *k = tmp;
int i;
for (i = 0; i < len; i += 3)
if (!lc_set_contains(l1, lc_get(l, i)))
k = lc_copy(k, l+i);
if (k == tmp)
return l1;
len = (k - tmp) * 4;
res = lp_alloc(pool, sizeof(struct adata) + l1->length + len);
res->length = l1->length + len;
memcpy(res->data, l1->data, l1->length);
memcpy(res->data + l1->length, tmp, len);
return res;
}
struct adata *
ec_set_del_nontrans(struct linpool *pool, const struct adata *set)
{
adata *res = lp_alloc_adata(pool, set->length);
u32 *src = int_set_get_data(set);
u32 *dst = int_set_get_data(res);
int len = int_set_get_size(set);
int i;
/* Remove non-transitive communities (EC_TBIT set) */
for (i = 0; i < len; i += 2)
{
if (src[i] & EC_TBIT)
continue;
*dst++ = src[i];
*dst++ = src[i+1];
}
res->length = ((byte *) dst) - res->data;
return res;
}
static int
int_set_cmp(const void *X, const void *Y)
{
const u32 *x = X, *y = Y;
return (*x < *y) ? -1 : (*x > *y) ? 1 : 0;
}
struct adata *
int_set_sort(struct linpool *pool, const struct adata *src)
{
struct adata *dst = lp_alloc_adata(pool, src->length);
memcpy(dst->data, src->data, src->length);
qsort(dst->data, dst->length / 4, 4, int_set_cmp);
return dst;
}
int
int_set_min(const struct adata *list, u32 *val)
{
if (!list)
return 0;
u32 *l = (u32 *) list->data;
int len = int_set_get_size(list);
int i;
if (len < 1)
return 0;
*val = *l++;
for (i = 1; i < len; i++, l++)
if (int_set_cmp(val, l) > 0)
*val = *l;
return 1;
}
int
int_set_max(const struct adata *list, u32 *val)
{
if (!list)
return 0;
u32 *l = (u32 *) list->data;
int len = int_set_get_size(list);
int i;
if (len < 1)
return 0;
*val = *l++;
for (i = 1; i < len; i++, l++)
if (int_set_cmp(val, l) < 0)
*val = *l;
return 1;
}
static int
ec_set_cmp(const void *X, const void *Y)
{
u64 x = ec_get(X, 0);
u64 y = ec_get(Y, 0);
return (x < y) ? -1 : (x > y) ? 1 : 0;
}
struct adata *
ec_set_sort(struct linpool *pool, const struct adata *src)
{
struct adata *dst = lp_alloc_adata(pool, src->length);
memcpy(dst->data, src->data, src->length);
qsort(dst->data, dst->length / 8, 8, ec_set_cmp);
return dst;
}
void
ec_set_sort_x(struct adata *set)
{
/* Sort in place */
qsort(set->data, set->length / 8, 8, ec_set_cmp);
}
int
ec_set_min(const struct adata *list, u64 *val)
{
if (!list)
return 0;
u32 *l = int_set_get_data(list);
int len = int_set_get_size(list);
int i;
if (len < 1)
return 0;
u32 *res = l; l += 2;
for (i = 2; i < len; i += 2, l += 2)
if (ec_set_cmp(res, l) > 0)
res = l;
*val = ec_generic(res[0], res[1]);
return 1;
}
int
ec_set_max(const struct adata *list, u64 *val)
{
if (!list)
return 0;
u32 *l = int_set_get_data(list);
int len = int_set_get_size(list);
int i;
if (len < 1)
return 0;
u32 *res = l; l += 2;
for (i = 2; i < len; i += 2, l += 2)
if (ec_set_cmp(res, l) < 0)
res = l;
*val = ec_generic(res[0], res[1]);
return 1;
}
static int
lc_set_cmp(const void *X, const void *Y)
{
const u32 *x = X, *y = Y;
if (x[0] != y[0])
return (x[0] > y[0]) ? 1 : -1;
if (x[1] != y[1])
return (x[1] > y[1]) ? 1 : -1;
if (x[2] != y[2])
return (x[2] > y[2]) ? 1 : -1;
return 0;
}
struct adata *
lc_set_sort(struct linpool *pool, const struct adata *src)
{
struct adata *dst = lp_alloc_adata(pool, src->length);
memcpy(dst->data, src->data, src->length);
qsort(dst->data, dst->length / LCOMM_LENGTH, LCOMM_LENGTH, lc_set_cmp);
return dst;
}
int
lc_set_min(const struct adata *list, lcomm *val)
{
if (!list)
return 0;
u32 *l = int_set_get_data(list);
int len = int_set_get_size(list);
int i;
if (len < 1)
return 0;
u32 *res = l; l += 3;
for (i = 3; i < len; i += 3, l += 3)
if (lc_set_cmp(res, l) > 0)
res = l;
*val = (lcomm) { res[0], res[1], res[2] };
return 1;
}
int
lc_set_max(const struct adata *list, lcomm *val)
{
if (!list)
return 0;
u32 *l = int_set_get_data(list);
int len = int_set_get_size(list);
int i;
if (len < 1)
return 0;
u32 *res = l; l += 3;
for (i = 3; i < len; i += 3, l += 3)
if (lc_set_cmp(res, l) < 0)
res = l;
*val = (lcomm) { res[0], res[1], res[2] };
return 1;
}
int
int_set_walk(const struct adata *list, uint *pos, uint *val)
{
if (!list)
return 0;
if (*pos >= (uint) int_set_get_size(list))
return 0;
u32 *res = int_set_get_data(list) + *pos;
*val = *res;
*pos += 1;
return 1;
}
int
ec_set_walk(const struct adata *list, uint *pos, u64 *val)
{
if (!list)
return 0;
if (*pos >= (uint) int_set_get_size(list))
return 0;
u32 *res = int_set_get_data(list) + *pos;
*val = ec_generic(res[0], res[1]);
*pos += 2;
return 1;
}
int
lc_set_walk(const struct adata *list, uint *pos, lcomm *val)
{
if (!list)
return 0;
if (*pos >= (uint) int_set_get_size(list))
return 0;
u32 *res = int_set_get_data(list) + *pos;
*val = (lcomm) { res[0], res[1], res[2] };
*pos += 3;
return 1;
}
bird2-2.17.5/nest/a-set_test.c 0000664 0000000 0000000 00000016606 15211753245 0016013 0 ustar 00root root 0000000 0000000 /*
* BIRD -- Set/Community-list Operations Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "test/bt-utils.h"
#include "lib/net.h"
#include "nest/route.h"
#include "nest/attrs.h"
#include "lib/resource.h"
#define SET_SIZE 10
static const struct adata *set_sequence; /* <0; SET_SIZE) */
static const struct adata *set_sequence_same; /* <0; SET_SIZE) */
static const struct adata *set_sequence_higher; /*
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_ATTRS_H_
#define _BIRD_ATTRS_H_
#include
#include "lib/unaligned.h"
#include "nest/route.h"
/* a-path.c */
#define AS_PATH_SET 1 /* Types of path segments */
#define AS_PATH_SEQUENCE 2
#define AS_PATH_CONFED_SEQUENCE 3
#define AS_PATH_CONFED_SET 4
#define AS_PATH_MAXLEN 10000
#define AS_TRANS 23456
/* AS_TRANS is used when we need to store 32bit ASN larger than 0xFFFF
* to 16bit slot (like in 16bit AS_PATH). See RFC 4893 for details
*/
struct f_val;
struct f_tree;
int as_path_valid(byte *data, uint len, int bs, int sets, int confed, char *err, uint elen);
int as_path_16to32(byte *dst, const byte *src, uint len);
int as_path_32to16(byte *dst, const byte *src, uint len);
int as_path_contains_as4(const struct adata *path);
int as_path_contains_confed(const struct adata *path);
int as_path_contains_set(const struct adata *path);
struct adata *as_path_strip_confed(struct linpool *pool, const struct adata *op);
struct adata *as_path_prepend2(struct linpool *pool, const struct adata *op, int seq, u32 as);
struct adata *as_path_to_old(struct linpool *pool, const struct adata *path);
struct adata *as_path_cut(struct linpool *pool, const struct adata *path, uint num);
const struct adata *as_path_merge(struct linpool *pool, const struct adata *p1, const struct adata *p2);
void as_path_format(const struct adata *path, byte *buf, uint size) ACCESS_WRITE(2, 3);
int as_path_getlen(const struct adata *path);
int as_path_getlen_int(const struct adata *path, int bs);
int as_path_get_first(const struct adata *path, u32 *orig_as);
int as_path_get_first_regular(const struct adata *path, u32 *last_as);
int as_path_get_last(const struct adata *path, u32 *last_as);
u32 as_path_get_last_nonaggregated(const struct adata *path);
int as_path_contains(const struct adata *path, u32 as, int min);
int as_path_match_set(const struct adata *path, const struct f_tree *set);
const struct adata *as_path_filter(struct linpool *pool, const struct adata *path, const struct f_val *set, int pos);
int as_path_compare(const struct adata *path1, const struct adata *path2);
int as_path_walk(const struct adata *path, uint *pos, uint *val);
static inline struct adata *as_path_prepend(struct linpool *pool, const struct adata *path, u32 as)
{ return as_path_prepend2(pool, path, AS_PATH_SEQUENCE, as); }
#define PM_ASN 0
#define PM_QUESTION 1
#define PM_ASTERISK 2
#define PM_ASN_EXPR 3
#define PM_ASN_RANGE 4
#define PM_ASN_SET 5
#define PM_LOOP 6
struct f_path_mask_item {
union {
u32 asn; /* PM_ASN */
const struct f_line *expr; /* PM_ASN_EXPR */
const struct f_tree *set; /* PM_ASN_SET */
struct { /* PM_ASN_RANGE */
u32 from;
u32 to;
};
};
int kind;
};
struct f_path_mask {
uint len;
struct f_path_mask_item item[0];
};
int as_path_match(const struct adata *path, const struct f_path_mask *mask);
/* Counterparts to appropriate as_path_* functions */
static inline int
aggregator_16to32(byte *dst, const byte *src)
{
put_u32(dst, get_u16(src));
memcpy(dst+4, src+2, 4);
return 8;
}
static inline int
aggregator_32to16(byte *dst, const byte *src)
{
put_u16(dst, get_u32(src));
memcpy(dst+2, src+4, 4);
return 6;
}
static inline int
aggregator_contains_as4(const struct adata *a)
{
return get_u32(a->data) > 0xFFFF;
}
static inline struct adata *
aggregator_to_old(struct linpool *pool, const struct adata *a)
{
struct adata *d = lp_alloc_adata(pool, 8);
put_u32(d->data, AS_TRANS);
memcpy(d->data + 4, a->data + 4, 4);
return d;
}
/* a-set.c */
/* Extended Community subtypes (kinds) */
enum ec_subtype {
EC_RT = 0x0002,
EC_RO = 0x0003,
EC_GENERIC = 0xFFFF,
};
static inline const char *ec_subtype_str(const enum ec_subtype ecs) {
switch (ecs) {
case EC_RT: return "rt";
case EC_RO: return "ro";
default: return NULL;
}
}
/* Check for EC_RT subtype within different types (0-2) */
static inline int ec_type_is_rt(uint type)
{ return (type == EC_RT) || (type == (0x0100 | EC_RT)) || (type == (0x0200 | EC_RT)); }
/* Transitive bit (for first u32 half of EC) */
#define EC_TBIT 0x40000000
#define ECOMM_LENGTH 8
static inline int int_set_get_size(const struct adata *list)
{ return list->length / 4; }
static inline int ec_set_get_size(const struct adata *list)
{ return list->length / 8; }
static inline int lc_set_get_size(const struct adata *list)
{ return list->length / 12; }
static inline u32 *int_set_get_data(const struct adata *list)
{ return (u32 *) list->data; }
static inline u32 ec_hi(u64 ec) { return ec >> 32; }
static inline u32 ec_lo(u64 ec) { return ec; }
static inline u64 ec_get(const u32 *l, int i)
{ return (((u64) l[i]) << 32) | l[i+1]; }
static inline void ec_put(u32 *l, int i, u64 val)
{ l[i] = ec_hi(val); l[i+1] = ec_lo(val); }
/* RFC 4360 3.1. Two-Octet AS Specific Extended Community */
static inline u64 ec_as2(enum ec_subtype kind, u64 key, u64 val)
{ return (((u64) kind | 0x0000) << 48) | (key << 32) | val; }
/* RFC 5668 4-Octet AS Specific BGP Extended Community */
static inline u64 ec_as4(enum ec_subtype kind, u64 key, u64 val)
{ return (((u64) kind | 0x0200) << 48) | (key << 16) | val; }
/* RFC 4360 3.2. IPv4 Address Specific Extended Community */
static inline u64 ec_ip4(enum ec_subtype kind, u64 key, u64 val)
{ return (((u64) kind | 0x0100) << 48) | (key << 16) | val; }
static inline u64 ec_generic(u64 key, u64 val)
{ return (key << 32) | val; }
/* Large community value */
typedef struct lcomm {
u32 asn;
u32 ldp1;
u32 ldp2;
} lcomm;
#define LCOMM_LENGTH 12
static inline lcomm lc_get(const u32 *l, int i)
{ return (lcomm) { l[i], l[i+1], l[i+2] }; }
static inline void lc_put(u32 *l, lcomm v)
{ l[0] = v.asn; l[1] = v.ldp1; l[2] = v.ldp2; }
static inline int lc_match(const u32 *l, int i, lcomm v)
{ return (l[i] == v.asn && l[i+1] == v.ldp1 && l[i+2] == v.ldp2); }
static inline u32 *lc_copy(u32 *dst, const u32 *src)
{ memcpy(dst, src, LCOMM_LENGTH); return dst + 3; }
enum isf_way {
ISF_NUMBERS,
ISF_COMMUNITY_LIST,
ISF_ROUTER_ID,
};
int int_set_format(const struct adata *set, enum isf_way way, int from, byte *buf, uint size) ACCESS_WRITE(4, 5);
int ec_format(byte *buf, u64 ec);
int ec_set_format(const struct adata *set, int from, byte *buf, uint size) ACCESS_WRITE(3, 4);
int lc_format(byte *buf, lcomm lc);
int lc_set_format(const struct adata *set, int from, byte *buf, uint size) ACCESS_WRITE(3, 4);
int int_set_contains(const struct adata *list, u32 val);
int ec_set_contains(const struct adata *list, u64 val);
int lc_set_contains(const struct adata *list, lcomm val);
const struct adata *int_set_prepend(struct linpool *pool, const struct adata *list, u32 val);
const struct adata *int_set_add(struct linpool *pool, const struct adata *list, u32 val);
const struct adata *ec_set_add(struct linpool *pool, const struct adata *list, u64 val);
const struct adata *lc_set_add(struct linpool *pool, const struct adata *list, lcomm val);
const struct adata *int_set_del(struct linpool *pool, const struct adata *list, u32 val);
const struct adata *ec_set_del(struct linpool *pool, const struct adata *list, u64 val);
const struct adata *lc_set_del(struct linpool *pool, const struct adata *list, lcomm val);
const struct adata *int_set_union(struct linpool *pool, const struct adata *l1, const struct adata *l2);
const struct adata *ec_set_union(struct linpool *pool, const struct adata *l1, const struct adata *l2);
const struct adata *lc_set_union(struct linpool *pool, const struct adata *l1, const struct adata *l2);
struct adata *ec_set_del_nontrans(struct linpool *pool, const struct adata *set);
struct adata *int_set_sort(struct linpool *pool, const struct adata *src);
struct adata *ec_set_sort(struct linpool *pool, const struct adata *src);
struct adata *lc_set_sort(struct linpool *pool, const struct adata *src);
int int_set_min(const struct adata *list, u32 *val);
int ec_set_min(const struct adata *list, u64 *val);
int lc_set_min(const struct adata *list, lcomm *val);
int int_set_max(const struct adata *list, u32 *val);
int ec_set_max(const struct adata *list, u64 *val);
int lc_set_max(const struct adata *list, lcomm *val);
int int_set_walk(const struct adata *list, uint *pos, u32 *val);
int ec_set_walk(const struct adata *list, uint *pos, u64 *val);
int lc_set_walk(const struct adata *list, uint *pos, lcomm *val);
int rte_set_walk(const struct adata *list, u32 *pos, struct rte **val);
void ec_set_sort_x(struct adata *set); /* Sort in place */
#endif
bird2-2.17.5/nest/bfd.h 0000664 0000000 0000000 00000003726 15211753245 0014502 0 ustar 00root root 0000000 0000000 /*
* BIRD -- Bidirectional Forwarding Detection (BFD)
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_NBFD_H_
#define _BIRD_NBFD_H_
#include "lib/lists.h"
#include "lib/resource.h"
#include "conf/conf.h"
struct bfd_session;
struct bfd_options {
u32 min_rx_int;
u32 min_tx_int;
u32 idle_tx_int;
u8 multiplier;
u8 passive;
u8 passive_set;
u8 mode;
u8 auth_type; /* Authentication type (BFD_AUTH_*) */
list *passwords; /* Passwords for authentication */
};
struct bfd_request {
resource r;
node n;
ip_addr addr;
ip_addr local;
struct iface *iface;
struct iface *vrf;
struct bfd_options opts;
void (*hook)(struct bfd_request *);
void *data;
struct bfd_session *session;
u8 state;
u8 diag;
u8 old_state;
u8 down;
};
#define BGP_BFD_GRACEFUL 2 /* BFD down triggers graceful restart */
#define BFD_STATE_ADMIN_DOWN 0
#define BFD_STATE_DOWN 1
#define BFD_STATE_INIT 2
#define BFD_STATE_UP 3
static inline struct bfd_options * bfd_new_options(void)
{ return cfg_allocz(sizeof(struct bfd_options)); }
#ifdef CONFIG_BFD
struct bfd_request * bfd_request_session(pool *p, ip_addr addr, ip_addr local, struct iface *iface, struct iface *vrf, void (*hook)(struct bfd_request *), void *data, const struct bfd_options *opts);
void bfd_update_request(struct bfd_request *req, const struct bfd_options *opts);
static inline void cf_check_bfd(int use UNUSED) { }
#else
static inline struct bfd_request * bfd_request_session(pool *p UNUSED, ip_addr addr UNUSED, ip_addr local UNUSED, struct iface *iface UNUSED, struct iface *vrf UNUSED, void (*hook)(struct bfd_request *) UNUSED, void *data UNUSED, const struct bfd_options *opts UNUSED) { return NULL; }
static inline void bfd_update_request(struct bfd_request *req UNUSED, const struct bfd_options *opts UNUSED) { };
static inline void cf_check_bfd(int use) { if (use) cf_error("BFD not available"); }
#endif /* CONFIG_BFD */
#endif /* _BIRD_NBFD_H_ */
bird2-2.17.5/nest/bird.h 0000664 0000000 0000000 00000000507 15211753245 0014661 0 ustar 00root root 0000000 0000000 /*
* BIRD Internet Routing Daemon -- Basic Declarations
*
* (c) 1998--2000 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_BIRD_H_
#define _BIRD_BIRD_H_
#include "sysdep/config.h"
#include "lib/birdlib.h"
#include "lib/ip.h"
#include "lib/net.h"
#endif
bird2-2.17.5/nest/cli.c 0000664 0000000 0000000 00000026150 15211753245 0014505 0 ustar 00root root 0000000 0000000 /*
* BIRD Internet Routing Daemon -- Command-Line Interface
*
* (c) 1999--2000 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
/**
* DOC: Command line interface
*
* This module takes care of the BIRD's command-line interface (CLI).
* The CLI exists to provide a way to control BIRD remotely and to inspect
* its status. It uses a very simple textual protocol over a stream
* connection provided by the platform dependent code (on UNIX systems,
* it's a UNIX domain socket).
*
* Each session of the CLI consists of a sequence of request and replies,
* slightly resembling the FTP and SMTP protocols.
* Requests are commands encoded as a single line of text, replies are
* sequences of lines starting with a four-digit code followed by either
* a space (if it's the last line of the reply) or a minus sign (when the
* reply is going to continue with the next line), the rest of the line
* contains a textual message semantics of which depends on the numeric
* code. If a reply line has the same code as the previous one and it's
* a continuation line, the whole prefix can be replaced by a single
* white space character.
*
* Reply codes starting with 0 stand for `action successfully completed' messages,
* 1 means `table entry', 8 `runtime error' and 9 `syntax error'.
*
* Each CLI session is internally represented by a &cli structure and a
* resource pool containing all resources associated with the connection,
* so that it can be easily freed whenever the connection gets closed, not depending
* on the current state of command processing.
*
* The CLI commands are declared as a part of the configuration grammar
* by using the |CF_CLI| macro. When a command is received, it is processed
* by the same lexical analyzer and parser as used for the configuration, but
* it's switched to a special mode by prepending a fake token to the text,
* so that it uses only the CLI command rules. Then the parser invokes
* an execution routine corresponding to the command, which either constructs
* the whole reply and returns it back or (in case it expects the reply will be long)
* it prints a partial reply and asks the CLI module (using the @cont hook)
* to call it again when the output is transferred to the user.
*
* The @this_cli variable points to a &cli structure of the session being
* currently parsed, but it's of course available only in command handlers
* not entered using the @cont hook.
*
* TX buffer management works as follows: At cli.tx_buf there is a
* list of TX buffers (struct cli_out), cli.tx_write is the buffer
* currently used by the producer (cli_printf(), cli_alloc_out()) and
* cli.tx_pos is the buffer currently used by the consumer
* (cli_write(), in system dependent code). The producer uses
* cli_out.wpos ptr as the current write position and the consumer
* uses cli_out.outpos ptr as the current read position. When the
* producer produces something, it calls cli_write_trigger(). If there
* is not enough space in the current buffer, the producer allocates
* the new one. When the consumer processes everything in the buffer
* queue, it calls cli_written(), tha frees all buffers (except the
* first one) and schedules cli.event .
*
*/
#include "nest/bird.h"
#include "nest/cli.h"
#include "conf/conf.h"
#include "lib/string.h"
pool *cli_pool;
static byte *
cli_alloc_out(cli *c, int size)
{
struct cli_out *o;
if (!(o = c->tx_write) || o->wpos + size > o->end)
{
if (!o && c->tx_buf)
o = c->tx_buf;
else
{
o = mb_alloc(c->pool, sizeof(struct cli_out) + CLI_TX_BUF_SIZE);
if (c->tx_write)
c->tx_write->next = o;
else
c->tx_buf = o;
o->wpos = o->outpos = o->buf;
o->end = o->buf + CLI_TX_BUF_SIZE;
}
c->tx_write = o;
if (!c->tx_pos)
c->tx_pos = o;
o->next = NULL;
}
o->wpos += size;
return o->wpos - size;
}
/**
* cli_printf - send reply to a CLI connection
* @c: CLI connection
* @code: numeric code of the reply, negative for continuation lines
* @msg: a printf()-like formatting string.
*
* This function send a single line of reply to a given CLI connection.
* In works in all aspects like bsprintf() except that it automatically
* prepends the reply line prefix.
*
* Please note that if the connection can be already busy sending some
* data in which case cli_printf() stores the output to a temporary buffer,
* so please avoid sending a large batch of replies without waiting
* for the buffers to be flushed.
*
* If you want to write to the current CLI output, you can use the cli_msg()
* macro instead.
*/
void
cli_vprintf(cli *c, int code, const char *msg, va_list args)
{
byte buf[CLI_LINE_SIZE];
int cd = code;
int errcode;
int size, cnt;
if (cd < 0)
{
cd = -cd;
if (cd == c->last_reply)
size = bsprintf(buf, " ");
else
size = bsprintf(buf, "%04d-", cd);
errcode = -8000;
}
else if (cd == CLI_ASYNC_CODE)
{
size = 1; buf[0] = '+';
errcode = cd;
}
else
{
size = bsprintf(buf, "%04d ", cd);
errcode = 8000;
cd = 0; /* Final message - no more continuation lines */
}
c->last_reply = cd;
cnt = bvsnprintf(buf+size, sizeof(buf)-size-1, msg, args);
if (cnt < 0)
{
cli_printf(c, errcode, "");
return;
}
size += cnt;
buf[size++] = '\n';
memcpy(cli_alloc_out(c, size), buf, size);
}
static void
cli_copy_message(cli *c)
{
byte *p, *q;
uint cnt = 2;
if (c->ring_overflow)
{
byte buf[64];
int n = bsprintf(buf, "<%d messages lost>\n", c->ring_overflow);
c->ring_overflow = 0;
memcpy(cli_alloc_out(c, n), buf, n);
}
p = c->ring_read;
while (*p)
{
cnt++;
p++;
if (p == c->ring_end)
p = c->ring_buf;
ASSERT(p != c->ring_write);
}
c->async_msg_size += cnt;
q = cli_alloc_out(c, cnt);
*q++ = '+';
p = c->ring_read;
do
{
*q = *p++;
if (p == c->ring_end)
p = c->ring_buf;
}
while (*q++);
c->ring_read = p;
q[-1] = '\n';
}
static void
cli_hello(cli *c)
{
cli_printf(c, 1, "BIRD " BIRD_VERSION " ready.");
c->cont = NULL;
}
static void
cli_free_out(cli *c)
{
struct cli_out *o, *p;
if (o = c->tx_buf)
{
o->wpos = o->outpos = o->buf;
while (p = o->next)
{
o->next = p->next;
mb_free(p);
}
}
c->tx_write = c->tx_pos = NULL;
c->async_msg_size = 0;
}
void
cli_written(cli *c)
{
cli_free_out(c);
ev_schedule(c->event);
}
static byte *cli_rh_pos;
static uint cli_rh_len;
static int cli_rh_trick_flag;
struct cli *this_cli;
static int
cli_cmd_read_hook(byte *buf, uint max, UNUSED int fd)
{
if (!cli_rh_trick_flag)
{
cli_rh_trick_flag = 1;
buf[0] = '!';
return 1;
}
if (max > cli_rh_len)
max = cli_rh_len;
memcpy(buf, cli_rh_pos, max);
cli_rh_pos += max;
cli_rh_len -= max;
return max;
}
static void
cli_command(struct cli *c)
{
struct config f;
int res;
if (config->cli_debug > 1)
log(L_TRACE "CLI: %s", c->rx_buf);
bzero(&f, sizeof(f));
f.mem = c->parser_pool;
f.pool = rp_new(c->pool, "Config");
init_list(&f.symbols);
cf_read_hook = cli_cmd_read_hook;
cli_rh_pos = c->rx_buf;
cli_rh_len = strlen(c->rx_buf);
cli_rh_trick_flag = 0;
this_cli = c;
lp_flush(c->parser_pool);
res = cli_parse(&f);
if (!res)
cli_printf(c, 9001, f.err_msg);
config_free(&f);
}
static void
cli_event(void *data)
{
cli *c = data;
int err;
while (c->ring_read != c->ring_write &&
c->async_msg_size < CLI_MAX_ASYNC_QUEUE)
cli_copy_message(c);
if (c->tx_pos)
;
else if (c->cont)
c->cont(c);
else
{
err = cli_get_command(c);
if (!err)
return;
if (err < 0)
cli_printf(c, 9000, "Command too long");
else
cli_command(c);
}
cli_write_trigger(c);
}
cli *
cli_new(void *priv, struct cli_config *cf)
{
pool *p = rp_new(cli_pool, "CLI");
cli *c = mb_alloc(p, sizeof(cli));
bzero(c, sizeof(cli));
c->pool = p;
c->priv = priv;
c->event = ev_new(p);
c->event->hook = cli_event;
c->event->data = c;
c->cont = cli_hello;
c->parser_pool = lp_new_default(c->pool);
c->show_pool = lp_new_default(c->pool);
c->rx_buf = mb_alloc(c->pool, CLI_RX_BUF_SIZE);
if (cf->restricted)
c->restricted = 1;
ev_schedule(c->event);
return c;
}
void
cli_kick(cli *c)
{
if (!c->cont && !c->tx_pos)
ev_schedule(c->event);
}
static list cli_log_hooks;
static int cli_log_inited;
void
cli_set_log_echo(cli *c, uint mask, uint size)
{
if (c->ring_buf)
{
mb_free(c->ring_buf);
c->ring_buf = c->ring_end = c->ring_read = c->ring_write = NULL;
rem_node(&c->n);
}
c->log_mask = mask;
if (mask && size)
{
c->ring_buf = mb_alloc(c->pool, size);
c->ring_end = c->ring_buf + size;
c->ring_read = c->ring_write = c->ring_buf;
add_tail(&cli_log_hooks, &c->n);
c->log_threshold = size / 8;
}
c->ring_overflow = 0;
}
void
cli_echo(uint class, byte *msg)
{
unsigned len, free, i, l;
cli *c;
byte *m;
if (!cli_log_inited || EMPTY_LIST(cli_log_hooks))
return;
len = strlen(msg) + 1;
WALK_LIST(c, cli_log_hooks)
{
if (!(c->log_mask & (1 << class)))
continue;
if (c->ring_read <= c->ring_write)
free = (c->ring_end - c->ring_buf) - (c->ring_write - c->ring_read + 1);
else
free = c->ring_read - c->ring_write - 1;
if ((len > free) ||
(free < c->log_threshold && class < (unsigned) L_INFO[0]))
{
c->ring_overflow++;
continue;
}
if (c->ring_read == c->ring_write)
ev_schedule(c->event);
m = msg;
l = len;
while (l)
{
if (c->ring_read <= c->ring_write)
i = c->ring_end - c->ring_write;
else
i = c->ring_read - c->ring_write;
if (i > l)
i = l;
memcpy(c->ring_write, m, i);
m += i;
l -= i;
c->ring_write += i;
if (c->ring_write == c->ring_end)
c->ring_write = c->ring_buf;
}
}
}
/* Set time format override for the current session */
void
cli_set_timeformat(cli *c, const struct timeformat tf)
{
size_t len1 = strlen(tf.fmt1) + 1;
size_t len2 = tf.fmt2 ? strlen(tf.fmt2) + 1 : 0;
if (len1 > TM_DATETIME_BUFFER_SIZE || len2 > TM_DATETIME_BUFFER_SIZE)
{
cli_msg(9003, "Format string too long");
return;
}
struct timeformat *old_tf = c->tf;
struct timeformat *new_tf = mb_allocz(c->pool, sizeof(struct timeformat));
new_tf->fmt1 = memcpy(mb_alloc(c->pool, len1), tf.fmt1, len1);
new_tf->fmt2 = tf.fmt2 ? memcpy(mb_alloc(c->pool, len2), tf.fmt2, len2) : NULL;
new_tf->limit = tf.limit;
c->tf = new_tf;
if (old_tf)
{
mb_free((void *) old_tf->fmt1);
mb_free((void *) old_tf->fmt2);
mb_free(old_tf);
}
cli_msg(0, "");
}
/* Hack for scheduled undo notification */
extern cli *cmd_reconfig_stored_cli;
void
cli_free(cli *c)
{
cli_set_log_echo(c, 0, 0);
if (c->cleanup)
c->cleanup(c);
if (c == cmd_reconfig_stored_cli)
cmd_reconfig_stored_cli = NULL;
rfree(c->pool);
}
/**
* cli_init - initialize the CLI module
*
* This function is called during BIRD startup to initialize
* the internal data structures of the CLI module.
*/
void
cli_init(void)
{
cli_pool = rp_new(&root_pool, "CLI");
init_list(&cli_log_hooks);
cli_log_inited = 1;
}
bird2-2.17.5/nest/cli.h 0000664 0000000 0000000 00000006117 15211753245 0014513 0 ustar 00root root 0000000 0000000 /*
* BIRD Internet Routing Daemon -- Command-Line Interface
*
* (c) 1999--2000 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#ifndef _BIRD_CLI_H_
#define _BIRD_CLI_H_
#include "lib/resource.h"
#include "lib/event.h"
#include "lib/timer.h"
#include "lib/tlists.h"
#include "conf/conf.h"
#define CLI_RX_BUF_SIZE 4096
#define CLI_TX_BUF_SIZE 4096
#define CLI_MAX_ASYNC_QUEUE 4096
#define CLI_MSG_SIZE 500
#define CLI_LINE_SIZE 512
struct cli_out {
struct cli_out *next;
byte *wpos, *outpos, *end;
byte buf[0];
};
typedef struct cli {
node n; /* Node in list of all log hooks */
pool *pool;
void *priv; /* Private to sysdep layer */
byte *rx_buf, *rx_pos; /* sysdep */
struct cli_out *tx_buf, *tx_pos, *tx_write;
event *event;
void (*cont)(struct cli *c);
void (*cleanup)(struct cli *c);
void *rover; /* Private to continuation routine */
int last_reply;
int restricted; /* CLI is restricted to read-only commands */
struct timeformat *tf; /* Time format override */
struct linpool *parser_pool; /* Pool used during parsing */
struct linpool *show_pool; /* Pool used during route show */
byte *ring_buf; /* Ring buffer for asynchronous messages */
byte *ring_end, *ring_read, *ring_write; /* Pointers to the ring buffer */
uint ring_overflow; /* Counter of ring overflows */
uint log_mask; /* Mask of allowed message levels */
uint log_threshold; /* When free < log_threshold, store only important messages */
uint async_msg_size; /* Total size of async messages queued in tx_buf */
} cli;
struct cli_config {
#define TLIST_PREFIX cli_config
#define TLIST_TYPE struct cli_config
#define TLIST_ITEM n
#define TLIST_DEFINED_BEFORE
#define TLIST_WANT_ADD_TAIL
#define TLIST_WANT_WALK
TLIST_DEFAULT_NODE;
const char *name;
struct config *config;
uint uid, gid, mode;
_Bool restricted;
};
#include "lib/tlists.h"
void cli_config_listen(struct cli_config *, const char *);
extern pool *cli_pool;
extern struct cli *this_cli; /* Used during parsing */
#define CLI_ASYNC_CODE 10000
/* Functions to be called by command handlers */
void cli_vprintf(cli *, int, const char *, va_list);
static inline void cli_printf(cli *cli, int code, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
cli_vprintf(cli, code, fmt, args);
va_end(args);
}
#define cli_msg(x...) cli_printf(this_cli, x)
void cli_set_log_echo(cli *, uint mask, uint size);
void cli_set_timeformat(cli *c, const struct timeformat tf);
static inline void cli_separator(cli *c)
{ if (c->last_reply) cli_printf(c, -c->last_reply, ""); };
/* Functions provided to sysdep layer */
cli *cli_new(void *, struct cli_config *);
void cli_init(void);
void cli_free(cli *);
void cli_kick(cli *);
void cli_written(cli *);
void cli_echo(uint class, byte *msg);
static inline int cli_access_restricted(void)
{
if (this_cli && this_cli->restricted)
return (cli_printf(this_cli, 8007, "Access denied"), 1);
else
return 0;
}
/* Functions provided by sysdep layer */
void cli_write_trigger(cli *);
int cli_get_command(cli *);
#endif
bird2-2.17.5/nest/cmds.c 0000664 0000000 0000000 00000010137 15211753245 0014662 0 ustar 00root root 0000000 0000000 /*
* BIRD Internet Routing Daemon -- CLI Commands Which Don't Fit Anywhere Else
*
* (c) 2000 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "nest/bird.h"
#include "nest/protocol.h"
#include "nest/route.h"
#include "nest/cli.h"
#include "conf/conf.h"
#include "nest/cmds.h"
#include "lib/string.h"
#include "lib/resource.h"
#include "filter/filter.h"
extern int shutting_down;
extern int configuring;
void
cmd_show_status(void)
{
struct timeformat *tf_base = this_cli->tf ?: &config->tf_base;
byte tim[TM_DATETIME_BUFFER_SIZE];
cli_msg(-1000, "BIRD " BIRD_VERSION);
tm_format_time(tim, tf_base, current_time());
cli_msg(-1011, "Router ID is %R", config->router_id);
cli_msg(-1011, "Hostname is %s", config->hostname);
cli_msg(-1011, "Current server time is %s", tim);
tm_format_time(tim, tf_base, boot_time);
cli_msg(-1011, "Last reboot on %s", tim);
tm_format_time(tim, tf_base, config->load_time);
cli_msg(-1011, "Last reconfiguration on %s", tim);
graceful_restart_show_status();
if (shutting_down)
cli_msg(13, "Shutdown in progress");
else if (configuring)
cli_msg(13, "Reconfiguration in progress");
else
cli_msg(13, "Daemon is up and running");
}
void
cmd_show_symbols(struct sym_show_data *sd)
{
if (sd->sym)
cli_msg(1010, "%-8s\t%s", sd->sym->name, cf_symbol_class_name(sd->sym));
else
{
for (const struct sym_scope *scope = config->root_scope; scope; scope = scope->next)
HASH_WALK(scope->hash, next, sym)
{
if (!sym->scope->active)
continue;
if (sd->type && (sym->class != sd->type))
continue;
cli_msg(-1010, "%-8s\t%s", sym->name, cf_symbol_class_name(sym));
}
HASH_WALK_END;
cli_msg(0, "");
}
}
#define SIZE_SUFFIX " kMGT"
#define SIZE_FORMAT "% 4u.%1u % 1cB"
#define SIZE_ARGS(a) (a).val, (a).decimal, SIZE_SUFFIX[(a).magnitude]
struct size_args {
u64 val:48;
u64 decimal:8;
u64 magnitude:8;
};
static struct size_args
get_size_args(u64 val)
{
#define VALDEC 10 /* One decimal place */
val *= VALDEC;
uint i = 0;
while ((val >= 10000 * VALDEC) && (i < 4))
{
val = (val + 512) / 1024;
i++;
}
return (struct size_args) {
.val = (val / VALDEC),
.decimal = (val % VALDEC),
.magnitude = i,
};
}
static void
print_size(char *dsc, struct resmem vals)
{
struct size_args effective = get_size_args(vals.effective);
struct size_args overhead = get_size_args(vals.overhead);
cli_msg(-1018, "%-17s " SIZE_FORMAT " " SIZE_FORMAT, dsc, SIZE_ARGS(effective), SIZE_ARGS(overhead));
}
extern pool *rt_table_pool;
extern pool *rta_pool;
extern uint *pages_kept;
extern uint pages_kept_cold, pages_kept_cold_index, pages_total;
void
cmd_show_memory(void)
{
cli_msg(-1018, "BIRD memory usage");
cli_msg(-1018, "%-17s Effective Overhead", "");
print_size("Routing tables:", rmemsize(rt_table_pool));
print_size("Route attributes:", rmemsize(rta_pool));
print_size("Protocols:", rmemsize(proto_pool));
print_size("Current config:", rmemsize(config_pool));
struct resmem total = rmemsize(&root_pool);
#ifdef HAVE_MMAP
uint pages_standby = *pages_kept + pages_kept_cold_index;
print_size("Standby memory:", (struct resmem) { .overhead = page_size * pages_standby });
total.overhead += page_size * pages_standby;
#endif
print_size("Total:", total);
cli_msg(-1018, "");
uint pages_active = pages_total - *pages_kept - pages_kept_cold;
struct size_args active = get_size_args(page_size * pages_active);
struct size_args kept = get_size_args(page_size * *pages_kept);
struct size_args cold = get_size_args(page_size * pages_kept_cold);
cli_msg(-1018, "%-17s " SIZE_FORMAT, "Active pages:", SIZE_ARGS(active));
cli_msg(-1018, "%-17s " SIZE_FORMAT, "Kept free pages:", SIZE_ARGS(kept));
cli_msg(-1018, "%-17s " SIZE_FORMAT, "Cold free pages:", SIZE_ARGS(cold));
cli_msg(0, "");
}
void
cmd_eval(const struct f_line *expr)
{
buffer buf;
LOG_BUFFER_INIT(buf);
if (f_eval_buf(expr, this_cli->parser_pool, &buf) > F_RETURN)
{
cli_msg(8008, "runtime error");
return;
}
cli_msg(23, "%s", buf.start);
}
bird2-2.17.5/nest/cmds.h 0000664 0000000 0000000 00000000721 15211753245 0014665 0 ustar 00root root 0000000 0000000 /*
* BIRD Internet Routing Daemon -- CLI Commands Which Don't Fit Anywhere Else
*
* (c) 2000 Martin Mares
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
struct sym_show_data {
int type; /* Symbols type to show */
struct symbol *sym;
};
struct f_inst;
void cmd_show_status(void);
void cmd_show_symbols(struct sym_show_data *sym);
void cmd_show_memory(void);
struct f_line;
void cmd_eval(const struct f_line *expr);
bird2-2.17.5/nest/config.Y 0000664 0000000 0000000 00000071253 15211753245 0015175 0 ustar 00root root 0000000 0000000 /*
* BIRD -- Core Configuration
*
* (c) 1998--2000 Martin Mares
* (c) 2004 Ondrej Filip
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
CF_HDR
#include "nest/rt-dev.h"
#include "nest/password.h"
#include "nest/cmds.h"
#include "nest/mpls.h"
#include "lib/lists.h"
#include "lib/mac.h"
CF_DEFINES
static struct rtable_config *this_table;
static struct proto_config *this_proto;
static struct channel_config *this_channel;
static struct iface_patt *this_ipatt;
static struct iface_patt_node *this_ipn;
/* static struct roa_table_config *this_roa_table; */
static list *this_p_list;
static struct password_item *this_p_item;
static int password_id;
static struct bfd_options *this_bfd_opts;
static void
iface_patt_check(void)
{
struct iface_patt_node *pn;
WALK_LIST(pn, this_ipatt->ipn_list)
if (!pn->pattern || pn->prefix.type)
cf_error("Interface name/mask expected, not IP prefix");
}
static inline void
init_password_list(void)
{
if (!this_p_list) {
this_p_list = cfg_allocz(sizeof(list));
init_list(this_p_list);
password_id = 1;
}
}
static inline void
init_password(const void *key, uint length, uint id)
{
this_p_item = cfg_allocz(sizeof (struct password_item));
this_p_item->password = key;
this_p_item->length = length;
this_p_item->genfrom = 0;
this_p_item->gento = TIME_INFINITY;
this_p_item->accfrom = 0;
this_p_item->accto = TIME_INFINITY;
this_p_item->id = id;
this_p_item->alg = ALG_UNDEFINED;
add_tail(this_p_list, &this_p_item->n);
}
static inline void
reset_passwords(void)
{
this_p_list = NULL;
}
static inline list *
get_passwords(void)
{
list *rv = this_p_list;
this_p_list = NULL;
return rv;
}
static inline void
init_bfd_opts(struct bfd_options **opts)
{
cf_check_bfd(1);
if (! *opts)
*opts = bfd_new_options();
}
static inline void
open_bfd_opts(struct bfd_options **opts)
{
init_bfd_opts(opts);
this_bfd_opts = *opts;
}
static inline void
close_bfd_opts(void)
{
this_bfd_opts = NULL;
}
static void
proto_postconfig(void)
{
CALL(this_proto->protocol->postconfig, this_proto);
this_channel = NULL;
this_proto = NULL;
}
#define DIRECT_CFG ((struct rt_dev_config *) this_proto)
CF_DECLS
CF_KEYWORDS(ROUTER, ID, HOSTNAME, PROTOCOL, TEMPLATE, PREFERENCE, DISABLED, DEBUG, ALL, OFF, DIRECT)
CF_KEYWORDS(INTERFACE, IMPORT, EXPORT, FILTER, NONE, VRF, DEFAULT, TABLE, TABLES, STATES, ROUTES, FILTERS)
CF_KEYWORDS(IPV4, IPV6, VPN4, VPN6, ROA4, ROA6, FLOW4, FLOW6, SADR, MPLS, ASPA)
CF_KEYWORDS(RECEIVE, LIMIT, ACTION, WARN, BLOCK, RESTART, DISABLE, KEEP, FILTERED, RPKI)
CF_KEYWORDS(PASSWORD, KEY, FROM, PASSIVE, TO, ID, EVENTS, PACKETS, PROTOCOLS, CHANNELS, INTERFACES)
CF_KEYWORDS(ALGORITHM, KEYED, HMAC, MD5, SHA1, SHA256, SHA384, SHA512, BLAKE2S128, BLAKE2S256, BLAKE2B256, BLAKE2B512)
CF_KEYWORDS(PRIMARY, STATS, COUNT, FOR, IN, COMMANDS, PREEXPORT, NOEXPORT, EXPORTED, GENERATE)
CF_KEYWORDS(BGP, PASSWORDS, DESCRIPTION)
CF_KEYWORDS(RELOAD, IN, OUT, MRTDUMP, MESSAGES, RESTRICT, MEMORY, IGP_METRIC, CLASS, DSCP)
CF_KEYWORDS(TIMEFORMAT, ISO, SHORT, LONG, ROUTE, PROTOCOL, BASE, LOG, S, MS, US)
CF_KEYWORDS(GRACEFUL, RESTART, WAIT, MAX, AS)
CF_KEYWORDS(CHECK, LINK)
CF_KEYWORDS(SORTED, TRIE, MIN, MAX, SETTLE, TIME, GC, THRESHOLD, PERIOD)
CF_KEYWORDS(MPLS_LABEL, MPLS_POLICY, MPLS_CLASS)
CF_KEYWORDS(ASPA_PROVIDERS)
/* For r_args_channel */
CF_KEYWORDS(IPV4, IPV4_MC, IPV4_MPLS, IPV6, IPV6_MC, IPV6_MPLS, IPV6_SADR, VPN4, VPN4_MC, VPN4_MPLS, VPN6, VPN6_MC, VPN6_MPLS, ROA4, ROA6, FLOW4, FLOW6, MPLS, PRI, SEC, ASPA)
CF_ENUM(T_ENUM_NET_TYPE, NET_, IP4, IP6, VPN4, VPN6, ROA4, ROA6, FLOW4, FLOW6, IP6_SADR, MPLS, ASPA)
CF_ENUM(T_ENUM_RTS, RTS_, STATIC, INHERIT, DEVICE, STATIC_DEVICE, REDIRECT,
RIP, OSPF, OSPF_IA, OSPF_EXT1, OSPF_EXT2, BGP, PIPE, BABEL, RPKI, L3VPN,
AGGREGATED)
CF_ENUM(T_ENUM_SCOPE, SCOPE_, HOST, LINK, SITE, ORGANIZATION, UNIVERSE, UNDEFINED)
CF_ENUM(T_ENUM_RTD, RTD_, UNICAST, BLACKHOLE, UNREACHABLE, PROHIBIT)
CF_ENUM(T_ENUM_ROA, ROA_, UNKNOWN, VALID, INVALID)
CF_ENUM(T_ENUM_ASPA, ASPA_, UNKNOWN, VALID, INVALID)
CF_ENUM_PX(T_ENUM_AF, AF_, AFI_, IPV4, IPV6)
CF_ENUM(T_ENUM_MPLS_POLICY, MPLS_POLICY_, NONE, STATIC, PREFIX, AGGREGATE, VRF)
%type idval
%type imexport
%type rtable
%type optproto
%type r_args
%type sym_args
%type proto_start echo_mask echo_size debug_mask debug_list debug_flag mrtdump_mask mrtdump_list mrtdump_flag export_mode limit_action net_type net_type_base tos password_algorithm
%type proto_patt proto_patt2
%type channel_start proto_channel
%type limit_spec
%type timeformat_spec
%type timeformat_which
%type r_args_for_val
%type r_args_for
%type channel_sym
%type channel_arg
CF_GRAMMAR
/* Setting of router ID */
conf: rtrid ;
rtrid:
ROUTER ID idval ';' { new_config->router_id = $3; }
| ROUTER ID FROM iface_patt ';' { new_config->router_id_from = this_ipatt; }
;
idval:
NUM { $$ = $1; }
| '(' term ')' { $$ = cf_eval_int($2); }
| IP4 { $$ = ip4_to_u32($1); }
| CF_SYM_KNOWN {
if ($1->class == (SYM_CONSTANT | T_INT) || $1->class == (SYM_CONSTANT | T_QUAD))
$$ = SYM_VAL($1).i;
else if (($1->class == (SYM_CONSTANT | T_IP)) && ipa_is_ip4(SYM_VAL($1).ip))
$$ = ipa_to_u32(SYM_VAL($1).ip);
else
cf_error("Number or IPv4 address constant expected");
}
;
conf: hostname_override ;
hostname_override: HOSTNAME text ';' { new_config->hostname = $2; } ;
conf: gr_opts ;
gr_opts: GRACEFUL RESTART WAIT expr ';' { new_config->gr_wait = $4; } ;
/* Network types (for tables, channels) */
net_type_base:
IPV4 { $$ = NET_IP4; }
| IPV6 { $$ = NET_IP6; }
| IPV6 SADR { $$ = NET_IP6_SADR; }
| VPN4 { $$ = NET_VPN4; }
| VPN6 { $$ = NET_VPN6; }
| ROA4 { $$ = NET_ROA4; }
| ROA6 { $$ = NET_ROA6; }
| FLOW4{ $$ = NET_FLOW4; }
| FLOW6{ $$ = NET_FLOW6; }
| ASPA { $$ = NET_ASPA; }
;
net_type:
net_type_base
| MPLS { $$ = NET_MPLS; }
;
/* Creation of routing tables */
conf: table ;
table: table_start table_sorted table_opt_list ;
table_start: net_type TABLE symbol {
this_table = rt_new_table($3, $1);
}
;
table_sorted:
/* empty */
| SORTED { this_table->sorted = 1; }
;
table_opt:
SORTED bool { this_table->sorted = $2; }
| DEBUG debug_mask { this_table->debug = $2; }
| TRIE bool {
if (!net_val_match(this_table->addr_type, NB_IP | NB_VPN | NB_ROA | NB_IP6_SADR))
cf_error("Trie option not supported for %s table", net_label[this_table->addr_type]);
this_table->trie_used = $2;
}
| MIN SETTLE TIME expr_us { this_table->min_settle_time = $4; }
| MAX SETTLE TIME expr_us { this_table->max_settle_time = $4; }
| GC THRESHOLD expr { this_table->gc_threshold = $3; }
| GC PERIOD expr_us { this_table->gc_period = (uint) $3; if ($3 > 3600 S_) cf_error("GC period must be at most 3600 s"); }
;
table_opts:
/* empty */
| table_opts table_opt ';'
;
table_opt_list:
/* empty */
| '{' table_opts '}'
;
/* Definition of protocols */
conf: proto { proto_postconfig(); } ;
proto_start:
PROTOCOL { $$ = SYM_PROTO; }
| TEMPLATE { $$ = SYM_TEMPLATE; }
;
proto_name:
/* EMPTY */ {
struct symbol *s = cf_default_name(new_config, this_proto->protocol->template, &this_proto->protocol->name_counter);
s->class = this_proto->class;
s->proto = this_proto;
this_proto->name = s->name;
}
| symbol {
cf_define_symbol(new_config, $1, this_proto->class, proto, this_proto);
this_proto->name = $1->name;
}
| FROM CF_SYM_KNOWN {
if (($2->class != SYM_TEMPLATE) && ($2->class != SYM_PROTO)) cf_error("Template or protocol name expected");
struct symbol *s = cf_default_name(new_config, this_proto->protocol->template, &this_proto->protocol->name_counter);
s->class = this_proto->class;
s->proto = this_proto;
this_proto->name = s->name;
proto_copy_config(this_proto, $2->proto);
}
| symbol FROM CF_SYM_KNOWN {
if (($3->class != SYM_TEMPLATE) && ($3->class != SYM_PROTO)) cf_error("Template or protocol name expected");
cf_define_symbol(new_config, $1, this_proto->class, proto, this_proto);
this_proto->name = $1->name;
proto_copy_config(this_proto, $3->proto);
}
;
proto_item:
/* EMPTY */
| DISABLED bool { this_proto->disabled = $2; }
| DEBUG debug_mask { this_proto->debug = $2; }
| MRTDUMP mrtdump_mask { this_proto->mrtdump = $2; }
| ROUTER ID idval { this_proto->router_id = $3; }
| HOSTNAME text { this_proto->hostname = $2; }
| DESCRIPTION text { this_proto->dsc = $2; }
| VRF text { this_proto->vrf = if_get_by_name($2); this_proto->vrf_set = 1; }
| VRF DEFAULT { this_proto->vrf = NULL; this_proto->vrf_set = 1; }
;
channel_start: net_type_base
{
$$ = this_channel = channel_config_get(NULL, net_label[$1], $1, this_proto);
};
channel_item_:
TABLE rtable {
if (this_channel->net_type && ($2->addr_type != this_channel->net_type))
cf_error("Incompatible table type");
this_channel->table = $2;
}
| IMPORT imexport { this_channel->in_filter = $2; }
| EXPORT imexport { this_channel->out_filter = $2; }
| RECEIVE LIMIT limit_spec { this_channel->rx_limit = $3; }
| IMPORT LIMIT limit_spec { this_channel->in_limit = $3; }
| EXPORT LIMIT limit_spec { this_channel->out_limit = $3; }
| PREFERENCE expr { this_channel->preference = $2; check_u16($2); }
| IMPORT KEEP FILTERED bool { this_channel->in_keep_filtered = $4; }
| RPKI RELOAD bool { this_channel->rpki_reload = $3; }
;
/* To avoid grammar collision in Pipe protocol */
channel_item:
channel_item_
| DEBUG debug_mask { this_channel->debug = $2; }
;
channel_opts:
/* empty */
| channel_opts channel_item ';'
;
channel_opt_list:
/* empty */
| '{' channel_opts '}'
;
channel_end:
{
if (!this_channel->table)
cf_error("Routing table not specified");
this_channel = NULL;
};
proto_channel: channel_start channel_opt_list channel_end;
rtable: CF_SYM_KNOWN { cf_assert_symbol($1, SYM_TABLE); $$ = $1->table; } ;
imexport:
FILTER filter { $$ = $2; }
| where_filter
| ALL { $$ = FILTER_ACCEPT; }
| NONE { $$ = FILTER_REJECT; }
;
limit_action:
/* default */ { $$ = PLA_DISABLE; }
| ACTION WARN { $$ = PLA_WARN; }
| ACTION BLOCK { $$ = PLA_BLOCK; }
| ACTION RESTART { $$ = PLA_RESTART; }
| ACTION DISABLE { $$ = PLA_DISABLE; }
;
limit_spec:
expr limit_action { $$ = (struct channel_limit){ .limit = $1, $$.action = $2 }; }
| OFF { $$ = (struct channel_limit){}; }
;
conf: debug_default ;
debug_default:
DEBUG PROTOCOLS debug_mask { new_config->proto_default_debug = $3; }
| DEBUG CHANNELS debug_mask { new_config->channel_default_debug = $3; }
| DEBUG TABLES debug_mask { new_config->table_default_debug = $3; }
| DEBUG COMMANDS expr { new_config->cli_debug = $3; }
;
/* MRTDUMP PROTOCOLS is in systep/unix/config.Y */
conf: timeformat_base ;
timeformat_base:
TIMEFORMAT timeformat_which timeformat_spec ';' { *$2 = $3; }
;
timeformat_which:
ROUTE { $$ = &new_config->tf_route; }
| PROTOCOL { $$ = &new_config->tf_proto; }
| BASE { $$ = &new_config->tf_base; }
| LOG { $$ = &new_config->tf_log; }
;
timeformat_spec:
TEXT { $$ = (struct timeformat){$1, NULL, 0}; }
| TEXT expr TEXT { $$ = (struct timeformat){$1, $3, (s64) $2 S_}; }
| ISO SHORT { $$ = TM_ISO_SHORT_S; }
| ISO SHORT MS { $$ = TM_ISO_SHORT_MS; }
| ISO SHORT US { $$ = TM_ISO_SHORT_US; }
| ISO LONG { $$ = TM_ISO_LONG_S; }
| ISO LONG MS { $$ = TM_ISO_LONG_MS; }
| ISO LONG US { $$ = TM_ISO_LONG_US; }
;
/* Interface patterns */
iface_patt_node_init:
/* EMPTY */ {
struct iface_patt_node *ipn = cfg_allocz(sizeof(struct iface_patt_node));
add_tail(&this_ipatt->ipn_list, NODE ipn);
this_ipn = ipn;
}
;
iface_patt_node_body:
TEXT { this_ipn->pattern = $1; /* this_ipn->prefix stays zero */ }
| opttext net_or_ipa { this_ipn->pattern = $1; this_ipn->prefix = $2; }
;
iface_negate:
{ this_ipn->positive = 1; }
| '-' { this_ipn->positive = 0; }
;
iface_patt_node:
iface_patt_node_init iface_negate iface_patt_node_body
;
iface_patt_list:
iface_patt_node
| iface_patt_list ',' iface_patt_node
;
/* For name/mask-only iface patterns */
iface_patt_list_nopx: iface_patt_list { iface_patt_check(); }
iface_patt_init: {
/* Generic this_ipatt init */
this_ipatt = cfg_allocz(sizeof(struct iface_patt));
init_list(&this_ipatt->ipn_list);
}
;
iface_patt:
iface_patt_init iface_patt_list
;
tos:
CLASS expr { $$ = $2 & 0xfc; if ($2 > 255) cf_error("TX class must be in range 0-255"); }
| DSCP expr { $$ = ($2 & 0x3f) << 2; if ($2 > 63) cf_error("TX DSCP must be in range 0-63"); }
;
/* Direct device route protocol */
proto: dev_proto '}' ;
dev_proto_start: proto_start DIRECT {
this_proto = proto_config_new(&proto_device, $1);
init_list(&DIRECT_CFG->iface_list);
}
;
dev_proto:
dev_proto_start proto_name '{'
| dev_proto proto_item ';'
| dev_proto proto_channel ';'
| dev_proto dev_iface_patt ';'
| dev_proto CHECK LINK bool ';' { DIRECT_CFG->check_link = $4; }
;
dev_iface_init:
/* EMPTY */ {
this_ipatt = cfg_allocz(sizeof(struct iface_patt));
add_tail(&DIRECT_CFG->iface_list, NODE this_ipatt);
init_list(&this_ipatt->ipn_list);
}
;
dev_iface_patt:
INTERFACE dev_iface_init iface_patt_list
;
/* Debug flags */
debug_mask:
ALL { $$ = ~0; }
| OFF { $$ = 0; }
| '{' debug_list '}' { $$ = $2; }
;
debug_list:
debug_flag
| debug_list ',' debug_flag { $$ = $1 | $3; }
;
debug_flag:
STATES { $$ = D_STATES; }
| ROUTES { $$ = D_ROUTES; }
| FILTERS { $$ = D_FILTERS; }
| INTERFACES { $$ = D_IFACES; }
| EVENTS { $$ = D_EVENTS; }
| PACKETS { $$ = D_PACKETS; }
;
/* MRTDump flags */
mrtdump_mask:
ALL { $$ = ~0; }
| OFF { $$ = 0; }
| '{' mrtdump_list '}' { $$ = $2; }
;
mrtdump_list:
mrtdump_flag
| mrtdump_list ',' mrtdump_flag { $$ = $1 | $3; }
;
mrtdump_flag:
STATES { $$ = MD_STATES; }
| MESSAGES { $$ = MD_MESSAGES; }
;
/* Password lists */
password_list:
password_list_body
;
password_list_body:
PASSWORDS '{' password_items '}'
| password_item
;
password_items:
/* empty */
| password_item ';' password_items
;
password_item:
password_item_begin '{' password_item_params '}' password_item_end
| password_item_begin password_item_end
;
pass_key: PASSWORD | KEY;
password_item_begin: pass_key bytestring_text
{
init_password_list();
if ($2.type == T_BYTESTRING)
init_password($2.val.bs->data, $2.val.bs->length, password_id++);
else if ($2.type == T_STRING)
init_password($2.val.s, strlen($2.val.s), password_id++);
else bug("Bad bytestring_text");
};
password_item_params:
/* empty */ { }
| GENERATE FROM time ';' password_item_params { this_p_item->genfrom = $3; }
| GENERATE TO time ';' password_item_params { this_p_item->gento = $3; }
| ACCEPT FROM time ';' password_item_params { this_p_item->accfrom = $3; }
| ACCEPT TO time ';' password_item_params { this_p_item->accto = $3; }
| FROM time ';' password_item_params { this_p_item->genfrom = this_p_item->accfrom = $2; }
| TO time ';' password_item_params { this_p_item->gento = this_p_item->accto = $2; }
| ID expr ';' password_item_params { this_p_item->id = $2; if ($2 > 255) cf_error("Password ID must be in range 0-255"); }
| ALGORITHM password_algorithm ';' password_item_params { this_p_item->alg = $2; }
;
password_algorithm:
KEYED MD5 { $$ = ALG_MD5; }
| KEYED SHA1 { $$ = ALG_SHA1; }
| KEYED SHA256 { $$ = ALG_SHA256; }
| KEYED SHA384 { $$ = ALG_SHA384; }
| KEYED SHA512 { $$ = ALG_SHA512; }
| HMAC MD5 { $$ = ALG_HMAC_MD5; }
| HMAC SHA1 { $$ = ALG_HMAC_SHA1; }
| HMAC SHA256 { $$ = ALG_HMAC_SHA256; }
| HMAC SHA384 { $$ = ALG_HMAC_SHA384; }
| HMAC SHA512 { $$ = ALG_HMAC_SHA512; }
| BLAKE2S128 { $$ = ALG_BLAKE2S_128; }
| BLAKE2S256 { $$ = ALG_BLAKE2S_256; }
| BLAKE2B256 { $$ = ALG_BLAKE2B_256; }
| BLAKE2B512 { $$ = ALG_BLAKE2B_512; }
;
password_item_end:
{
password_validate_length(this_p_item);
};
/* BFD options - just dummy rule, rest in proto/bfd/config.Y */
bfd_opts: '{' INVALID_TOKEN '}';
/* Core commands */
CF_CLI_HELP(SHOW, ..., [[Show status information]])
CF_CLI(SHOW STATUS,,, [[Show router status]])
{ cmd_show_status(); } ;
CF_CLI(SHOW MEMORY,,, [[Show memory usage]])
{ cmd_show_memory(); } ;
CF_CLI(SHOW PROTOCOLS, proto_patt2, [ | \"\"], [[Show routing protocols]])
{ proto_apply_cmd($3, proto_cmd_show, 0, 0); } ;
CF_CLI(SHOW PROTOCOLS ALL, proto_patt2, [ | \"\"], [[Show routing protocol details]])
{ proto_apply_cmd($4, proto_cmd_show, 0, 1); } ;
optproto:
CF_SYM_KNOWN { cf_assert_symbol($1, SYM_PROTO); $$ = $1; }
| /* empty */ { $$ = NULL; }
;
CF_CLI(SHOW INTERFACES,,, [[Show network interfaces]])
{ if_show(); } ;
CF_CLI(SHOW INTERFACES SUMMARY,,, [[Show summary of network interfaces]])
{ if_show_summary(); } ;
CF_CLI_HELP(SHOW ROUTE, ..., [[Show routing table]])
CF_CLI(SHOW ROUTE, r_args, [[[|for |for |in ] [table ] [(import|export) table .] [filter |where ] [all] [primary] [filtered] [(export|preexport|noexport) ] [protocol
] [stats|count]]], [[Show routing table]])
{ rt_show($3); } ;
CF_CLI_OPT(SHOW ROUTE FOR, |)
CF_CLI_OPT(SHOW ROUTE IN, )
CF_CLI_OPT(SHOW ROUTE TABLE, )
CF_CLI_OPT(SHOW ROUTE FILTER, )
CF_CLI_OPT(SHOW ROUTE WHERE, )
CF_CLI_OPT(SHOW ROUTE ALL)
CF_CLI_OPT(SHOW ROUTE PRIMARY)
CF_CLI_OPT(SHOW ROUTE FILTERED)
CF_CLI_OPT(SHOW ROUTE IMPORT, [.])
CF_CLI_OPT(SHOW ROUTE EXPORT, [.])
CF_CLI_OPT(SHOW ROUTE EXPORTED, [.])
CF_CLI_OPT(SHOW ROUTE PREEXPORT, [.])
CF_CLI_OPT(SHOW ROUTE NOEXPORT, [.])
CF_CLI_OPT(SHOW ROUTE PROTOCOL, )
CF_CLI_OPT(SHOW ROUTE STATS)
CF_CLI_OPT(SHOW ROUTE COUNT)
r_args:
/* empty */ {
$$ = cfg_allocz(sizeof(struct rt_show_data));
init_list(&($$->tables));
$$->filter = FILTER_ACCEPT;
$$->running_on_config = config;
}
| r_args net_any {
$$ = $1;
if ($$->addr) cf_error("Only one prefix expected");
$$->addr = $2;
$$->addr_mode = RSD_ADDR_EQUAL;
}
| r_args FOR r_args_for {
$$ = $1;
if ($$->addr) cf_error("Only one prefix expected");
$$->addr = $3;
$$->addr_mode = RSD_ADDR_FOR;
}
| r_args IN net_any {
$$ = $1;
if ($$->addr) cf_error("Only one prefix expected");
if (!net_type_match($3, NB_IP)) cf_error("Only IP networks accepted for 'in' argument");
$$->addr = $3;
$$->addr_mode = RSD_ADDR_IN;
}
| r_args TABLE symbol_known {
cf_assert_symbol($3, SYM_TABLE);
$$ = $1;
rt_show_add_table($$, $3->table->table);
$$->tables_defined_by = RSD_TDB_DIRECT;
}
| r_args TABLE ALL {
struct rtable_config *t;
$$ = $1;
WALK_LIST(t, config->tables)
rt_show_add_table($$, t->table);
$$->tables_defined_by = RSD_TDB_ALL;
}
| r_args IMPORT TABLE channel_arg {
if (!$4->in_table) cf_error("No import table in channel %s.%s", $4->proto->name, $4->name);
rt_show_add_table($$, $4->in_table);
$$->tables_defined_by = RSD_TDB_DIRECT;
}
| r_args EXPORT TABLE channel_arg {
if (!$4->out_table) cf_error("No export table in channel %s.%s", $4->proto->name, $4->name);
rt_show_add_table($$, $4->out_table);
$$->tables_defined_by = RSD_TDB_DIRECT;
}
| r_args FILTER filter {
$$ = $1;
if ($$->filter != FILTER_ACCEPT) cf_error("Filter specified twice");
$$->filter = $3;
}
| r_args where_filter {
$$ = $1;
if ($$->filter != FILTER_ACCEPT) cf_error("Filter specified twice");
$$->filter = $2;
}
| r_args ALL {
$$ = $1;
$$->verbose = 1;
}
| r_args PRIMARY {
$$ = $1;
$$->primary_only = 1;
}
| r_args FILTERED {
$$ = $1;
$$->filtered = 1;
}
| r_args export_mode symbol_known {
cf_assert_symbol($3, SYM_PROTO);
struct proto_config *c = (struct proto_config *) $3->proto;
$$ = $1;
if ($$->export_mode) cf_error("Export specified twice");
if (!c->proto) cf_error("%s is not a protocol", $3->name);
$$->export_mode = $2;
$$->export_protocol = c->proto;
$$->tables_defined_by = RSD_TDB_INDIRECT;
}
| r_args export_mode channel_arg {
$$ = $1;
if ($$->export_mode) cf_error("Export specified twice");
$$->export_mode = $2;
$$->export_channel = $3;
$$->tables_defined_by = RSD_TDB_INDIRECT;
}
| r_args PROTOCOL symbol_known {
cf_assert_symbol($3, SYM_PROTO);
struct proto_config *c = (struct proto_config *) $3->proto;
$$ = $1;
if ($$->show_protocol) cf_error("Protocol specified twice");
if (!c->proto) cf_error("%s is not a protocol", $3->name);
$$->show_protocol = c->proto;
$$->tables_defined_by = RSD_TDB_INDIRECT;
}
| r_args STATS {
$$ = $1;
$$->stats = 1;
}
| r_args COUNT {
$$ = $1;
$$->stats = 2;
}
;
r_args_for:
r_args_for_val {
$$ = cfg_alloc($1.length);
net_copy($$, &$1);
}
| net_vpn4_
| net_vpn6_
| net_ip6_sadr_
| VPN_RD IP4 {
$$ = cfg_alloc(sizeof(net_addr_vpn4));
net_fill_vpn4($$, $2, IP4_MAX_PREFIX_LENGTH, $1);
}
| VPN_RD IP6 {
$$ = cfg_alloc(sizeof(net_addr_vpn6));
net_fill_vpn6($$, $2, IP6_MAX_PREFIX_LENGTH, $1);
}
| IP6 FROM IP6 {
$$ = cfg_alloc(sizeof(net_addr_ip6_sadr));
net_fill_ip6_sadr($$, $1, IP6_MAX_PREFIX_LENGTH, $3, IP6_MAX_PREFIX_LENGTH);
}
| CF_SYM_KNOWN {
if ($1->class == (SYM_CONSTANT | T_IP))
{
$$ = cfg_alloc(ipa_is_ip4(SYM_VAL($1).ip) ? sizeof(net_addr_ip4) : sizeof(net_addr_ip6));
net_fill_ip_host($$, SYM_VAL($1).ip);
}
else if (($1->class == (SYM_CONSTANT | T_NET)) && net_type_match(SYM_VAL($1).net, NB_IP | NB_VPN))
$$ = (net_addr *) SYM_VAL($1).net; /* Avoid const warning */
else
cf_error("IP address or network constant expected");
}
;
r_args_for_val:
net_ip4_
| net_ip6_
| IP4 { net_fill_ip4(&($$), $1, IP4_MAX_PREFIX_LENGTH); }
| IP6 { net_fill_ip6(&($$), $1, IP6_MAX_PREFIX_LENGTH); }
export_mode:
PREEXPORT { $$ = RSEM_PREEXPORT; }
| EXPORT { $$ = RSEM_EXPORT; }
| NOEXPORT { $$ = RSEM_NOEXPORT; }
| EXPORTED { $$ = RSEM_EXPORTED; }
;
/* This is ugly hack */
channel_sym:
IPV4 { $$ = "ipv4"; }
| IPV4_MC { $$ = "ipv4-mc"; }
| IPV4_MPLS { $$ = "ipv4-mpls"; }
| IPV6 { $$ = "ipv6"; }
| IPV6_MC { $$ = "ipv6-mc"; }
| IPV6_MPLS { $$ = "ipv6-mpls"; }
| IPV6_SADR { $$ = "ipv6-sadr"; }
| VPN4 { $$ = "vpn4"; }
| VPN4_MC { $$ = "vpn4-mc"; }
| VPN4_MPLS { $$ = "vpn4-mpls"; }
| VPN6 { $$ = "vpn6"; }
| VPN6_MC { $$ = "vpn6-mc"; }
| VPN6_MPLS { $$ = "vpn6-mpls"; }
| ROA4 { $$ = "roa4"; }
| ROA6 { $$ = "roa6"; }
| FLOW4 { $$ = "flow4"; }
| FLOW6 { $$ = "flow6"; }
| MPLS { $$ = "mpls"; }
| ASPA { $$ = "aspa"; }
| PRI { $$ = "pri"; }
| SEC { $$ = "sec"; }
;
channel_arg:
CF_SYM_KNOWN '.' channel_sym {
cf_assert_symbol($1, SYM_PROTO);
struct proto *p = $1->proto->proto;
if (!p) cf_error("%s is not a protocol", $1->name);
$$ = proto_find_channel_by_name(p, $3);
if (!$$) cf_error("Channel %s.%s not found", $1->name, $3);
}
;
CF_CLI_HELP(SHOW SYMBOLS, ..., [[Show all known symbolic names]])
CF_CLI(SHOW SYMBOLS, sym_args, [table|filter|function|protocol|template|