Add missing closure in bird aspath output

Update information on SOURCES
Bump version
2025-02-28 08:53:11 +00:00 · 2021-08-20 10:58:07 +00:00 · 2021-08-20 10:22:19 +00:00 · 2021-08-20 10:08:59 +00:00 · 2021-08-20 03:51:51 +00:00 · 2021-08-20 03:06:26 +00:00
37 changed files with 4276 additions and 3958 deletions
--- a/.github/images/centos.Dockerfile
+++ b/.github/images/centos.Dockerfile
@@ -4,7 +4,7 @@ FROM $image
 # Install dependencies
 RUN yum update -y
 RUN yum groupinstall -y 'Development Tools'
-RUN yum install -y autoconf automake findutils
+RUN yum install -y autoconf automake findutils libtool

 # Add source code
 ADD . /src
--- a/.github/images/debian.Dockerfile
+++ b/.github/images/debian.Dockerfile
@@ -7,7 +7,10 @@ RUN apt-get update && apt-get install -y locales && rm -rf /var/lib/apt/lists/*
 ENV LANG en_US.utf8

 # Install dependencies
-RUN apt-get update && apt-get dist-upgrade -y && apt-get install -y build-essential autoconf automake markdown && rm -rf /var/lib/apt/lists/*
+RUN apt-get update \
+    && apt-get dist-upgrade -y \
+    && apt-get install -y build-essential autoconf libtool automake markdown \
+    && rm -rf /var/lib/apt/lists/*

 # Add source code
 ADD . /src
--- a/20
+++ b/20
@@ -1,3 +1,23 @@
+1.4 (2021-08-20)
+    - Fix BIRD aspath output
+
+1.3 (2021-08-20)
+    - Change versioning from X.Y.Z to Y.Z
+    - The repository file hierachy has been reorganized (compat/ include/)
+    - Man page has been extended
+    - Large portions of code have been reformatted to adhere to OpenBSD's source
+      file style guide to improve readability.
+    - Refactor: replace two-dimensional array for ASN storage with Red-Black tree
+    - Reduced memory usage
+
+0.0.9 (2021-08-18)
+    - Fix various memory errors
+
+0.0.8 (2021-08-17)
+    - Reorganize automake files and includes
+    - Normalize code to adhere to KNF
+    - Fix all compiler warnings
+
 0.0.6 (2020-03-12):
    - Bugfixes - Thanks Chris Caputo!

--- a/1
+++ b/1
@@ -1,5 +1,4 @@
 /*-
- * Copyright (c) 2019-2020 Job Snijders <job@sobornost.net>
 * Copyright (c) 2007-2019 Alexandre Snarskii <snar@snar.spb.ru>
 * All rights reserved.
 *
--- a/29
+++ b/29
@@ -0,0 +1,29 @@
+Ben Maddison taught me another aggregation trick:
+
+	route-set:      AS37271:RS-EXAMPLE
+	mp-members:     192.0.2.0/27
+	mp-members:     192.0.2.32/27
+	mp-members:     192.0.2.64/27
+	mp-members:     192.0.2.96/27
+	mp-members:     192.0.2.128/26
+	mp-members:     192.0.2.128/27
+	mp-members:     192.0.2.160/27
+	mp-members:     192.0.2.192/27
+	mp-members:     192.0.2.224/27
+	descr:          Example route-set
+	mnt-by:         MAINT-AS37271
+	changed:        benm@workonline.africa 20210819
+	source:         RADB
+
+BGPQ4 produces the following:
+
+	$ bgpq4 -A AS37271:RS-EXAMPLE
+	no ip prefix-list NN
+	ip prefix-list NN permit 192.0.2.0/25 ge 27 le 27
+	ip prefix-list NN permit 192.0.2.128/26 le 27
+	ip prefix-list NN permit 192.0.2.192/26 ge 27 le 27
+
+But the following aggregation also is valid, and shorter:
+
+	ip prefix-list NN permit 192.0.2.0/24 ge 27 le 27
+	ip prefix-list NN permit 192.0.2.128/26
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,14 +1,35 @@
+SUBDIRS = include
+ACLOCAL_AMFLAGS = -I m4
+
+AM_CPPFLAGS = -I$(top_srcdir)/include
+AM_CPPFLAGS += -I$(top_srcdir)/compat
+
 AUTOMAKE_OPTIONS=foreign subdir-objects
+
 bin_PROGRAMS=bgpq4
-bgpq4_SOURCES=bgpq4.c bgpq4.h config.h bgpq4_printer.c bgpq_expander.c \
-			  expander_freeall.c expander_freeall.h strlcpy.c sx_maxsockbuf.c \
-			  sx_maxsockbuf.h sx_prefix.c sx_prefix.h sx_report.c sx_report.h \
-			  sx_slentry.c sx_slentry.h sys_queue.h sys_tree.h
 dist_man8_MANS=bgpq4.8
-EXTRA_DIST=bootstrap README.md CHANGES COPYRIGHT bgpq4.spec
+
+bgpq4_LDADD = $(PLATFORM_LDADD) $(PROG_LDADD)
+
+if !HAVE_STRLCPY
+SUBDIRS += compat
+bgpq4_LDADD += $(top_builddir)/compat/libcompat.la
+endif
+
+bgpq4_SOURCES=main.c extern.h printer.c expander.c \
+    sx_maxsockbuf.c \
+    sx_prefix.c sx_prefix.h \
+    sx_report.c sx_report.h \
+    sx_slentry.c
+
+
+EXTRA_DIST=bootstrap README.md CHANGES
+
 MAINTAINERCLEANFILES=configure aclocal.m4 compile \
                     install-sh missing Makefile.in depcomp \
-                     stamp-h1 config.h.in
+                     stamp-h1 compat/Makefile.in \
+		     config.guess config.sub include/Makefile.in \
+		     ltmain.sh

 maintainer-clean-local:
-	-rm -rf autom4te.cache config.h.in~
+	-rm -rf m4 autom4te.cache
--- a/README.md
+++ b/README.md
@@ -1,237 +1,232 @@
-NAME
----
+# NAME

-`bgpq4` - bgp filtering automation tool
+**bgpq4** - bgp filtering automation tool

-SYNOPSIS
--------
+# SYNOPSIS

-```
-	bgpq4 [-h host[:port]] [-S sources] [-Ez] [-f asn | -F fmt | -G asn | -t] [-46ABbDdeJjNnpsUX] [-a asn] [-r len] [-R len] [-m max] [-W len] OBJECTS [...] EXCEPT OBJECTS
-```
+**bgpq4**
+\[**-h**&nbsp;*host\[:port]*]
+\[**-S**&nbsp;*sources*]
+\[**-EPz**]
+\[**-f**&nbsp;*asn*&nbsp;|
+**-F**&nbsp;*fmt*&nbsp;|
+**-G**&nbsp;*asn*
+**-t**]
+\[**-46ABbDdJjNnsXU**]
+\[**-a**&nbsp;*asn*]
+\[**-r**&nbsp;*len*]
+\[**-R**&nbsp;*len*]
+\[**-m**&nbsp;*max*]
+\[**-W**&nbsp;*len*]
+*OBJECTS*
+\[...]
+\[EXCEPT&nbsp;OBJECTS]

-DESCRIPTION
-----------
+# DESCRIPTION

-The bgpq4 utility used to generate configuration (prefix-lists,
-extended access-lists, policy-statement terms and as-path lists)
-based on IRR routing data.
+The
+**bgpq4**
+utility used to generate configurations (prefix-lists, extended
+access-lists, policy-statement terms and as-path lists) based on RADB data.

 The options are as follows:

-#### -4 
+**-4**

-Generate IPv4 prefix/access-lists (default).
+> generate IPv4 prefix/access-lists (default).

-#### -6      
+**-6**

-Generate IPv6 prefix/access-lists (IPv4 by default).
+> generate IPv6 prefix/access-lists (IPv4 by default).

-#### -A      
+**-A**

-Try to aggregate generated filters as much as possible (not all output formats
-supported).
+> try to aggregate prefix-lists as much as possible (not all output
+> formats supported).

-#### -a asn
+**-a** *asn*

-Specify ASN that shall be denied in case of empty prefix-list (OpenBGPD).
+> specify what asn shall be denied in case of empty prefix-list (OpenBGPD)

-#### -B
+**-B**

-Generate output in OpenBGPD format.
+> generate output in OpenBGPD format (default: Cisco)

-#### -b
+**-b**

-Generate output in BIRD format.
+> generate output in BIRD format (default: Cisco).

-#### -d      
+**-d**

-Enable some debugging output.
+> enable some debugging output.

-#### -E      
+**-e**

-Generate extended access-list (Cisco) or policy-statement term using
-route-filters (Juniper), [ip|ipv6]-prefix-list (Nokia) or prefix-filter
-(OpenBGPD)
+> generate output in Arista EOS format (default: Cisco).

-#### -e
+**-E**

-Generate output in Arista EOS format.
+> generate extended access-list (Cisco), policy-statement term using
+> route-filters (Juniper), \[ip|ipv6]-prefix-list (Nokia) or prefix-sets
+> (OpenBGPd).

-#### -f `AS number`
+**-f** *number*

-Generate input as-path access-list for adjacent as `AS number`.
+> generate input as-path access-list.

-#### -F `fmt`
+**-F** *fmt*

-Generate output in user-defined format.
+> generate output in user-defined format.

-#### -G `number`
+**-G** *number*

-Generate output as-path access-list.
+> generate output as-path access-list.

-#### -h `host[:port]`
+**-h** *host\[:port]*

-Host running IRRD database (default: `rr.ntt.net`).
+> host running IRRD database (default: rr.ntt.net).

-#### -J      
+**-J**

-Generate config for Juniper.
+> generate config for Juniper (default: Cisco).

-#### -j      
+**-j**

-Generate output in JSON format.
+> generate output in JSON format (default: Cisco).

-#### -K
+**-K**

-Generate config for MikroTik.
+> generate config for Mikrotik (default: Cisco).

-#### -m `length`
+**-l** *name*

-Maximum length of accepted prefixes (default: `32` for IPv4, `128` for IPv6).
+> name of generated entry.

-#### -M `match`
+**-L** *limit*

-Extra match conditions for Juniper route-filters. See the examples section.
+> limit recursion depth when expanding as-sets.

-#### -n
+**-m** *len*

-Generate config for Nokia SR OS (former Alcatel-Lucent) MD-CLI.
+> maximum prefix-length of accepted prefixes (default: 32 for IPv4 and
+> 128 for IPv6).

-#### -N
+**-M** *match*

-Generate config for Nokia SR OS (former Alcatel-Lucent) classic CLI.
+> extra match conditions for Juniper route-filters.

-#### -l `name`
+**-n**

-`Name` of generated configuration stanza.
+> generate config for Nokia SR OS MD-CLI (Cisco IOS by default)

-#### -L `limit`
+**-N**

-Limit recursion depth when expanding. This slows `bgpq4` a bit, but sometimes
-is a useful feature to prevent generated filters from growing too big.
+> generate config for Nokia SR OS classic CLI (Cisco IOS by default).

-#### -p
+**-p**

-Enable use of private ASNs and ASNs used for documentation purpose only
-(default: disabled).
+> accept routes registered for private ASNs (default: disabled)

-#### -r `length`
+**-P**

-Allow more-specific routes with masklen starting with specified length.
+> generate prefix-list (default, backward compatibility).

-#### -R `length`
+**-r** *len*

-Allow more-specific routes up to specified masklen too.  (Please, note: objects
-with prefix-length greater than specified length will be always allowed.)
+> allow more specific routes starting with specified masklen too.

-#### -s
+**-R** *len*

-Generate sequence numbers in IOS-style prefix-lists.
+> allow more specific routes up to specified masklen too.

-#### -S `sources`
+**-s**

-Use specified sources only (recommended: RADB,RIPE,APNIC).
+> generate sequence numbers in IOS-style prefix-lists.

-#### -t
+**-S** *sources*

-Generate as-sets for OpenBGPD (OpenBSD 6.4+), BIRD and JSON formats.
+> use specified sources only (recommended: RADB,RIPE,APNIC).

-#### -T      
+**-t**

-Disable pipelining (not recommended).
+> generate as-sets for OpenBGPd, BIRD and JSON formats.

-#### -U
+**-T**

-Generate output in Huawei format.
+> disable pipelining (not recommended).

-#### -W `length`
+**-W** *len*

-Generate as-path strings of a given length maximum (0 for infinity).
+> generate as-path strings of no more than len items (use 0 for inifinity).

-#### -X      
+**-U**

-Generate output in Cisco IOS XR format.
+> generate config for Huawei devices (Cisco IOS by default)

-#### -z
+**-X**

-Generate Juniper route-filter-list (JunOS 16.2+).
+> generate config for Cisco IOS XR devices (plain IOS by default).

-####  `OBJECTS`
+**-z**

-`OBJECTS` means networks (in prefix format), autonomous systems, as-sets and
-route-sets. If multiple objects are specified they will be merged.
+> generate route-filter-lists (JunOS 16.2+).

-#### `EXCEPT OBJECTS`
+*OBJECTS*

-You can exclude autonomous sets, as-sets and route-sets found during
-expansion from future expansion.
+> means networks (in prefix format), autonomous systems, as-sets and route-sets.

-EXAMPLES
--------
-Generating prefix filter for MikroTik for `AS20597`:
+*EXCEPT OBJECTS*

-     $ ./bgpq4 -Kl eltel-v4 AS20597
-     /routing filter add action=accept chain="eltel-v4" prefix=81.9.0.0/20
-     /routing filter add action=accept chain="eltel-v4" prefix=81.9.32.0/20
-     /routing filter add action=accept chain="eltel-v4" prefix=81.9.96.0/20
-     /routing filter add action=accept chain="eltel-v4" prefix=81.222.128.0/20
-     /routing filter add action=accept chain="eltel-v4" prefix=81.222.160.0/20
-     /routing filter add action=accept chain="eltel-v4" prefix=81.222.192.0/18
-     /routing filter add action=accept chain="eltel-v4" prefix=85.249.8.0/21
-     /routing filter add action=accept chain="eltel-v4" prefix=85.249.224.0/19
-     /routing filter add action=accept chain="eltel-v4" prefix=89.112.0.0/17
-     /routing filter add action=accept chain="eltel-v4" prefix=217.170.64.0/19
+> those objects will be excluded from expansion.

-Generating named Juniper prefix-filter for `AS20597`:
+# EXAMPLES

-     $ bgpq4 -Jl eltel-v4 AS20597
-     policy-options {
-     replace:
-      prefix-list eltel-v4 {
-         81.9.0.0/20;
-         81.9.32.0/20;
-         81.9.96.0/20;
-         81.222.128.0/20;
-         81.222.192.0/18;
-         85.249.8.0/21;
-         85.249.224.0/19;
-         89.112.0.0/19;
-         89.112.4.0/22;
-         89.112.32.0/19;
-         89.112.64.0/19;
-         217.170.64.0/20;
-         217.170.80.0/20;
-      }
-     }
+Generating named juniper prefix-filter for AS20597:
+
+	$ bgpq4 -Jl eltel AS20597
+	policy-options {
+	replace:
+	 prefix-list eltel {
+	    81.9.0.0/20;
+	    81.9.32.0/20;
+	    81.9.96.0/20;
+	    81.222.128.0/20;
+	    81.222.192.0/18;
+	    85.249.8.0/21;
+	    85.249.224.0/19;
+	    89.112.0.0/19;
+	    89.112.4.0/22;
+	    89.112.32.0/19;
+	    89.112.64.0/19;
+	    217.170.64.0/20;
+	    217.170.80.0/20;
+	 }
+	}

 For Cisco we can use aggregation (-A) flag to make this prefix-filter
 more compact:

-     $ bgpq4 -Al eltel-v4 AS20597
-     no ip prefix-list eltel-v4
-     ip prefix-list eltel-v4 permit 81.9.0.0/20
-     ip prefix-list eltel-v4 permit 81.9.32.0/20
-     ip prefix-list eltel-v4 permit 81.9.96.0/20
-     ip prefix-list eltel-v4 permit 81.222.128.0/20
-     ip prefix-list eltel-v4 permit 81.222.192.0/18
-     ip prefix-list eltel-v4 permit 85.249.8.0/21
-     ip prefix-list eltel-v4 permit 85.249.224.0/19
-     ip prefix-list eltel-v4 permit 89.112.0.0/18 ge 19 le 19
-     ip prefix-list eltel-v4 permit 89.112.4.0/22
-     ip prefix-list eltel-v4 permit 89.112.64.0/19
-     ip prefix-list eltel-v4 permit 217.170.64.0/19 ge 20 le 20
+	$ bgpq4 -Al eltel AS20597
+	no ip prefix-list eltel
+	ip prefix-list eltel permit 81.9.0.0/20
+	ip prefix-list eltel permit 81.9.32.0/20
+	ip prefix-list eltel permit 81.9.96.0/20
+	ip prefix-list eltel permit 81.222.128.0/20
+	ip prefix-list eltel permit 81.222.192.0/18
+	ip prefix-list eltel permit 85.249.8.0/21
+	ip prefix-list eltel permit 85.249.224.0/19
+	ip prefix-list eltel permit 89.112.0.0/18 ge 19 le 19
+	ip prefix-list eltel permit 89.112.4.0/22
+	ip prefix-list eltel permit 89.112.64.0/19
+	ip prefix-list eltel permit 217.170.64.0/19 ge 20 le 20

-and, as you see, prefixes `89.112.0.0/19` and `89.112.32.0/19` now aggregated 
-into single entry 
+Prefixes 89.112.0.0/19 and 89.112.32.0/19 now aggregated
+into single entry 89.112.0.0/18 ge 19 le 19.

-	ip prefix-list eltel permit 89.112.0.0/18 ge 19 le 19.
+Well, for Juniper we can generate even more interesting policy-options,
+using -M &lt;extra match conditions&gt;, -R &lt;len&gt; and hierarchical names:

-Well, for Juniper we can generate even more interesting policy-statement,
-using `-M <extra match conditions>`, `-r <len>`, `-R <len>` and hierarchical 
-names:
-
-     $ bgpq4 -AJEl eltel/specifics -r 29 -R 32 -M "community blackhole" AS20597
+	$ bgpq4 -AJEl eltel/specifics -r 29 -R 32 -M "community blackhole" AS20597
 	policy-options {
 	 policy-statement eltel {
 	  term specifics {
@@ -252,51 +247,83 @@ names:
 	 }
 	}

+generated policy-option term now allows all specifics with prefix-length
+between /29 and /32 for eltel networks if they match with special community
+blackhole (defined elsewhere in configuration).

-generated policy-option term now allows more-specific routes in range
-/29 - /32 for eltel networks if they marked with community 'blackhole' 
-(defined elsewhere in configuration).
+Of course, this version supports IPv6 (-6):

-Of course, `bgpq4` supports IPv6 (-6):
-
-     $ bgpq4 -6l as-retn-v6 AS-RETN6
-     no ipv6 prefix-list as-retn-v6
-     ipv6 prefix-list as-retn-v6 permit 2001:7fb:fe00::/48
-     ipv6 prefix-list as-retn-v6 permit 2001:7fb:fe01::/48
-     [....]
+	$ bgpq4 -6l as-retn-6 AS-RETN6
+	no ipv6 prefix-list as-retn-6
+	ipv6 prefix-list as-retn-6 permit 2001:7fb:fe00::/48
+	ipv6 prefix-list as-retn-6 permit 2001:7fb:fe01::/48
+	[....]

 and assumes your device supports 32-bit ASNs

-     $ bgpq4 -Jf 112 AS-SPACENET
-     policy-options {
-     replace:
-      as-path-group NN {
-       as-path a0 "^112(112)*$";
-       as-path a1 "^112(.)*(1898|5539|8495|8763|8878|12136|12931|15909)$";
-       as-path a2 "^112(.)*(21358|23600|24151|25152|31529|34127|34906)$";
-       as-path a3 "^112(.)*(35052|41720|43628|44450|196611)$";
-      }
-     }
+	$ bgpq4 -Jf 112 AS-SPACENET
+	policy-options {
+	replace:
+	 as-path-group NN {
+	  as-path a0 "^112(112)*$";
+	  as-path a1 "^112(.)*(1898|5539|8495|8763|8878|12136|12931|15909)$";
+	  as-path a2 "^112(.)*(21358|23456|23600|24151|25152|31529|34127|34906)$";
+	  as-path a3 "^112(.)*(35052|41720|43628|44450|196611)$";
+	 }
+	}

-see `AS196611` in the end of the list ? That's a 32-bit ASN.
+see \`AS196611\` in the end of the list ? That's a 32-bit ASN.

-USER-DEFINED FORMAT
-------------------
+# USER-DEFINED FORMAT

 If you want to generate configuration not for routers, but for some
 other programs/systems, you may use user-defined formatting, like in
 example below:

-	$ bgpq4 -F "ipfw add pass all from %n/%l to any\\n" as3254
+	$ bgpq4 -F "ipfw add pass all from %n/%l to any\n" as3254
 	ipfw add pass all from 62.244.0.0/18 to any
 	ipfw add pass all from 91.219.29.0/24 to any
 	ipfw add pass all from 91.219.30.0/24 to any
 	ipfw add pass all from 193.193.192.0/19 to any

-Recognized format characters: '%n' - network, '%l' - mask length,
-'%a' - aggregate low mask length, '%A' - aggregate high mask length,
-'%N' - object name, '%m' - object mask and '%i' - inversed mask.
-Recognized escape characters: '\n' - new line, '\t' - tabulation.
+Recognized format sequences are:
+
+**%n**
+
+> network
+
+**%l**
+
+> mask length
+
+**%a**
+
+> aggregate low mask length
+
+**%A**
+
+> aggregate high mask length
+
+**%N**
+
+> object name
+
+**%m**
+
+> object mask
+
+**%i**
+
+> inversed mask
+
+**&#92;n**
+
+> new line
+
+**&#92;t**
+
+> tabulation
+
 Please note that no new lines inserted automatically after each sentence,
 you have to add them into format string manually, elsewhere output will
 be in one line (sometimes it makes sense):
@@ -304,101 +331,116 @@ be in one line (sometimes it makes sense):
 	$ bgpq4 -6F "%n/%l; " as-eltel
 	2001:1b00::/32; 2620:4f:8000::/48; 2a04:bac0::/29; 2a05:3a80::/48;

-DIAGNOSTICS
-----------
+# NOTES ON SOURCES

-When everything is OK, `bgpq4` generates result to standard output and
-exits with status == 0.  In case of errors they are printed to stderr and
-program exits with non-zero status.
+By default
+*bgpq4*
+trusts to data from all databases mirrored into NTT's IRR service.
+Unfortunately, not all these databases are equal in how much can we
+trust their data.
+RIR maintained databases (AFRINIC, ARIN, APNIC, LACNIC and RIPE)
+shall be trusted more than the others because they are indeed have the
+knowledge about which address space allocated to this or that ASn,
+other databases lack this knowledge and can (and, actually, do) contain
+some stale data: noone but RIRs care to remove outdated route-objects
+when address space revoked from one ASn and allocated to another.
+In order to keep their filters both compact and actual,
+*bgpq4 users*
+are encouraged to use '-S' flag to limit database sources to only
+ones they trust.

-NOTES ON ULTRA-LARGE PREFIX-LISTS
---------------------------------
+General recommendations:

-To improve `bgpq4` performance when expanding extra-large AS-SETs you
+Use minimal set of RIR databases (only those in which you and your
+customers have registered route-objects).
+
+Avoid using ARIN-NONAUTH and RIPE-NONAUTH as trusted source: these records
+were created in database but for address space allocated to different RIR,
+so the NONAUTH databases have no chance to confirm validity of this route
+object.
+
+	$ bgpq4 -S RIPE,RADB as-space
+	no ip prefix-list NN
+	ip prefix-list NN permit 195.190.32.0/19
+	
+	$ bgpq4 -S RADB,RIPE as-space
+	no ip prefix-list NN
+	ip prefix-list NN permit 45.4.4.0/22
+	ip prefix-list NN permit 45.4.132.0/22
+	ip prefix-list NN permit 45.6.128.0/22
+	ip prefix-list NN permit 45.65.184.0/22
+	[...]
+
+# PERFORMANCE
+
+To improve \`bgpq4\` performance when expanding extra-large AS-SETs you
 shall tune OS settings to enlarge TCP send buffer.

 FreeBSD can be tuned in the following way:

-    sysctl -w net.inet.tcp.sendbuf_max=2097152
-    
+	sysctl -w net.inet.tcp.sendbuf_max=2097152
+
 Linux can be tuned in the following way:

-    sysctl -w net.ipv4.tcp_window_scaling=1
-    sysctl -w net.core.rmem_max=2097152
-    sysctl -w net.core.wmem_max=2097152
-    sysctl -w net.ipv4.tcp_rmem="4096 87380 2097152"
-    sysctl -w net.ipv4.tcp_wmem="4096 65536 2097152"
+	sysctl -w net.ipv4.tcp_window_scaling=1

-Please note that generated prefix-lists may not fit your router's
-limitations. For example, JunOS supports only 85,325 prefixes in 
-each prefix-list [4](http://www.juniper.net/techpubs/en_US/junos11.4/topics/reference/configuration-statement/prefix-list-edit-policy-options.html). 
+	sysctl -w net.core.rmem_max=2097152

+	sysctl -w net.core.wmem_max=2097152

-BUILDING
--------
+	sysctl -w net.ipv4.tcp_rmem="4096 87380 2097152"
+
+	sysctl -w net.ipv4.tcp_wmem="4096 65536 2097152"
+
+# BUILDING

 This project uses autotools. If you are building from the repository,
 run the following command to prepare the build system:

-    ./bootstrap
+	./bootstrap

 In order to compile the software, run:

-    ./configure
-    make
-    make install
+	./configure
+
+	make
+
+	make install

 If you wish to remove the generated build system files from your
 working tree, run:

-    make maintainer-clean
+	make maintainer-clean

 In order to create a distribution archive, run:

-    make dist
+	make dist

-PACKAGE INSTALLATION
--------------------
+# DIAGNOSTICS

-In FreeBSD binary package can be installed using
+When everything is OK,
+**bgpq4**
+generates access-list to standard output and exits with status == 0.
+In case of errors they are printed to stderr and program exits with
+non-zero status.

-```shell
-pkg install bgpq4
-```
-
-Or from ports with `portmaster`
-
-```shell
-portmaster net-mgmt/bgpq4
-```
-
-On Arch Linux, BGPQ4 is [available in AUR](https://aur.archlinux.org/packages/bgpq4/):
-
-```shell
-yay -S bgpq4
-```
-
-MAILING LIST
------------
-
-Users and interested parties can subscribe to the BGPQ4 mailing list [bgpq4@tcp0.com](https://tcp0.com/cgi-bin/mailman/listinfo/bgpq4).
-
-SEE ALSO
--------
-
-NLNOG's [BGP Filter Guide](http://bgpfilterguide.nlnog.net/)
-
-AUTHORS
-------
+# AUTHORS

 Alexandre Snarskii, Christian David, Claudio Jeker, Job Snijders,
 Massimiliano Stucchi, Michail Litvak, Peter Schoenmaker, Roelf Wichertjes,
 and contributions from many others.

-Project
-------
+# SEE ALSO

-BGPQ4 is maintained by Job Snijders `<job@sobornost.net>`.
+**https://github.com/bgp/bgpq4**
+BGPQ4 on Github.

-[https://github.com/bgp/bgpq4](https://github.com/bgp/bgpq4)
+**http://bgpfilterguide.nlnog.net/**
+NLNOG's BGP Filter Guide.

+**https://tcp0.com/cgi-bin/mailman/listinfo/bgpq4**
+Users and interested parties can subscribe to the BGPQ4 mailing list bgpq4@tcp0.com
+
+# PROJECT MAINTAINER
+
+Job Snijders &lt;job@sobornost.net&gt;
--- a/1
+++ b/1
@@ -0,0 +1 @@
+1.4
--- a/bgpq4.8
+++ b/bgpq4.8
@@ -178,7 +178,8 @@ ip prefix-list eltel permit 89.112.64.0/19
 ip prefix-list eltel permit 217.170.64.0/19 ge 20 le 20
 .Ed
 .fi
- you see, prefixes 89.112.0.0/19 and 89.112.32.0/19 now aggregated
+.Pp
+Prefixes 89.112.0.0/19 and 89.112.32.0/19 now aggregated
 into single entry 89.112.0.0/18 ge 19 le 19.
 .Pp
 Well, for Juniper we can generate even more interesting policy-options,
@@ -251,10 +252,29 @@ ipfw add pass all from 193.193.192.0/19 to any
 .Ed
 .fi
 .Pp
-Recognized format characters: %n - network, %l - mask length,
-%a - aggregate low mask length, %A - aggregate high mask length,
-%N - object name, %m - object mask and %i - inversed mask.
-Recognized escape characters: \\n - new line, \\t - tabulation.
+Recognized format sequences are:
+.Pp
+.Bl -tag -width Ds -offset indent -compact
+.It Cm %n
+network
+.It Cm %l
+mask length
+.It Cm %a
+aggregate low mask length
+.It Cm \&%A
+aggregate high mask length
+.It Cm \&%N
+object name
+.It Cm %m
+object mask
+.It Cm %i
+inversed mask
+.It Cm \en
+new line
+.It Cm \et
+tabulation
+.El
+.Pp
 Please note that no new lines inserted automatically after each sentence,
 you have to add them into format string manually, elsewhere output will
 be in one line (sometimes it makes sense):
@@ -264,14 +284,97 @@ $ bgpq4 -6F "%n/%l; " as-eltel
 2001:1b00::/32; 2620:4f:8000::/48; 2a04:bac0::/29; 2a05:3a80::/48;
 .Ed
 .fi
+.Sh NOTES ON SOURCES
+By default
+.Em bgpq4
+trusts to data from all databases mirrored into NTT's IRR service.
+Unfortunately, not all these databases are equal in how much can we
+trust their data.
+RIR maintained databases (AFRINIC, ARIN, APNIC, LACNIC and RIPE)
+shall be trusted more than the others because they are indeed have the
+knowledge about which address space allocated to this or that ASn,
+other databases lack this knowledge and can (and, actually, do) contain
+some stale data: noone but RIRs care to remove outdated route-objects
+when address space revoked from one ASn and allocated to another.
+In order to keep their filters both compact and actual,
+.Em bgpq4 users
+are encouraged to use '-S' flag to limit database sources to only
+ones they trust.
+.Pp
+General recommendations:
+.Pp
+Use minimal set of RIR databases (only those in which you and your
+customers have registered route-objects).
+.Pp
+Avoid using ARIN-NONAUTH and RIPE-NONAUTH as trusted source: these records
+were created in database but for address space allocated to different RIR,
+so the NONAUTH databases have no chance to confirm validity of this route
+object.
+.Bd -literal
+$ bgpq4 -S RIPE,RADB as-space
+no ip prefix-list NN
+ip prefix-list NN permit 195.190.32.0/19
+
+$ bgpq4 -S RADB,RIPE as-space
+no ip prefix-list NN
+ip prefix-list NN permit 45.4.4.0/22
+ip prefix-list NN permit 45.4.132.0/22
+ip prefix-list NN permit 45.6.128.0/22
+ip prefix-list NN permit 45.65.184.0/22
+[...]
+.Sh PERFORMANCE
+To improve `bgpq4` performance when expanding extra-large AS-SETs you
+shall tune OS settings to enlarge TCP send buffer.
+.Pp
+FreeBSD can be tuned in the following way:
+.Pp
+.Dl sysctl -w net.inet.tcp.sendbuf_max=2097152
+.Pp
+Linux can be tuned in the following way:
+.Pp
+.Dl sysctl -w net.ipv4.tcp_window_scaling=1
+.Dl sysctl -w net.core.rmem_max=2097152
+.Dl sysctl -w net.core.wmem_max=2097152
+.Dl sysctl -w net.ipv4.tcp_rmem="4096 87380 2097152"
+.Dl sysctl -w net.ipv4.tcp_wmem="4096 65536 2097152"
+.Sh BUILDING
+This project uses autotools. If you are building from the repository,
+run the following command to prepare the build system:
+.Pp
+.Dl ./bootstrap
+.Pp
+In order to compile the software, run:
+.Pp
+.Dl ./configure
+.Dl make
+.Dl make install
+.Pp
+If you wish to remove the generated build system files from your
+working tree, run:
+.Pp
+.Dl make maintainer-clean
+.Pp
+In order to create a distribution archive, run:
+.Pp
+.Dl make dist
 .Sh DIAGNOSTICS
 When everything is OK,
 .Nm
 generates access-list to standard output and exits with status == 0.
 In case of errors they are printed to stderr and program exits with
 non-zero status.
+.Sh AUTHORS
+Alexandre Snarskii, Christian David, Claudio Jeker, Job Snijders,
+Massimiliano Stucchi, Michail Litvak, Peter Schoenmaker, Roelf Wichertjes,
+and contributions from many others.
 .Sh SEE ALSO
 .Sy https://github.com/bgp/bgpq4
 BGPQ4 on Github.
+.Pp
+.Sy http://bgpfilterguide.nlnog.net/
+NLNOG's BGP Filter Guide.
+.Pp
+.Sy https://tcp0.com/cgi-bin/mailman/listinfo/bgpq4
+Users and interested parties can subscribe to the BGPQ4 mailing list bgpq4@tcp0.com
 .Sh PROJECT MAINTAINER
 .An Job Snijders Aq job@sobornost.net
--- a/bgpq4.h
+++ b/bgpq4.h
@@ -1,98 +0,0 @@
-#ifndef BGPQ4_H_
-#define BGPQ4_H_
-
-#if HAVE_SYS_QUEUE_H && HAVE_STAILQ_IN_SYS_QUEUE
-#include <sys/queue.h>
-#else
-#include "sys_queue.h"
-#endif
-
-#include "sx_prefix.h"
-#include "sx_slentry.h"
-
-typedef enum {
-	V_CISCO = 0,
-	V_JUNIPER,
-	V_CISCO_XR,
-	V_JSON,
-	V_BIRD,
-	V_OPENBGPD,
-	V_FORMAT,
-	V_NOKIA,
-	V_HUAWEI,
-	V_MIKROTIK,
-	V_NOKIA_MD,
-	V_ARISTA
-} bgpq_vendor_t;
-
-typedef enum {
-	T_NONE = 0,
-	T_ASPATH,
-	T_OASPATH,
-	T_ASSET,
-	T_PREFIXLIST,	
-	T_EACL,
-	T_ROUTE_FILTER_LIST
-} bgpq_gen_t;
-
-struct bgpq_expander;
-
-struct bgpq_request {
-	STAILQ_ENTRY(bgpq_request) next;
-	char* request;
-	int size, offset;
-	int (*callback)(char*, struct bgpq_expander*, struct bgpq_request*);
-	void *udata;
-	unsigned depth;
-};
-
-struct bgpq_expander {
-	struct sx_radix_tree* tree;
-	STAILQ_HEAD(sx_slentries, sx_slentry) macroses, rsets;
-	RB_HEAD(tentree, sx_tentry) already, stoplist;
-	int family;
-	char* sources;
-	uint32_t asnumber;
-	int aswidth;
-	char* name;
-	bgpq_vendor_t vendor;
-	bgpq_gen_t    generation;
-	int identify;
-	int sequence;
-	int maxdepth;
-	int validate_asns;
-	unsigned char* asn32s[65536];
-	struct bgpq_prequest* firstpipe, *lastpipe;
-	int piped;
-	char* match;
-	char* server;
-	char* port;
-	char* format;
-	unsigned maxlen;
-	STAILQ_HEAD(bgpq_requests, bgpq_request) wq, rq;
-	int fd, cdepth;
-};
-
-
-int bgpq_expander_init(struct bgpq_expander* b, int af);
-int bgpq_expander_add_asset(struct bgpq_expander* b, char* set);
-int bgpq_expander_add_rset(struct bgpq_expander* b, char* set);
-int bgpq_expander_add_as(struct bgpq_expander* b, char* as);
-int bgpq_expander_add_prefix(struct bgpq_expander* b, char* prefix);
-int bgpq_expander_add_prefix_range(struct bgpq_expander* b, char* prefix);
-int bgpq_expander_add_stop(struct bgpq_expander* b, char* object);
-
-int bgpq_expand(struct bgpq_expander* b);
-
-int bgpq4_print_prefixlist(FILE* f, struct bgpq_expander* b);
-int bgpq4_print_eacl(FILE* f, struct bgpq_expander* b);
-int bgpq4_print_aspath(FILE* f, struct bgpq_expander* b);
-int bgpq4_print_asset(FILE* f, struct bgpq_expander* b);
-int bgpq4_print_oaspath(FILE* f, struct bgpq_expander* b);
-int bgpq4_print_route_filter_list(FILE* f, struct bgpq_expander* b);
-
-#ifndef HAVE_STRLCPY
-size_t strlcpy(char* dst, const char* src, size_t size);
-#endif
-
-#endif
--- a/bgpq4.spec
+++ b/bgpq4.spec
@@ -1,88 +0,0 @@
-Name:           bgpq4
-Version:        0.0.6
-Release:        0%{?dist}
-
-Group:          System/Utilities
-Summary:        Generate BGP filters based on routing database information
-URL:            https://github.com/bgp/bgpq4
-License:        BSD
-Source0:        https://github.com/bgp/bgpq4
-BuildRoot:      %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
-
-%description
-You are running BGP in your network and want to automate filter generation for your routers? Well, with BGPQ4 it's easy.
-
-%prep
-%setup -q
-
-%global debug_package %{nil}
-
-%build
-./configure --prefix=$RPM_BUILD_ROOT%{_prefix} --mandir=%{_mandir}
-make
-
-%install
-rm -rf $RPM_BUILD_ROOT
-mkdir -p $RPM_BUILD_ROOT/usr/bin
-make install
-
-%files
-%defattr(-,root,root,-)
-/usr/bin/bgpq4
-/usr/man/man8/bgpq4.8.gz
-%doc COPYRIGHT CHANGES
-
-%clean
-rm -rf $RPM_BUILD_ROOT
-
-%changelog
-* Thu Mar 12 2020 Job Snijders <job@ntt.net> 0.0.6:
- bugfixes (Thanks Chris Caputo!)
-
-* Wed Jan 01 2020 Job Snijders <job@ntt.net> 0.0.5:
- bugfixes
-
-* Tue Dec 31 2019 Job Snijders <job@ntt.net> 0.0.4
- Remove '-3' command line option, assume all devices are 32-bit ASN safe
-
-* Mon Dec 30 2019 Job Snijders <job@ntt.net> 0.0.3
- Remove the '-2' command line option
- Significant code reformating
- Improve performance by using IRRd 4's A query when available
-
-* Sat Dec 14 2019 Job Snijders <job@ntt.net> 0.0.2
- Add Mikrotik support
- Remove ASDDOT support
-
-* Sat Dec 14 2019 Job Snijders <job@ntt.net> 0.0.1
- Fork from bgpq3
-
-* Tue Nov 30 2018 Alexandre Snarskii <snar@snar.spb.ru> 0.1.35
- Version updated
-
-* Fri Oct 14 2016 Alexandre Snarskii <snar@snar.spb.ru> 0.1.33
- Version updated
-
-* Tue Jun 23 Alexandre Snarskii <snar@snar.spb.ru> 0.1.31
- Version updated
-
-* Tue Mar 10 Alexandre Snarskii <snar@snar.spb.ru> 0.1.28
- Version updated
-
-* Wed Oct 29 Alexandre Snarskii <snar@snar.spb.ru> 0.1.25
- Version updated
-
-* Thu Jun 5 2014 Alexandre Snarskii <snar@snar.spb.ru> 0.1.21-0.snar
- Version updated
-
-* Thu May 9 2013 Alexandre Snarskii <snar@snar.spb.ru> 0.1.19-0.snar
- Version updated
-
-* Sun Feb 24 2013 Alexandre Snarskii <snar@snar.spb.ru> 0.1.18-3.snar
- License corrected
-
-* Wed Feb 20 2013 Arnoud Vermeer <arnoud@tumblr.com> 0.1.18-2.tumblr
- Adding missing group info (arnoud@tumblr.com)
-
-* Wed Feb 20 2013 Arnoud Vermeer <arnoud@tumblr.com> 0.1.18-1.tumblr
- new package built with tito
--- a/bgpq4_printer.c
+++ b/bgpq4_printer.c
--- a/compat/Makefile.am
+++ b/compat/Makefile.am
@@ -0,0 +1,7 @@
+AM_CPPFLAGS = -I$(top_srcdir)/include
+
+noinst_LTLIBRARIES = libcompat.la
+
+libcompat_la_LIBADD = $(PLATFORM_LDADD)
+
+libcompat_la_SOURCES = strlcpy.c
--- a/compat/strlcpy.c
+++ b/compat/strlcpy.c
@@ -0,0 +1,50 @@
+/*	$OpenBSD: strlcpy.c,v 1.16 2019/01/25 00:19:25 millert Exp $	*/
+
+/*
+ * Copyright (c) 1998, 2015 Todd C. Miller <millert@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/types.h>
+#include <string.h>
+
+/*
+ * Copy string src to buffer dst of size dsize.  At most dsize-1
+ * chars will be copied.  Always NUL terminates (unless dsize == 0).
+ * Returns strlen(src); if retval >= dsize, truncation occurred.
+ */
+size_t
+strlcpy(char *dst, const char *src, size_t dsize)
+{
+	const char *osrc = src;
+	size_t nleft = dsize;
+
+	/* Copy as many bytes as will fit. */
+	if (nleft != 0) {
+		while (--nleft != 0) {
+			if ((*dst++ = *src++) == '\0')
+				break;
+		}
+	}
+
+	/* Not enough room in dst, add NUL and traverse rest of src. */
+	if (nleft == 0) {
+		if (dsize != 0)
+			*dst = '\0';		/* NUL-terminate dst */
+		while (*src++)
+			;
+	}
+
+	return(src - osrc - 1);	/* count does not include NUL */
+}
--- a/configure.ac
+++ b/configure.ac
@@ -1,34 +1,103 @@
-AC_INIT(bgpq4,0.0.6,job@sobornost.net)
-AM_INIT_AUTOMAKE
-AC_PACKAGE_URL(https://github.com/bgp/bgpq4)
-AC_CONFIG_HEADERS([config.h])
-AM_SILENT_RULES([yes])
+#
+# Copyright (c) 2019 Brent Cook
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+AC_INIT([bgpq4], m4_esyscmd([tr -d '\n' < VERSION]), job@sobornost.net)
+
+AC_CANONICAL_HOST
+AM_INIT_AUTOMAKE([subdir-objects foreign])
+AC_CONFIG_MACRO_DIR([m4])
+m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
+AC_PROG_CC([cc gcc])
+
+case $host_os in
+	*darwin*)
+		HOST_OS=darwin
+		AC_DEFINE([SPT_TYPE], [SPT_REUSEARGV])
+		;;
+	*freebsd*)
+		HOST_OS=freebsd
+	;;
+	*linux*)
+		HOST_OS=linux
+		CFLAGS="$CFLAGS -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_GNU_SOURCE"
+		AC_DEFINE([SPT_TYPE], [SPT_REUSEARGV])
+		;;
+	*netbsd*)
+		HOST_OS=netbsd
+		;;
+	*openbsd*)
+		HOST_OS=openbsd
+		AC_DEFINE([HAVE_ATTRIBUTE__BOUNDED__], [1], [OpenBSD has __bounded__])
+		AC_DEFINE([HAVE_ATTRIBUTE__DEAD], [1], [OpenBSD has __dead])
+		;;
+	*solaris*)
+		HOST_OS=solaris
+		CFLAGS="$CFLAGS -D__EXTENSIONS__ -D_XOPEN_SOURCE=600 -DBSD_COMP"
+		;;
+	*) ;;
+esac
+
+AM_CONDITIONAL([HOST_DARWIN],  [test x$HOST_OS = xdarwin])
+AM_CONDITIONAL([HOST_FREEBSD], [test x$HOST_OS = xfreebsd])
+AM_CONDITIONAL([HOST_LINUX],   [test x$HOST_OS = xlinux])
+AM_CONDITIONAL([HOST_NETBSD],  [test x$HOST_OS = xnetbsd])
+AM_CONDITIONAL([HOST_SOLARIS], [test x$HOST_OS = xsolaris])

 AC_PROG_CC
-CC=cc
-CFLAGS="${CFLAGS} -std=gnu11"
-
+AC_PROG_CC_STDC
+AM_PROG_CC_C_O
+AC_PROG_LIBTOOL
 AC_PROG_INSTALL

-AC_CHECK_HEADERS([sys/cdefs.h sys/queue.h sys/tree.h sys/select.h])
+AC_ARG_ENABLE(warnings,
+	AS_HELP_STRING([--disable-warnings],
+	    [ enable compiler warnings [default=enabled]]),
+	[case $enableval in
+	    yes) enable_warnings=yes;;
+	    no) enable_warnings=no;;
+	    *) enable_warnings=yes;; esac],
+    enable_warnings=yes)

-AC_MSG_CHECKING([for STAILQ_ interface in queue.h])
-AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
-#if HAVE_SYS_QUEUE_H
-#include <sys/queue.h>
-#else
-#include "sys_queue.h"
+if test "$enable_warnings" = yes; then
+	AM_CFLAGS="$AM_CFLAGS -Wall -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations -Wshadow -Wpointer-arith -Wsign-compare -Werror-implicit-function-declaration"
+	save_cflags="$CFLAGS"
+	CFLAGS=-Wno-pointer-sign
+	AC_MSG_CHECKING([whether CC supports -Wno-pointer-sign])
+	AC_COMPILE_IFELSE([AC_LANG_PROGRAM([])],
+	    [AC_MSG_RESULT([yes])]
+	    [WARN_CFLAGS=-Wno-pointer-sign],
+	    [AC_MSG_RESULT([no])]
+	)
+	AM_CFLAGS="$AM_CFLAGS $WARN_CFLAGS"
+	CFLAGS="$save_cflags"
+fi
+
+AC_MSG_CHECKING([if compiling with clang])
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[
+#ifndef __clang__
+	not clang
 #endif
-struct blah {
-   STAILQ_ENTRY(blah) next;
-};
-])],
-[AC_MSG_RESULT(yes)
-AC_DEFINE([HAVE_STAILQ_IN_SYS_QUEUE], [1], [sys/queue.h have STAILQ_])],
-[AC_MSG_RESULT(no)])
-
-
-AC_CHECK_PROGS([MARKDOWN], [markdown_py markdown2 markdown], [echo])
+	]])],
+	[AC_MSG_RESULT([yes])]
+	[CLANG_FLAGS=-Qunused-arguments],
+	[AC_MSG_RESULT([no])]
+)
+AM_CFLAGS="$AM_CFLAGS $CLANG_FLAGS"
+AM_LDFLAGS="$LDFLAGS $CLANG_FLAGS"
+AC_SUBST(AM_CFLAGS)
+AC_SUBST(AM_LDFLAGS)

 AC_CHECK_FUNCS(strlcpy)
 AC_CHECK_FUNCS(pledge)
@@ -36,5 +105,15 @@ AC_CHECK_FUNCS(pledge)
 AC_CHECK_LIB(socket,socket)
 AC_CHECK_LIB(nsl,getaddrinfo)

-AC_OUTPUT(Makefile)
+AC_CHECK_HEADERS([sys/cdefs.h sys/queue.h sys/tree.h sys/select.h])

+AM_CONDITIONAL([HAVE_PLEDGE], [test "x$ac_cv_func_pledge" = xyes])
+AM_CONDITIONAL([HAVE_STRLCPY], [test "x$ac_cv_func_strlcpy" = xyes])
+
+AC_CONFIG_FILES([
+	Makefile
+	include/Makefile
+	compat/Makefile
+])
+
+AC_OUTPUT
--- a/bgpq_expander.c
+++ b/bgpq_expander.c
@@ -1,46 +1,75 @@
-#if HAVE_CONFIG_H
-#include "config.h"
-#endif
+/*
+ * Copyright (c) 2019-2021 Job Snijders <job@sobornost.net>
+ * Copyright (c) 2018 Peter Schoenmaker <pds@ntt.net>
+ * Copyright (c) 2007-2019 Alexandre Snarskii <snar@snar.spb.ru>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */

 #include <sys/types.h>
 #include <sys/socket.h>
-#if HAVE_SYS_SELECT_H
 #include <sys/select.h>
-#endif

 #include <assert.h>
-#include <fcntl.h>
-#include <inttypes.h>
 #include <ctype.h>
 #include <errno.h>
-#include <netdb.h>
+#include <err.h>
+#include <fcntl.h>
+#include <inttypes.h>
 #include <limits.h>
-#include <string.h>
-#include <strings.h>
+#include <netdb.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
+#include <strings.h>
 #include <unistd.h>

-#include "bgpq4.h"
+#include "extern.h"
 #include "sx_report.h"
-#include "sx_maxsockbuf.h"
-#include "expander_freeall.h"

 int debug_expander = 0;
 int pipelining = 1;
 int expand_special_asn = 0;

 static inline int
-tentry_cmp(struct sx_tentry* a, struct sx_tentry* b)
+tentry_cmp(struct sx_tentry *a, struct sx_tentry *b)
 {
 	return strcasecmp(a->text, b->text);
 }

-RB_GENERATE(tentree, sx_tentry, entry, tentry_cmp);
+RB_GENERATE_STATIC(tentree, sx_tentry, entry, tentry_cmp);

 int
-bgpq_expander_init(struct bgpq_expander* b, int af)
+asn_cmp(struct asn_entry *a, struct asn_entry *b)
+{
+	return (a->asn < b->asn ? -1 : a->asn > b->asn);
+}
+
+RB_GENERATE(asn_tree, asn_entry, entry, asn_cmp);
+
+int
+bgpq_expander_init(struct bgpq_expander *b, int af)
 {
 	if (!af)
 		af = AF_INET;
@@ -59,22 +88,12 @@ bgpq_expander_init(struct bgpq_expander* b, int af)
 	b->sources = "";
 	b->name = "NN";
 	b->aswidth = 8;
-	b->asn32s[0] = malloc(8192);
-	if (!b->asn32s[0]) {
-		sx_report(SX_FATAL,"Unable to allocate 8192 bytes: %s\n",
-		    strerror(errno));
-		exit(1);
-	}
-	memset(b->asn32s[0], 0, 8192);
 	b->identify = 1;
 	b->server = "rr.ntt.net";
 	b->port = "43";

-	//	b->wq = STAILQ_HEAD_INITIALZIER(b->wq);
-	//      b->rq = STAILQ_HEAD_INITIALZIER(b->rq);
-	//      b->rsets = STAILQ_HEAD_INITIALZIER(b->rsets);
-	//      b->macroses = STAILQ_HEAD_INITIALZIER(b->macroses);
-	
+	RB_INIT(&b->asnlist);
+
 	STAILQ_INIT(&b->wq);
 	STAILQ_INIT(&b->rq);
 	STAILQ_INIT(&b->rsets);
@@ -93,24 +112,24 @@ fixups:
 }

 int
-bgpq_expander_add_asset(struct bgpq_expander* b, char* as)
+bgpq_expander_add_asset(struct bgpq_expander *b, char *as)
 {
-	struct sx_slentry* le;
+	struct slentry	*le;

 	if (!b || !as)
 		return 0;

 	le = sx_slentry_new(as);

-	STAILQ_INSERT_TAIL(&b->macroses, le, next);
+	STAILQ_INSERT_TAIL(&b->macroses, le, entry);

 	return 1;
 }

 int
-bgpq_expander_add_rset(struct bgpq_expander* b, char* rs)
+bgpq_expander_add_rset(struct bgpq_expander *b, char *rs)
 {
-	struct sx_slentry* le;
+	struct slentry	*le;

 	if (!b || !rs)
 		return 0;
@@ -120,15 +139,16 @@ bgpq_expander_add_rset(struct bgpq_expander* b, char* rs)
 	if (!le)
 		return 0;

-	STAILQ_INSERT_TAIL(&b->rsets, le, next);
+	STAILQ_INSERT_TAIL(&b->rsets, le, entry);

 	return 1;
 }

-int
-bgpq_expander_add_already(struct bgpq_expander* b, char* rs)
+static int
+bgpq_expander_add_already(struct bgpq_expander *b, char *rs)
 {
-	struct sx_tentry* le, lkey;
+	struct sx_tentry	*le, lkey;
+
 	lkey.text = rs;

 	if (RB_FIND(tentree, &b->already, &lkey))
@@ -142,9 +162,10 @@ bgpq_expander_add_already(struct bgpq_expander* b, char* rs)
 }

 int
-bgpq_expander_add_stop(struct bgpq_expander* b, char* rs)
+bgpq_expander_add_stop(struct bgpq_expander *b, char *rs)
 {
-	struct sx_tentry* le, lkey;
+	struct sx_tentry	*le, lkey;
+
 	lkey.text = rs;

 	if (RB_FIND(tentree, &b->stoplist, &lkey))
@@ -158,56 +179,40 @@ bgpq_expander_add_stop(struct bgpq_expander* b, char* rs)
 }

 int
-bgpq_expander_add_as(struct bgpq_expander* b, char* as)
+bgpq_expander_add_as(struct bgpq_expander *b, char *as)
 {
-	char* eoa;
-	uint32_t asn1 = 0, asn2 = 0;
-	uint32_t asno = 0;
+	char			*eoa;
+	uint32_t	 	 asno = 0;
+	struct asn_entry	*asne;

 	if (!b || !as)
 		return 0;

 	asno = strtoul(as + 2, &eoa, 10);
-
 	if (eoa && *eoa != 0) {
 		sx_report(SX_ERROR,"Invalid symbol in AS number: '%c' in %s\n",
 		    *eoa, as);
 		return 0;
 	}

-	if (asno > 65535) {
-		asn1 = asno / 65536;
-		asn2 = asno % 65536;
-	} else
-		asn1 = asno;
-
 	if (!expand_special_asn &&
 	    ((asno  >= 4200000000ul) || (asno >= 64496 && asno <= 65551)))
 		return 0;

-	if (!b->asn32s[asn1]) {
-		b->asn32s[asn1] = malloc(8192);
-		if (!b->asn32s[asn1]) {
-			sx_report(SX_FATAL, "Unable to allocate 8192 "
-			    "bytes: %s. Unable to add asn32 %s to "
-			    " future expansion\n", strerror(errno), as);
-				return 0;
-			}
-		memset(b->asn32s[asn1], 0, 8192);
-	}
+	if ((asne = malloc(sizeof(struct asn_entry))) == NULL)
+		err(1, NULL);

-	if (asno > 65535)
-		b->asn32s[asn1][asn2 / 8] |= (0x80 >> (asn2 % 8));
-	else
-		b->asn32s[0][asn1 / 8] |= (0x80 >> (asn1 % 8));
+	asne->asn = asno;
+	RB_INSERT(asn_tree, &b->asnlist, asne);

 	return 1;
 }

 int
-bgpq_expander_add_prefix(struct bgpq_expander* b, char* prefix)
+bgpq_expander_add_prefix(struct bgpq_expander *b, char *prefix)
 {
 	struct sx_prefix *p = sx_prefix_alloc(NULL);
+
 	if (!sx_prefix_parse(p, 0, prefix)) {
 		sx_report(SX_ERROR, "Unable to parse prefix %s\n", prefix);
 		return 0;
@@ -221,7 +226,7 @@ bgpq_expander_add_prefix(struct bgpq_expander* b, char* prefix)
 		    " masklen %u\n", prefix, p->masklen, b->maxlen);
 		return 0;
 	}
-	sx_radix_tree_insert(b->tree,p);
+	sx_radix_tree_insert(b->tree, p);

        if (p)
 		sx_prefix_destroy(p);
@@ -230,42 +235,43 @@ bgpq_expander_add_prefix(struct bgpq_expander* b, char* prefix)
 }

 int
-bgpq_expander_add_prefix_range(struct bgpq_expander* b, char* prefix)
+bgpq_expander_add_prefix_range(struct bgpq_expander *b, char *prefix)
 {
 	return sx_prefix_range_parse(b->tree, b->family, b->maxlen, prefix);
 }

-int
-bgpq_expanded_macro(char* as, struct bgpq_expander* ex,
-    struct bgpq_request* req)
+static int
+bgpq_expanded_macro(char *as, struct bgpq_expander *ex,
+    struct request *req)
 {
 	bgpq_expander_add_as(ex, as);

 	return 1;
 }

-struct bgpq_request* bgpq_pipeline(struct bgpq_expander* b,
-	int (*callback)(char*, struct bgpq_expander* b, struct bgpq_request* req),
-	void* udata, char* fmt, ...);
-int bgpq_expand_irrd(struct bgpq_expander* b,
-    int (*callback)(char*, struct bgpq_expander* b, struct bgpq_request* req),
-     void* udata, char* fmt, ...);
+struct request *bgpq_pipeline(struct bgpq_expander *b,
+    int (*callback)(char *, struct bgpq_expander *b, struct request *req),
+    void *udata, char *fmt, ...);

-int
-bgpq_expanded_macro_limit(char* as, struct bgpq_expander* b,
-    struct bgpq_request* req)
+int bgpq_expand_irrd(struct bgpq_expander *b,
+    int (*callback)(char*, struct bgpq_expander *b, struct request *req),
+    void *udata, char *fmt, ...);
+
+static int
+bgpq_expanded_macro_limit(char *as, struct bgpq_expander *b,
+    struct request *req)
 {
 	if (!strncasecmp(as, "AS-", 3) || strchr(as, '-') || strchr(as, ':')) {
 		struct sx_tentry tkey = { .text = as };

 		if (RB_FIND(tentree, &b->already, &tkey)) {
-			SX_DEBUG(debug_expander>2, "%s is already expanding, "
+			SX_DEBUG(debug_expander > 2, "%s is already expanding, "
 			    "ignore\n", as);
 			return 0;
 		}

 		if (RB_FIND(tentree, &b->stoplist, &tkey)) {
-			SX_DEBUG(debug_expander>2, "%s is in the stoplist, "
+			SX_DEBUG(debug_expander > 2, "%s is in the stoplist, "
 			    "ignore\n", as);
 			return 0;
 		}
@@ -275,10 +281,10 @@ bgpq_expanded_macro_limit(char* as, struct bgpq_expander* b,
 		    req->depth + 1 < b->maxdepth)) {
 			bgpq_expander_add_already(b, as);
 			if (pipelining) {
-				struct bgpq_request* req1 = bgpq_pipeline(b,
+				struct request *req1 = bgpq_pipeline(b,
 				    bgpq_expanded_macro_limit, NULL, "!i%s\n",
-				    as);
-				req1->depth = req->depth+1;
+				        as);
+				req1->depth = req->depth + 1;
 			} else {
 				b->cdepth++;
 				bgpq_expand_irrd(b, bgpq_expanded_macro_limit,
@@ -286,7 +292,7 @@ bgpq_expanded_macro_limit(char* as, struct bgpq_expander* b,
 				b->cdepth--;
 			}
 		} else {
-			SX_DEBUG(debug_expander>2, "ignoring %s at depth %i\n",
+			SX_DEBUG(debug_expander > 2, "ignoring %s at depth %i\n",
 			    as,
 			    b->cdepth ? (b->cdepth + 1) : (req->depth + 1));
 		}
@@ -316,11 +322,11 @@ bgpq_expanded_macro_limit(char* as, struct bgpq_expander* b,
 	return 1;
 }

-int
-bgpq_expanded_prefix(char* as, struct bgpq_expander* ex,
-    struct bgpq_request* req __attribute__((unused)))
+static int
+bgpq_expanded_prefix(char *as, struct bgpq_expander *ex,
+    struct request *req __attribute__((unused)))
 {
-	char* d = strchr(as, '^');
+	char *d = strchr(as, '^');

 	if (!d)
 		bgpq_expander_add_prefix(ex, as);
@@ -330,11 +336,11 @@ bgpq_expanded_prefix(char* as, struct bgpq_expander* ex,
 	return 1;
 }

-int
-bgpq_expanded_v6prefix(char* prefix, struct bgpq_expander* ex,
-    struct bgpq_request* req)
+static int
+bgpq_expanded_v6prefix(char *prefix, struct bgpq_expander *ex,
+    struct request *req)
 {
-	char* d = strchr(prefix, '^');
+	char *d = strchr(prefix, '^');

 	if (!d)
 		bgpq_expander_add_prefix(ex, prefix);
@@ -344,18 +350,18 @@ bgpq_expanded_v6prefix(char* prefix, struct bgpq_expander* ex,
 	return 1;
 }

-int bgpq_pipeline_dequeue(int fd, struct bgpq_expander* b);
+int bgpq_pipeline_dequeue(int fd, struct bgpq_expander *b);

-static struct bgpq_request*
-bgpq_request_alloc(char* request, int (*callback)(char*, struct bgpq_expander*,
-    struct bgpq_request*), void* udata)
+static struct request *
+request_alloc(char *request, int (*callback)(char *, struct bgpq_expander *,
+    struct request *), void *udata)
 {
-	struct bgpq_request* bp = malloc(sizeof(struct bgpq_request));
+	struct request *bp = malloc(sizeof(struct request));

 	if (!bp)
 		return NULL;

-	memset(bp, 0, sizeof(struct bgpq_request));
+	memset(bp, 0, sizeof(struct request));
 	bp->request = strdup(request);
 	bp->offset = 0;
 	bp->size = strlen(bp->request);
@@ -366,7 +372,7 @@ bgpq_request_alloc(char* request, int (*callback)(char*, struct bgpq_expander*,
 }

 static void
-bgpq_request_free(struct bgpq_request* req)
+request_free(struct request *req)
 {
 	if (req->request)
 		free(req->request);
@@ -374,15 +380,15 @@ bgpq_request_free(struct bgpq_request* req)
 	free(req);
 }

-struct bgpq_request*
-bgpq_pipeline(struct bgpq_expander* b,
-    int (*callback)(char*, struct bgpq_expander*, struct bgpq_request*),
-    void* udata, char* fmt, ...)
+struct request *
+bgpq_pipeline(struct bgpq_expander *b,
+    int (*callback)(char *, struct bgpq_expander *, struct request *),
+    void *udata, char *fmt, ...)
 {
-	char request[128];
-	int ret;
-	struct bgpq_request* bp = NULL;
-	va_list ap;
+	char			 request[128];
+	int			 ret;
+	struct request	*bp = NULL;
+	va_list			 ap;

 	va_start(ap, fmt);
 	vsnprintf(request, sizeof(request), fmt, ap);
@@ -390,11 +396,11 @@ bgpq_pipeline(struct bgpq_expander* b,

 	SX_DEBUG(debug_expander,"expander: sending %s", request);

-	bp = bgpq_request_alloc(request, callback, udata);
+	bp = request_alloc(request, callback, udata);

 	if (!bp) {
 		sx_report(SX_FATAL,"Unable to allocate %lu bytes: %s\n",
-		    (unsigned long)sizeof(struct bgpq_request),
+		    (unsigned long)sizeof(struct request),
 		    strerror(errno));
 		exit(1);
 	}
@@ -422,36 +428,48 @@ bgpq_pipeline(struct bgpq_expander* b,
 }

 static void
-bgpq_expander_invalidate_asn(struct bgpq_expander* b, const char* q)
+bgpq_expander_invalidate_asn(struct bgpq_expander *b, const char *q)
 {
+	char			*eptr;
+	unsigned long		 asn = 0;
+	struct asn_entry	 find, *res;
+
 	if (!strncmp(q, "!gas", 4) || !strncmp(q, "!6as", 4)) {
-		char* eptr;
-		unsigned long asn = strtoul(q+4, &eptr, 10), asn0, asn1 = 0;
-		if (!asn || asn == ULONG_MAX || asn >= 4294967295
-		    || (eptr && *eptr != '\n')) {
-			sx_report(SX_ERROR, "some problem invalidating asn"
-			    " %s\n", q);
+
+		errno = 0;
+		asn = strtoul(q + 4, &eptr, 10);
+		if (*eptr != '\n') {
+			sx_report(SX_ERROR, "not a number: %s\n", q);
 			return;
 		}
-		asn1 = asn % 65536;
-		asn0 = asn / 65536;
-		if (!b->asn32s[asn0] ||
-			!(b->asn32s[asn0][asn1/8] & (0x80 >> (asn1 % 8)))) {
-			sx_report(SX_NOTICE, "strange, invalidating inactive "
-			    "asn %lu(%s)\n", asn, q);
-		} else {
-			b->asn32s[asn0][asn1 / 8] &= ~(0x80 >> (asn1 % 8));
+		if (errno == ERANGE && asn == ULONG_MAX) {
+			sx_report(SX_ERROR, "overflow: %s\n", q);
+			return;
+		}
+		if (asn == 0 || asn >= 4294967295) {
+			sx_report(SX_ERROR, "out of range: %s\n", q);
+			return;
+		}
+		if (eptr && *eptr != '\n') {
+			sx_report(SX_ERROR, "no number? %s\n", q);
+			return;
+		}
+
+		find.asn = asn;
+		if ((res = RB_FIND(asn_tree, &b->asnlist, &find)) == NULL) {
+			RB_REMOVE(asn_tree, &b->asnlist, res);
+			free(res);
 		}
 	}
 }

 static void
-bgpq_write(struct bgpq_expander* b)
+bgpq_write(struct bgpq_expander *b)
 {
 	while(!STAILQ_EMPTY(&b->wq)) {
-		struct bgpq_request* req = STAILQ_FIRST(&b->wq);
+		struct request *req = STAILQ_FIRST(&b->wq);

-		int ret = write(b->fd, req->request+req->offset,
+		int ret = write(b->fd, req->request + req->offset,
 		    req->size-req->offset);

 		if (ret < 0) {
@@ -473,10 +491,10 @@ bgpq_write(struct bgpq_expander* b)
 }

 static int
-bgpq_selread(struct bgpq_expander* b, char* buffer, int size)
+bgpq_selread(struct bgpq_expander *b, char *buffer, int size)
 {
-	fd_set rfd, wfd;
-	int ret;
+	fd_set		rfd, wfd;
+	int		ret;

 repeat:
 	FD_ZERO(&rfd);
@@ -505,8 +523,8 @@ repeat:
 	goto repeat;
 }

-int
-bgpq_read(struct bgpq_expander* b)
+static int
+bgpq_read(struct bgpq_expander *b)
 {
 	static char response[256];
 	static int off = 0;
@@ -515,11 +533,12 @@ bgpq_read(struct bgpq_expander* b)
 		bgpq_write(b);

 	while(!STAILQ_EMPTY(&b->rq)) {
-		struct bgpq_request* req = STAILQ_FIRST(&b->rq);
+		int			 ret = 0;
+		char			*cres;
+		struct request	*req = STAILQ_FIRST(&b->rq);
+
 		SX_DEBUG(debug_expander > 2, "waiting for answer to %s,"
 		    "init %i '%.*s'\n", req->request, off, off, response);
-		int ret = 0;
-		char* cres;

 		if ((cres=strchr(response, '\n')) != NULL)
 			goto have;
@@ -544,17 +563,17 @@ have:
 		    response);

 		if (response[0] == 'A') {
-			char* eon, *c;
-			unsigned long togot = strtoul(response+1,&eon,10);
-			char* recvbuffer = malloc(togot+2);
-			int offset = 0;
+			char		*eon, *c;
+			unsigned long	 offset = 0;
+			unsigned long 	 togot = strtoul(response + 1, &eon, 10);
+			char 		*recvbuffer = malloc(togot + 2);

 			if (!recvbuffer) {
 				sx_report(SX_FATAL, "error allocating %lu "
 				    "bytes: %s\n", togot + 2, strerror(errno));
 			}

-			memset(recvbuffer,0,togot+2);
+			memset(recvbuffer, 0, togot + 2);

 			if (!eon || *eon != '\n') {
 				sx_report(SX_ERROR,"A-code finished with wrong"
@@ -563,7 +582,7 @@ have:
 				exit(1);
 			}

-			if (off - ((eon + 1) - response) > togot) {
+			if ((unsigned)(off - ((eon + 1) - response)) > togot) {
 				// full response and more data is already in buffer
 				memcpy(recvbuffer, eon + 1, togot);
 				offset = togot;
@@ -576,14 +595,14 @@ have:
 				/* response is not yet fully buffered */
 				memcpy(recvbuffer, eon + 1,
 				    off - ((eon + 1) - response));
-				offset = off - ((eon+1) - response);
+				offset = off - ((eon + 1) - response);
 				memset(response, 0, sizeof(response));
 				off = 0;
 			}

-			SX_DEBUG(debug_expander>5,
+			SX_DEBUG(debug_expander > 5,
 			    "starting read with ready '%.*s', waiting for "
-			    "%lu\n", offset, recvbuffer, togot-offset);
+			    "%lu\n", (int)offset, recvbuffer, togot - offset);

 			if (off > 0)
 				goto have3;
@@ -592,7 +611,7 @@ have:

 reread:

-			ret = bgpq_selread(b, recvbuffer + offset, togot-offset);
+			ret = bgpq_selread(b, recvbuffer + offset, togot - offset);
 			if (ret < 0) {
 				if (errno == EAGAIN)
 					goto reread;
@@ -607,7 +626,7 @@ reread:
 				    recvbuffer + offset);
 			offset += ret;
 			if (offset < togot) {
-				SX_DEBUG(debug_expander>5, "expected %lu, got "
+				SX_DEBUG(debug_expander > 5, "expected %lu, got "
 				    "%lu expanding %s", togot,
 				    strlen(recvbuffer), req->request);
 				goto reread;
@@ -648,7 +667,7 @@ have3:
 				if (c[0] == 0)
 					break;
 				req->callback(c, b, req);
-				c += spn+1;
+				c += spn + 1;
 			}
 			assert(c == recvbuffer + togot);
 			memset(recvbuffer, 0, togot + 2);
@@ -678,7 +697,7 @@ have3:
 		}

 		memmove(response, cres + 1, off - ((cres + 1) - response));
-		off -= (cres+1) - response;
+		off -= (cres + 1) - response;
 		memset(response + off, 0, sizeof(response) - off);
 		SX_DEBUG(debug_expander > 5,
 		    "fixed response of %i, %.*s\n", off, off, response);
@@ -686,36 +705,34 @@ have3:
 		STAILQ_REMOVE_HEAD(&b->rq, next);
 		b->piped--;

-		bgpq_request_free(req);
+		request_free(req);
 	}

 	return 0;
 }

 int
-bgpq_expand_irrd(struct bgpq_expander* b,
-    int (*callback)(char*, struct bgpq_expander*, struct bgpq_request* ),
-    void* udata, char* fmt, ...)
+bgpq_expand_irrd(struct bgpq_expander *b,
+    int (*callback)(char *, struct bgpq_expander *, struct request *),
+    void *udata, char *fmt, ...)
 {
-	char request[128], response[128];
-	va_list ap;
-	int ret, off = 0;
-	struct bgpq_request *req;
+	char			 request[128], response[128];
+	va_list			 ap;
+	ssize_t			 ret;
+	int			 off = 0;
+	struct request	*req;

-	va_start(ap,fmt);
+	va_start(ap, fmt);
 	vsnprintf(request, sizeof(request), fmt, ap);
 	va_end(ap);

-	req = bgpq_request_alloc(request, callback, udata);
+	req = request_alloc(request, callback, udata);

-	SX_DEBUG(debug_expander, "expander: sending '%s'\n", request);
+	SX_DEBUG(debug_expander, "expander sending: %s", request);
+
+	if ((ret = write(b->fd, request, strlen(request)) == 0) || ret == -1)
+		err(1, "write");

-	ret=write(b->fd, request, strlen(request));
-	if (ret != strlen(request)) {
-		sx_report(SX_FATAL,"Partial write to IRRd, only %i bytes "
-		    "written: %s\n", ret, strerror(errno));
-		exit(1);
-	}
 	memset(response, 0, sizeof(response));

 repeat:
@@ -738,10 +755,10 @@ repeat:
 	    "'%s'\n", (unsigned long)strlen(response), response);

 	if (response[0] == 'A') {
-		char* eon, *c;
-		long togot = strtoul(response+1, &eon, 10);
-		char *recvbuffer = malloc(togot + 2);
-		int offset = 0;
+		char	*eon, *c;
+		long 	 togot = strtoul(response + 1, &eon, 10);
+		char 	*recvbuffer = malloc(togot + 2);
+		int 	 offset = 0;

 		if (!recvbuffer) {
 			sx_report(SX_FATAL, "Error allocating %lu bytes: %s\n",
@@ -749,13 +766,13 @@ repeat:
 		}

 		if (eon && *eon != '\n') {
-			sx_report(SX_ERROR,"A-code finised with wrong char "
-			    "'%c' (%s)\n", *eon,response);
+			sx_report(SX_ERROR,"A-code finished with wrong char "
+			    "'%c' (%s)\n", *eon, response);
 			exit(1);
 		}

-		if (off - ((eon + 1)-response) > togot) {
-			memcpy(recvbuffer, eon+1, togot);
+		if (off - ((eon + 1) - response) > togot) {
+			memcpy(recvbuffer, eon + 1, togot);
 			offset = togot;
 			memmove(response, eon + 1 + togot,
 			    off - ((eon + 1) - response) - togot);
@@ -802,7 +819,7 @@ have3:
 		if (!strchr(response, '\n'))
 			goto reread2;

-		SX_DEBUG(debug_expander>2,"expander: final reply of %lu bytes,"
+		SX_DEBUG(debug_expander > 2,"expander: final reply of %lu bytes,"
 		    " %.*sreturn code %.*s",
 		    (unsigned long)strlen(recvbuffer), offset, recvbuffer, off,
 		    response);
@@ -835,18 +852,20 @@ have3:
 		sx_report(SX_ERROR,"Wrong reply: %s\n", response);
 		exit(0);
 	}
-	bgpq_request_free(req);
+	request_free(req);

 	return 0;
 }

 int
-bgpq_expand(struct bgpq_expander* b)
+bgpq_expand(struct bgpq_expander *b)
 {
-	int fd = -1, err, ret, aquery = 0;
-	struct sx_slentry* mc;
-	struct addrinfo hints, *res=NULL, *rp;
-	struct linger sl;
+	int			 fd = -1, err, ret, aquery = 0;
+	struct slentry		*mc;
+	struct addrinfo 	 hints, *res = NULL, *rp;
+	struct linger		 sl;
+	struct asn_entry	*asne;
+
 	sl.l_onoff = 1;
 	sl.l_linger = 5;

@@ -865,7 +884,7 @@ bgpq_expand(struct bgpq_expander* b)
 	for (rp=res; rp; rp = rp->ai_next) {
 		fd = socket(rp->ai_family, rp->ai_socktype, 0);
 		if (fd == -1) {
-			if (errno==EPROTONOSUPPORT || errno==EAFNOSUPPORT)
+			if (errno == EPROTONOSUPPORT || errno == EAFNOSUPPORT)
 				continue;
 			sx_report(SX_ERROR,"Unable to create socket: %s\n",
 			    strerror(errno));
@@ -908,10 +927,10 @@ bgpq_expand(struct bgpq_expander* b)
 	b->fd = fd;

 	SX_DEBUG(debug_expander, "Sending '!!' to server to request for the"
-	    "connection to remain open\n");
+	    " connection to remain open\n");
 	if ((ret = write(fd, "!!\n", 3)) != 3) {
-		sx_report(SX_ERROR, "Partial write of multiple command mode to IRRd: %i bytes, %s\n",
-		    ret, strerror(errno));
+		sx_report(SX_ERROR, "Partial write of multiple command mode "
+		    "to IRRd: %i bytes, %s\n", ret, strerror(errno));
 		exit(1);
 	}

@@ -922,7 +941,8 @@ bgpq_expand(struct bgpq_expander* b)
 		int ilen = snprintf(ident, sizeof(ident), "!n" PACKAGE_STRING "\n");
 		if (ilen > 0) {
 			if ((ret = write(fd, ident, ilen)) != ilen) {
-				sx_report(SX_ERROR, "Partial write of identifier to IRRd: %i bytes, %s\n",
+				sx_report(SX_ERROR, "Partial write of "
+				    "identifier to IRRd: %i bytes, %s\n",
 				    ret, strerror(errno));
 				exit(1);
 			}
@@ -930,7 +950,7 @@ bgpq_expand(struct bgpq_expander* b)
 			if (0 < read(fd, ident, sizeof(ident))) {
 				SX_DEBUG(debug_expander, "Got answer %s", ident);
 			} else {
-				sx_report(SX_ERROR, "ident - failed read from IRRd\n");
+				sx_report(SX_ERROR, "ident, failed read from IRRd\n");
 				exit(1);
 			}
 		} else {
@@ -945,8 +965,8 @@ bgpq_expand(struct bgpq_expander* b)
 		char aresp[] = "F Missing required set name for A query";
 		SX_DEBUG(debug_expander, "Testing support for A queries\n");
 		if ((ret = write(fd, "!a\n", 3)) != 3) {
-			sx_report(SX_ERROR, "Partial write of '!a' test query to IRRd: %i bytes, %s\n",
-			    ret, strerror(errno));
+			sx_report(SX_ERROR, "Partial write of '!a' test query "
+			    "to IRRd: %i bytes, %s\n", ret, strerror(errno));
 			exit(1);
 		}
 		memset(aret, 0, sizeof(aret));
@@ -955,10 +975,10 @@ bgpq_expand(struct bgpq_expander* b)
 				SX_DEBUG(debug_expander, "Server supports A query\n");
 				aquery = 1;
 			} else {
-				SX_DEBUG(debug_expander, "No support for A queries\n");
+				SX_DEBUG(debug_expander, "No support for A query\n");
 			}
 		} else {
-			sx_report(SX_ERROR, "'!a' query test - failed read from IRRd\n");
+			sx_report(SX_ERROR, "A query test failed read from IRRd\n");
 			exit(1);
 		}
 	}
@@ -972,20 +992,20 @@ bgpq_expand(struct bgpq_expander* b)
 		if (slen > 0) {
 			SX_DEBUG(debug_expander, "Requesting sources %s", sources);
 			if ((ret = write(fd, sources, slen)) != slen) {
-				sx_report(SX_ERROR, "Partial write of sources to IRRd: %i bytes, %s\n",
-				    ret, strerror(errno));
+				sx_report(SX_ERROR, "Partial write of sources to "
+				    "IRRd: %i bytes, %s\n", ret, strerror(errno));
 				exit(1);
 			}
 			memset(sources, 0, sizeof(sources));
 			if (0 < read(fd, sources, sizeof(sources))) {
 				SX_DEBUG(debug_expander, "Got answer %s", sources);
 				if (sources[0] != 'C') {
-					sx_report(SX_ERROR, "Invalid source(s) '%s': %s\n",
-					    b->sources, sources);
+					sx_report(SX_ERROR, "Invalid source(s) "
+					    "'%s': %s\n", b->sources, sources);
 					exit(1);
 				}
 			} else {
-				sx_report(SX_ERROR, "sources - failed read from IRRd\n");
+				sx_report(SX_ERROR, "failed to read sources\n");
 				exit(1);
 			}
 		} else {
@@ -997,7 +1017,7 @@ bgpq_expand(struct bgpq_expander* b)
 	if (pipelining)
 		fcntl(fd, F_SETFL, O_NONBLOCK|(fcntl(fd, F_GETFL)));

-	STAILQ_FOREACH(mc, &b->macroses, next) {
+	STAILQ_FOREACH(mc, &b->macroses, entry) {
 		if (!b->maxdepth && RB_EMPTY(&b->stoplist)) {
 			if (aquery)
 				bgpq_expand_irrd(b, bgpq_expanded_prefix, b,
@@ -1008,7 +1028,7 @@ bgpq_expand(struct bgpq_expander* b)
 				bgpq_expand_irrd(b, bgpq_expanded_macro, b,
 				    "!i%s,1\n", mc->text);
 		} else {
-			bgpq_expander_add_already(b,mc->text);
+			bgpq_expander_add_already(b, mc->text);
 			if (pipelining)
 				bgpq_pipeline(b, bgpq_expanded_macro_limit,
 				    NULL, "!i%s\n", mc->text);
@@ -1026,8 +1046,7 @@ bgpq_expand(struct bgpq_expander* b)
 	}

 	if (b->generation >= T_PREFIXLIST || b->validate_asns) {
-		uint32_t i, j, k;
-		STAILQ_FOREACH(mc, &b->rsets, next) {
+		STAILQ_FOREACH(mc, &b->rsets, entry) {
 			if (b->family == AF_INET)
 				bgpq_expand_irrd(b, bgpq_expanded_prefix,
 				    NULL, "!i%s,1\n", mc->text);
@@ -1035,33 +1054,27 @@ bgpq_expand(struct bgpq_expander* b)
 				bgpq_expand_irrd(b, bgpq_expanded_v6prefix,
 				    NULL, "!i%s,1\n", mc->text);
 		}
-		for (k=0; k < sizeof(b->asn32s) / sizeof(unsigned char*); k++) {
-			if (!b->asn32s[k])
-				continue;
-			for (i=0; i<8192; i++) {
-				for (j=0; j<8; j++) {
-					if (b->asn32s[k][i] & (0x80 >> j)) {
-						if (b->family == AF_INET6) {
-							if (!pipelining) {
-								bgpq_expand_irrd(b, bgpq_expanded_v6prefix,
-								    NULL, "!6as%" PRIu32 "\n", ( k << 16) + i * 8 + j);
-							} else {
-								bgpq_pipeline(b, bgpq_expanded_v6prefix,
-								    NULL, "!6as%" PRIu32 "\n", (k << 16) + i * 8 + j);
-							}
-						} else {
-							if (!pipelining) {
-								bgpq_expand_irrd(b, bgpq_expanded_prefix,
-								    NULL, "!gas%" PRIu32 "\n", (k << 16) + i * 8 + j);
-							} else {
-								bgpq_pipeline(b, bgpq_expanded_prefix,
-								    NULL, "!gas%" PRIu32 "\n", ( k<< 16) + i* 8 + j);
-							}
-						}
-					}
+
+		RB_FOREACH(asne, asn_tree, &b->asnlist) {
+			if (b->family == AF_INET6) {
+				if (!pipelining) {
+					bgpq_expand_irrd(b, bgpq_expanded_v6prefix,
+					    NULL, "!6as%" PRIu32 "\n", asne->asn);
+				} else {
+					bgpq_pipeline(b, bgpq_expanded_v6prefix,
+					    NULL, "!6as%" PRIu32 "\n", asne->asn);
+				}
+			} else {
+				if (!pipelining) {
+					bgpq_expand_irrd(b, bgpq_expanded_prefix,
+					    NULL, "!gas%" PRIu32 "\n", asne->asn);
+				} else {
+					bgpq_pipeline(b, bgpq_expanded_prefix,
+					    NULL, "!gas%" PRIu32 "\n", asne->asn);
 				}
 			}
 		}
+
 		if (pipelining) {
 			if (!STAILQ_EMPTY(&b->wq))
 				bgpq_write(b);
@@ -1085,3 +1098,81 @@ bgpq_expand(struct bgpq_expander* b)
 	return 1;
 }

+void
+sx_radix_node_freeall(struct sx_radix_node *n) {
+
+	if (n->l != NULL)
+		sx_radix_node_freeall(n->l);
+
+	if (n->r != NULL)
+		sx_radix_node_freeall(n->r);
+
+	if (n->son != NULL)
+		sx_radix_node_freeall(n->son);
+
+	if (n->payload)
+		free(n->payload);
+
+	sx_prefix_destroy(n->prefix);
+
+	free(n);
+}
+
+void
+sx_radix_tree_freeall(struct sx_radix_tree *t) {
+
+	if (t->head != NULL)
+		sx_radix_node_freeall(t->head);
+
+	free(t);
+}
+
+void
+bgpq_prequest_freeall(struct bgpq_prequest *bpr) {
+}
+
+void
+expander_freeall(struct bgpq_expander *expander) {
+	struct sx_tentry	*var, *nxt;
+	struct asn_entry	*asne, *asne_next;
+
+	while (!STAILQ_EMPTY(&expander->macroses)) {
+		struct slentry *n1 = STAILQ_FIRST(&expander->macroses);
+		STAILQ_REMOVE_HEAD(&expander->macroses, entry);
+		free(n1->text);
+		free(n1);
+	}
+
+	while (!STAILQ_EMPTY(&expander->rsets)) {
+		struct slentry *n1 = STAILQ_FIRST(&expander->rsets);
+		STAILQ_REMOVE_HEAD(&expander->rsets, entry);
+		free(n1->text);
+		free(n1);
+	}
+
+	for (var = RB_MIN(tentree, &expander->already); var != NULL; var = nxt) {
+		nxt = RB_NEXT(tentree, &expander->already, var);
+		RB_REMOVE(tentree, &expander->already, var);
+		free(var->text);
+		free(var);
+	}
+
+	for (var = RB_MIN(tentree, &expander->stoplist); var != NULL; var = nxt) {
+		nxt = RB_NEXT(tentree, &expander->stoplist, var);
+		RB_REMOVE(tentree, &expander->stoplist, var);
+		free(var->text);
+		free(var);
+	}
+
+	for (asne = RB_MIN(asn_tree, &expander->asnlist);
+	    asne != NULL; asne = asne_next) {
+		asne_next = RB_NEXT(asn_tree, &expander->asnlist, asne);
+		RB_REMOVE(asn_tree, &expander->asnlist, asne);
+		free(asne);
+	}
+
+	sx_radix_tree_freeall(expander->tree);
+
+	bgpq_prequest_freeall(expander->firstpipe);
+	bgpq_prequest_freeall(expander->lastpipe);
+}
--- a/expander_freeall.c
+++ b/expander_freeall.c
@@ -1,83 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <bgpq4.h>
-
-void
-sx_radix_node_freeall(struct sx_radix_node *n) {
-
-	if (n->l != NULL)
-		sx_radix_node_freeall(n->l);
-
-	if (n->r != NULL)
-		sx_radix_node_freeall(n->r);
-
-	if (n->son != NULL)
-		sx_radix_node_freeall(n->son);
-
-	if (n->payload)
-		free(n->payload);
-
-	sx_prefix_destroy(n->prefix);
-
-	free(n);
-}
-
-void
-sx_radix_tree_freeall(struct sx_radix_tree *t) {
-
-	if (t->head != NULL)
-		sx_radix_node_freeall(t->head);
-
-	free(t);
-}
-
-void
-bgpq_prequest_freeall(struct bgpq_prequest *bpr) {
-}
-
-void
-expander_freeall(struct bgpq_expander *expander) {
-
-	// printf("starting to free all\n");
-	// seg fault here
-	// if (expander->sources != NULL) {
-	//  printf("freeing soruces\n");
-	//  free(expander->sources);
-	//}
-	//  if (expander->name != NULL) {
-	//  printf("freeing name\n");
-	//  free(expander->name);
-	//}
-	// printf("freeing asn32s\n");
-
-	for (int i = 0; i < 65536; i++) {
-		if (expander->asn32s[i] != NULL) {
-			free(expander->asn32s[i]);
-		}
-	}
-
-	// if (expander->match != NULL) {
-	// printf("freeing match\n");
-	//  free(expander->match);
-	//}
-	//if (expander->server != NULL) {
-	//  printf("freeing server\n");
-	//  free(expander->server);
-	//}
-	//if (expander->port != NULL) {
-	//   printf("freeing port\n");
-	//   free(expander->port);
-	//}
-	//if (expander->format != NULL) {
-	//  printf("freeing format\n");
-	//  free(expander->format);
-	//}
-
-	sx_radix_tree_freeall(expander->tree);
-
-	bgpq_prequest_freeall(expander->firstpipe);
-	bgpq_prequest_freeall(expander->lastpipe);
-
-	// printf("finished freeing all\n");
-}
--- a/expander_freeall.h
+++ b/expander_freeall.h
@@ -1,5 +0,0 @@
-
-void sx_radix_node_freeall(struct sx_radix_node *n);
-void sx_radix_tree_freeall(struct sx_radix_tree *t);
-void bgpq_prequest_freeall(struct bgpq_prequest *bpr);
-void expander_freeall(struct bgpq_expander *expander);
--- a/extern.h
+++ b/extern.h
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2007-2019 Alexandre Snarskii <snar@snar.spb.ru>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/queue.h>
+#include <sys/tree.h>
+
+#include "sx_prefix.h"
+
+struct slentry {
+	STAILQ_ENTRY(slentry)	 entry;
+	char			*text;
+};
+
+struct slentry		*sx_slentry_new(char *text);
+
+struct sx_tentry {
+	RB_ENTRY(sx_tentry)	 entry;
+	char			*text;
+};
+
+struct sx_tentry	*sx_tentry_new(char *text);
+
+struct asn_entry {
+	RB_ENTRY(asn_entry)	entry;
+	uint32_t		asn;
+};
+
+typedef enum {
+	V_CISCO = 0,
+	V_JUNIPER,
+	V_CISCO_XR,
+	V_JSON,
+	V_BIRD,
+	V_OPENBGPD,
+	V_FORMAT,
+	V_NOKIA,
+	V_HUAWEI,
+	V_MIKROTIK,
+	V_NOKIA_MD,
+	V_ARISTA
+} bgpq_vendor_t;
+
+typedef enum {
+	T_NONE = 0,
+	T_ASPATH,
+	T_OASPATH,
+	T_ASSET,
+	T_PREFIXLIST,	
+	T_EACL,
+	T_ROUTE_FILTER_LIST
+} bgpq_gen_t;
+
+struct bgpq_expander;
+
+struct request {
+	STAILQ_ENTRY(request)	 next;
+	char			*request;
+	int 	 	 	 size, offset;
+	void			*udata;
+	unsigned int	 	 depth;
+	int	 	 	 (*callback)(char *, struct bgpq_expander *,
+				    struct request *);
+};
+
+struct bgpq_expander {
+	struct sx_radix_tree	 	*tree;
+	int			 	 family;
+	char				*sources;
+	uint32_t		 	 asnumber;
+	int			 	 aswidth;
+	char				*name;
+	bgpq_vendor_t		 	 vendor;
+	bgpq_gen_t		 	 generation;
+	int			 	 identify;
+	int			 	 sequence;
+	unsigned int		 	 maxdepth;
+	unsigned int		 	 cdepth;
+	int			 	 validate_asns;
+	struct bgpq_prequest		*firstpipe, *lastpipe;
+	int 			 	 piped;
+	char				*match;
+	char				*server;
+	char				*port;
+	char				*format;
+	unsigned int		 	 maxlen;
+	int			 	 fd;
+	RB_HEAD(asn_tree, asn_entry)	 asnlist;
+	STAILQ_HEAD(requests, request)	 wq, rq;
+	STAILQ_HEAD(slentries, slentry)	 macroses, rsets;
+	RB_HEAD(tentree, sx_tentry)	 already, stoplist;
+};
+
+int asn_cmp(struct asn_entry *, struct asn_entry *);
+RB_PROTOTYPE(asn_tree, asn_entry, entry, asn_cmp);
+
+int bgpq_expander_init(struct bgpq_expander *b, int af);
+int bgpq_expander_add_asset(struct bgpq_expander *b, char *set);
+int bgpq_expander_add_rset(struct bgpq_expander *b, char *set);
+int bgpq_expander_add_as(struct bgpq_expander *b, char *as);
+int bgpq_expander_add_prefix(struct bgpq_expander *b, char *prefix);
+int bgpq_expander_add_prefix_range(struct bgpq_expander *b, char *prefix);
+int bgpq_expander_add_stop(struct bgpq_expander *b, char *object);
+
+int bgpq_expand(struct bgpq_expander *b);
+
+void bgpq4_print_prefixlist(FILE *f, struct bgpq_expander *b);
+void bgpq4_print_eacl(FILE *f, struct bgpq_expander *b);
+void bgpq4_print_aspath(FILE *f, struct bgpq_expander *b);
+void bgpq4_print_asset(FILE *f, struct bgpq_expander *b);
+void bgpq4_print_oaspath(FILE *f, struct bgpq_expander *b);
+void bgpq4_print_route_filter_list(FILE *f, struct bgpq_expander *b);
+
+void sx_radix_node_freeall(struct sx_radix_node *n);
+void sx_radix_tree_freeall(struct sx_radix_tree *t);
+void bgpq_prequest_freeall(struct bgpq_prequest *bpr);
+void expander_freeall(struct bgpq_expander *expander);
+
+/* s - number of opened socket, dir is either SO_SNDBUF or SO_RCVBUF */
+int sx_maxsockbuf(int s, int dir);
+
+#ifndef HAVE_STRLCPY
+size_t strlcpy(char *dst, const char *src, size_t size);
+#endif
--- a/include/Makefile.am
+++ b/include/Makefile.am
@@ -0,0 +1,6 @@
+noinst_HEADERS =
+noinst_HEADERS += sys/_null.h
+noinst_HEADERS += sys/queue.h
+noinst_HEADERS += sys/tree.h
+noinst_HEADERS += sys/types.h
+noinst_HEADERS += string.h
--- a/include/string.h
+++ b/include/string.h
@@ -0,0 +1,24 @@
+/*
+ * Public domain
+ * string.h compatibility shim
+ */
+
+#include_next <string.h>
+
+#ifndef LIBCOMPAT_STRING_H
+#define LIBCOMPAT_STRING_H
+
+#include <sys/types.h>
+
+#if defined(__sun) || defined(__hpux)
+/* Some functions historically defined in string.h were placed in strings.h by
+ * SUS. Use the same hack as OS X and FreeBSD use to work around on Solaris and HPUX.
+ */
+#include <strings.h>
+#endif
+
+#ifndef HAVE_STRLCPY
+size_t strlcpy(char *dst, const char *src, size_t siz);
+#endif
+
+#endif
--- a/include/sys/_null.h
+++ b/include/sys/_null.h
@@ -0,0 +1,18 @@
+/*	$OpenBSD: _null.h,v 1.2 2016/09/09 22:07:58 millert Exp $	*/
+
+/*
+ * Written by Todd C. Miller, September 9, 2016
+ * Public domain.
+ */
+
+#ifndef NULL
+#if !defined(__cplusplus)
+#define	NULL	((void *)0)
+#elif __cplusplus >= 201103L
+#define	NULL	nullptr
+#elif defined(__GNUG__)
+#define	NULL	__null
+#else
+#define	NULL	0L
+#endif
+#endif
--- a/include/sys/queue.h
+++ b/include/sys/queue.h
@@ -0,0 +1,633 @@
+/*	$OpenBSD: queue.h,v 1.46 2020/12/30 13:33:12 millert Exp $	*/
+/*	$NetBSD: queue.h,v 1.11 1996/05/16 05:17:14 mycroft Exp $	*/
+
+/*
+ * Copyright (c) 1991, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)queue.h	8.5 (Berkeley) 8/20/94
+ */
+
+#ifndef	_SYS_QUEUE_H_
+#define	_SYS_QUEUE_H_
+
+#include <sys/_null.h>
+
+/*
+ * This file defines five types of data structures: singly-linked lists,
+ * lists, simple queues, tail queues and XOR simple queues.
+ *
+ *
+ * A singly-linked list is headed by a single forward pointer. The elements
+ * are singly linked for minimum space and pointer manipulation overhead at
+ * the expense of O(n) removal for arbitrary elements. New elements can be
+ * added to the list after an existing element or at the head of the list.
+ * Elements being removed from the head of the list should use the explicit
+ * macro for this purpose for optimum efficiency. A singly-linked list may
+ * only be traversed in the forward direction.  Singly-linked lists are ideal
+ * for applications with large datasets and few or no removals or for
+ * implementing a LIFO queue.
+ *
+ * A list is headed by a single forward pointer (or an array of forward
+ * pointers for a hash table header). The elements are doubly linked
+ * so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before
+ * or after an existing element or at the head of the list. A list
+ * may only be traversed in the forward direction.
+ *
+ * A simple queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are singly
+ * linked to save space, so elements can only be removed from the
+ * head of the list. New elements can be added to the list before or after
+ * an existing element, at the head of the list, or at the end of the
+ * list. A simple queue may only be traversed in the forward direction.
+ *
+ * A tail queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are doubly
+ * linked so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before or
+ * after an existing element, at the head of the list, or at the end of
+ * the list. A tail queue may be traversed in either direction.
+ *
+ * An XOR simple queue is used in the same way as a regular simple queue.
+ * The difference is that the head structure also includes a "cookie" that
+ * is XOR'd with the queue pointer (first, last or next) to generate the
+ * real pointer value.
+ *
+ * For details on the use of these macros, see the queue(3) manual page.
+ */
+
+#if defined(QUEUE_MACRO_DEBUG) || (defined(_KERNEL) && defined(DIAGNOSTIC))
+#define _Q_INVALID ((void *)-1)
+#define _Q_INVALIDATE(a) (a) = _Q_INVALID
+#else
+#define _Q_INVALIDATE(a)
+#endif
+
+/*
+ * Singly-linked List definitions.
+ */
+#define SLIST_HEAD(name, type)						\
+struct name {								\
+	struct type *slh_first;	/* first element */			\
+}
+
+#define	SLIST_HEAD_INITIALIZER(head)					\
+	{ NULL }
+
+#define SLIST_ENTRY(type)						\
+struct {								\
+	struct type *sle_next;	/* next element */			\
+}
+
+/*
+ * Singly-linked List access methods.
+ */
+#define	SLIST_FIRST(head)	((head)->slh_first)
+#define	SLIST_END(head)		NULL
+#define	SLIST_EMPTY(head)	(SLIST_FIRST(head) == SLIST_END(head))
+#define	SLIST_NEXT(elm, field)	((elm)->field.sle_next)
+
+#define	SLIST_FOREACH(var, head, field)					\
+	for((var) = SLIST_FIRST(head);					\
+	    (var) != SLIST_END(head);					\
+	    (var) = SLIST_NEXT(var, field))
+
+#define	SLIST_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = SLIST_FIRST(head);				\
+	    (var) && ((tvar) = SLIST_NEXT(var, field), 1);		\
+	    (var) = (tvar))
+
+/*
+ * Singly-linked List functions.
+ */
+#define	SLIST_INIT(head) {						\
+	SLIST_FIRST(head) = SLIST_END(head);				\
+}
+
+#define	SLIST_INSERT_AFTER(slistelm, elm, field) do {			\
+	(elm)->field.sle_next = (slistelm)->field.sle_next;		\
+	(slistelm)->field.sle_next = (elm);				\
+} while (0)
+
+#define	SLIST_INSERT_HEAD(head, elm, field) do {			\
+	(elm)->field.sle_next = (head)->slh_first;			\
+	(head)->slh_first = (elm);					\
+} while (0)
+
+#define	SLIST_REMOVE_AFTER(elm, field) do {				\
+	(elm)->field.sle_next = (elm)->field.sle_next->field.sle_next;	\
+} while (0)
+
+#define	SLIST_REMOVE_HEAD(head, field) do {				\
+	(head)->slh_first = (head)->slh_first->field.sle_next;		\
+} while (0)
+
+#define SLIST_REMOVE(head, elm, type, field) do {			\
+	if ((head)->slh_first == (elm)) {				\
+		SLIST_REMOVE_HEAD((head), field);			\
+	} else {							\
+		struct type *curelm = (head)->slh_first;		\
+									\
+		while (curelm->field.sle_next != (elm))			\
+			curelm = curelm->field.sle_next;		\
+		curelm->field.sle_next =				\
+		    curelm->field.sle_next->field.sle_next;		\
+	}								\
+	_Q_INVALIDATE((elm)->field.sle_next);				\
+} while (0)
+
+/*
+ * List definitions.
+ */
+#define LIST_HEAD(name, type)						\
+struct name {								\
+	struct type *lh_first;	/* first element */			\
+}
+
+#define LIST_HEAD_INITIALIZER(head)					\
+	{ NULL }
+
+#define LIST_ENTRY(type)						\
+struct {								\
+	struct type *le_next;	/* next element */			\
+	struct type **le_prev;	/* address of previous next element */	\
+}
+
+/*
+ * List access methods.
+ */
+#define	LIST_FIRST(head)		((head)->lh_first)
+#define	LIST_END(head)			NULL
+#define	LIST_EMPTY(head)		(LIST_FIRST(head) == LIST_END(head))
+#define	LIST_NEXT(elm, field)		((elm)->field.le_next)
+
+#define LIST_FOREACH(var, head, field)					\
+	for((var) = LIST_FIRST(head);					\
+	    (var)!= LIST_END(head);					\
+	    (var) = LIST_NEXT(var, field))
+
+#define	LIST_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = LIST_FIRST(head);				\
+	    (var) && ((tvar) = LIST_NEXT(var, field), 1);		\
+	    (var) = (tvar))
+
+/*
+ * List functions.
+ */
+#define	LIST_INIT(head) do {						\
+	LIST_FIRST(head) = LIST_END(head);				\
+} while (0)
+
+#define LIST_INSERT_AFTER(listelm, elm, field) do {			\
+	if (((elm)->field.le_next = (listelm)->field.le_next) != NULL)	\
+		(listelm)->field.le_next->field.le_prev =		\
+		    &(elm)->field.le_next;				\
+	(listelm)->field.le_next = (elm);				\
+	(elm)->field.le_prev = &(listelm)->field.le_next;		\
+} while (0)
+
+#define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
+	(elm)->field.le_prev = (listelm)->field.le_prev;		\
+	(elm)->field.le_next = (listelm);				\
+	*(listelm)->field.le_prev = (elm);				\
+	(listelm)->field.le_prev = &(elm)->field.le_next;		\
+} while (0)
+
+#define LIST_INSERT_HEAD(head, elm, field) do {				\
+	if (((elm)->field.le_next = (head)->lh_first) != NULL)		\
+		(head)->lh_first->field.le_prev = &(elm)->field.le_next;\
+	(head)->lh_first = (elm);					\
+	(elm)->field.le_prev = &(head)->lh_first;			\
+} while (0)
+
+#define LIST_REMOVE(elm, field) do {					\
+	if ((elm)->field.le_next != NULL)				\
+		(elm)->field.le_next->field.le_prev =			\
+		    (elm)->field.le_prev;				\
+	*(elm)->field.le_prev = (elm)->field.le_next;			\
+	_Q_INVALIDATE((elm)->field.le_prev);				\
+	_Q_INVALIDATE((elm)->field.le_next);				\
+} while (0)
+
+#define LIST_REPLACE(elm, elm2, field) do {				\
+	if (((elm2)->field.le_next = (elm)->field.le_next) != NULL)	\
+		(elm2)->field.le_next->field.le_prev =			\
+		    &(elm2)->field.le_next;				\
+	(elm2)->field.le_prev = (elm)->field.le_prev;			\
+	*(elm2)->field.le_prev = (elm2);				\
+	_Q_INVALIDATE((elm)->field.le_prev);				\
+	_Q_INVALIDATE((elm)->field.le_next);				\
+} while (0)
+
+/*
+ * Simple queue definitions.
+ */
+#define SIMPLEQ_HEAD(name, type)					\
+struct name {								\
+	struct type *sqh_first;	/* first element */			\
+	struct type **sqh_last;	/* addr of last next element */		\
+}
+
+#define SIMPLEQ_HEAD_INITIALIZER(head)					\
+	{ NULL, &(head).sqh_first }
+
+#define SIMPLEQ_ENTRY(type)						\
+struct {								\
+	struct type *sqe_next;	/* next element */			\
+}
+
+/*
+ * Simple queue access methods.
+ */
+#define	SIMPLEQ_FIRST(head)	    ((head)->sqh_first)
+#define	SIMPLEQ_END(head)	    NULL
+#define	SIMPLEQ_EMPTY(head)	    (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head))
+#define	SIMPLEQ_NEXT(elm, field)    ((elm)->field.sqe_next)
+
+#define SIMPLEQ_FOREACH(var, head, field)				\
+	for((var) = SIMPLEQ_FIRST(head);				\
+	    (var) != SIMPLEQ_END(head);					\
+	    (var) = SIMPLEQ_NEXT(var, field))
+
+#define	SIMPLEQ_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = SIMPLEQ_FIRST(head);				\
+	    (var) && ((tvar) = SIMPLEQ_NEXT(var, field), 1);		\
+	    (var) = (tvar))
+
+/*
+ * Simple queue functions.
+ */
+#define	SIMPLEQ_INIT(head) do {						\
+	(head)->sqh_first = NULL;					\
+	(head)->sqh_last = &(head)->sqh_first;				\
+} while (0)
+
+#define SIMPLEQ_INSERT_HEAD(head, elm, field) do {			\
+	if (((elm)->field.sqe_next = (head)->sqh_first) == NULL)	\
+		(head)->sqh_last = &(elm)->field.sqe_next;		\
+	(head)->sqh_first = (elm);					\
+} while (0)
+
+#define SIMPLEQ_INSERT_TAIL(head, elm, field) do {			\
+	(elm)->field.sqe_next = NULL;					\
+	*(head)->sqh_last = (elm);					\
+	(head)->sqh_last = &(elm)->field.sqe_next;			\
+} while (0)
+
+#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
+	if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
+		(head)->sqh_last = &(elm)->field.sqe_next;		\
+	(listelm)->field.sqe_next = (elm);				\
+} while (0)
+
+#define SIMPLEQ_REMOVE_HEAD(head, field) do {			\
+	if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \
+		(head)->sqh_last = &(head)->sqh_first;			\
+} while (0)
+
+#define SIMPLEQ_REMOVE_AFTER(head, elm, field) do {			\
+	if (((elm)->field.sqe_next = (elm)->field.sqe_next->field.sqe_next) \
+	    == NULL)							\
+		(head)->sqh_last = &(elm)->field.sqe_next;		\
+} while (0)
+
+#define SIMPLEQ_CONCAT(head1, head2) do {				\
+	if (!SIMPLEQ_EMPTY((head2))) {					\
+		*(head1)->sqh_last = (head2)->sqh_first;		\
+		(head1)->sqh_last = (head2)->sqh_last;			\
+		SIMPLEQ_INIT((head2));					\
+	}								\
+} while (0)
+
+/*
+ * XOR Simple queue definitions.
+ */
+#define XSIMPLEQ_HEAD(name, type)					\
+struct name {								\
+	struct type *sqx_first;	/* first element */			\
+	struct type **sqx_last;	/* addr of last next element */		\
+	unsigned long sqx_cookie;					\
+}
+
+#define XSIMPLEQ_ENTRY(type)						\
+struct {								\
+	struct type *sqx_next;	/* next element */			\
+}
+
+/*
+ * XOR Simple queue access methods.
+ */
+#define XSIMPLEQ_XOR(head, ptr)	    ((__typeof(ptr))((head)->sqx_cookie ^ \
+					(unsigned long)(ptr)))
+#define	XSIMPLEQ_FIRST(head)	    XSIMPLEQ_XOR(head, ((head)->sqx_first))
+#define	XSIMPLEQ_END(head)	    NULL
+#define	XSIMPLEQ_EMPTY(head)	    (XSIMPLEQ_FIRST(head) == XSIMPLEQ_END(head))
+#define	XSIMPLEQ_NEXT(head, elm, field)    XSIMPLEQ_XOR(head, ((elm)->field.sqx_next))
+
+
+#define XSIMPLEQ_FOREACH(var, head, field)				\
+	for ((var) = XSIMPLEQ_FIRST(head);				\
+	    (var) != XSIMPLEQ_END(head);				\
+	    (var) = XSIMPLEQ_NEXT(head, var, field))
+
+#define	XSIMPLEQ_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = XSIMPLEQ_FIRST(head);				\
+	    (var) && ((tvar) = XSIMPLEQ_NEXT(head, var, field), 1);	\
+	    (var) = (tvar))
+
+/*
+ * XOR Simple queue functions.
+ */
+#define	XSIMPLEQ_INIT(head) do {					\
+	arc4random_buf(&(head)->sqx_cookie, sizeof((head)->sqx_cookie)); \
+	(head)->sqx_first = XSIMPLEQ_XOR(head, NULL);			\
+	(head)->sqx_last = XSIMPLEQ_XOR(head, &(head)->sqx_first);	\
+} while (0)
+
+#define XSIMPLEQ_INSERT_HEAD(head, elm, field) do {			\
+	if (((elm)->field.sqx_next = (head)->sqx_first) ==		\
+	    XSIMPLEQ_XOR(head, NULL))					\
+		(head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \
+	(head)->sqx_first = XSIMPLEQ_XOR(head, (elm));			\
+} while (0)
+
+#define XSIMPLEQ_INSERT_TAIL(head, elm, field) do {			\
+	(elm)->field.sqx_next = XSIMPLEQ_XOR(head, NULL);		\
+	*(XSIMPLEQ_XOR(head, (head)->sqx_last)) = XSIMPLEQ_XOR(head, (elm)); \
+	(head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next);	\
+} while (0)
+
+#define XSIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
+	if (((elm)->field.sqx_next = (listelm)->field.sqx_next) ==	\
+	    XSIMPLEQ_XOR(head, NULL))					\
+		(head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \
+	(listelm)->field.sqx_next = XSIMPLEQ_XOR(head, (elm));		\
+} while (0)
+
+#define XSIMPLEQ_REMOVE_HEAD(head, field) do {				\
+	if (((head)->sqx_first = XSIMPLEQ_XOR(head,			\
+	    (head)->sqx_first)->field.sqx_next) == XSIMPLEQ_XOR(head, NULL)) \
+		(head)->sqx_last = XSIMPLEQ_XOR(head, &(head)->sqx_first); \
+} while (0)
+
+#define XSIMPLEQ_REMOVE_AFTER(head, elm, field) do {			\
+	if (((elm)->field.sqx_next = XSIMPLEQ_XOR(head,			\
+	    (elm)->field.sqx_next)->field.sqx_next)			\
+	    == XSIMPLEQ_XOR(head, NULL))				\
+		(head)->sqx_last = 					\
+		    XSIMPLEQ_XOR(head, &(elm)->field.sqx_next);		\
+} while (0)
+
+
+/*
+ * Tail queue definitions.
+ */
+#define TAILQ_HEAD(name, type)						\
+struct name {								\
+	struct type *tqh_first;	/* first element */			\
+	struct type **tqh_last;	/* addr of last next element */		\
+}
+
+#define TAILQ_HEAD_INITIALIZER(head)					\
+	{ NULL, &(head).tqh_first }
+
+#define TAILQ_ENTRY(type)						\
+struct {								\
+	struct type *tqe_next;	/* next element */			\
+	struct type **tqe_prev;	/* address of previous next element */	\
+}
+
+/*
+ * Tail queue access methods.
+ */
+#define	TAILQ_FIRST(head)		((head)->tqh_first)
+#define	TAILQ_END(head)			NULL
+#define	TAILQ_NEXT(elm, field)		((elm)->field.tqe_next)
+#define TAILQ_LAST(head, headname)					\
+	(*(((struct headname *)((head)->tqh_last))->tqh_last))
+/* XXX */
+#define TAILQ_PREV(elm, headname, field)				\
+	(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
+#define	TAILQ_EMPTY(head)						\
+	(TAILQ_FIRST(head) == TAILQ_END(head))
+
+#define TAILQ_FOREACH(var, head, field)					\
+	for((var) = TAILQ_FIRST(head);					\
+	    (var) != TAILQ_END(head);					\
+	    (var) = TAILQ_NEXT(var, field))
+
+#define	TAILQ_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = TAILQ_FIRST(head);					\
+	    (var) != TAILQ_END(head) &&					\
+	    ((tvar) = TAILQ_NEXT(var, field), 1);			\
+	    (var) = (tvar))
+
+
+#define TAILQ_FOREACH_REVERSE(var, head, headname, field)		\
+	for((var) = TAILQ_LAST(head, headname);				\
+	    (var) != TAILQ_END(head);					\
+	    (var) = TAILQ_PREV(var, headname, field))
+
+#define	TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)	\
+	for ((var) = TAILQ_LAST(head, headname);			\
+	    (var) != TAILQ_END(head) &&					\
+	    ((tvar) = TAILQ_PREV(var, headname, field), 1);		\
+	    (var) = (tvar))
+
+/*
+ * Tail queue functions.
+ */
+#define	TAILQ_INIT(head) do {						\
+	(head)->tqh_first = NULL;					\
+	(head)->tqh_last = &(head)->tqh_first;				\
+} while (0)
+
+#define TAILQ_INSERT_HEAD(head, elm, field) do {			\
+	if (((elm)->field.tqe_next = (head)->tqh_first) != NULL)	\
+		(head)->tqh_first->field.tqe_prev =			\
+		    &(elm)->field.tqe_next;				\
+	else								\
+		(head)->tqh_last = &(elm)->field.tqe_next;		\
+	(head)->tqh_first = (elm);					\
+	(elm)->field.tqe_prev = &(head)->tqh_first;			\
+} while (0)
+
+#define TAILQ_INSERT_TAIL(head, elm, field) do {			\
+	(elm)->field.tqe_next = NULL;					\
+	(elm)->field.tqe_prev = (head)->tqh_last;			\
+	*(head)->tqh_last = (elm);					\
+	(head)->tqh_last = &(elm)->field.tqe_next;			\
+} while (0)
+
+#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
+	if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
+		(elm)->field.tqe_next->field.tqe_prev =			\
+		    &(elm)->field.tqe_next;				\
+	else								\
+		(head)->tqh_last = &(elm)->field.tqe_next;		\
+	(listelm)->field.tqe_next = (elm);				\
+	(elm)->field.tqe_prev = &(listelm)->field.tqe_next;		\
+} while (0)
+
+#define	TAILQ_INSERT_BEFORE(listelm, elm, field) do {			\
+	(elm)->field.tqe_prev = (listelm)->field.tqe_prev;		\
+	(elm)->field.tqe_next = (listelm);				\
+	*(listelm)->field.tqe_prev = (elm);				\
+	(listelm)->field.tqe_prev = &(elm)->field.tqe_next;		\
+} while (0)
+
+#define TAILQ_REMOVE(head, elm, field) do {				\
+	if (((elm)->field.tqe_next) != NULL)				\
+		(elm)->field.tqe_next->field.tqe_prev =			\
+		    (elm)->field.tqe_prev;				\
+	else								\
+		(head)->tqh_last = (elm)->field.tqe_prev;		\
+	*(elm)->field.tqe_prev = (elm)->field.tqe_next;			\
+	_Q_INVALIDATE((elm)->field.tqe_prev);				\
+	_Q_INVALIDATE((elm)->field.tqe_next);				\
+} while (0)
+
+#define TAILQ_REPLACE(head, elm, elm2, field) do {			\
+	if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL)	\
+		(elm2)->field.tqe_next->field.tqe_prev =		\
+		    &(elm2)->field.tqe_next;				\
+	else								\
+		(head)->tqh_last = &(elm2)->field.tqe_next;		\
+	(elm2)->field.tqe_prev = (elm)->field.tqe_prev;			\
+	*(elm2)->field.tqe_prev = (elm2);				\
+	_Q_INVALIDATE((elm)->field.tqe_prev);				\
+	_Q_INVALIDATE((elm)->field.tqe_next);				\
+} while (0)
+
+#define TAILQ_CONCAT(head1, head2, field) do {				\
+	if (!TAILQ_EMPTY(head2)) {					\
+		*(head1)->tqh_last = (head2)->tqh_first;		\
+		(head2)->tqh_first->field.tqe_prev = (head1)->tqh_last;	\
+		(head1)->tqh_last = (head2)->tqh_last;			\
+		TAILQ_INIT((head2));					\
+	}								\
+} while (0)
+
+/*
+ * Singly-linked Tail queue declarations.
+ */
+#define	STAILQ_HEAD(name, type)						\
+struct name {								\
+	struct type *stqh_first;	/* first element */		\
+	struct type **stqh_last;	/* addr of last next element */	\
+}
+
+#define	STAILQ_HEAD_INITIALIZER(head)					\
+	{ NULL, &(head).stqh_first }
+
+#define	STAILQ_ENTRY(type)						\
+struct {								\
+	struct type *stqe_next;	/* next element */			\
+}
+
+/*
+ * Singly-linked Tail queue access methods.
+ */
+#define	STAILQ_FIRST(head)	((head)->stqh_first)
+#define	STAILQ_END(head)	NULL
+#define	STAILQ_EMPTY(head)	(STAILQ_FIRST(head) == STAILQ_END(head))
+#define	STAILQ_NEXT(elm, field)	((elm)->field.stqe_next)
+
+#define STAILQ_FOREACH(var, head, field)				\
+	for ((var) = STAILQ_FIRST(head);				\
+	    (var) != STAILQ_END(head);					\
+	    (var) = STAILQ_NEXT(var, field))
+
+#define	STAILQ_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = STAILQ_FIRST(head);				\
+	    (var) && ((tvar) = STAILQ_NEXT(var, field), 1);		\
+	    (var) = (tvar))
+
+/*
+ * Singly-linked Tail queue functions.
+ */
+#define	STAILQ_INIT(head) do {						\
+	STAILQ_FIRST((head)) = NULL;					\
+	(head)->stqh_last = &STAILQ_FIRST((head));			\
+} while (0)
+
+#define	STAILQ_INSERT_HEAD(head, elm, field) do {			\
+	if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL)	\
+		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
+	STAILQ_FIRST((head)) = (elm);					\
+} while (0)
+
+#define	STAILQ_INSERT_TAIL(head, elm, field) do {			\
+	STAILQ_NEXT((elm), field) = NULL;				\
+	*(head)->stqh_last = (elm);					\
+	(head)->stqh_last = &STAILQ_NEXT((elm), field);			\
+} while (0)
+
+#define	STAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
+	if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((elm), field)) == NULL)\
+		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
+	STAILQ_NEXT((elm), field) = (elm);				\
+} while (0)
+
+#define STAILQ_REMOVE_HEAD(head, field) do {                            \
+	if ((STAILQ_FIRST((head)) =					\
+	    STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)		\
+		(head)->stqh_last = &STAILQ_FIRST((head));		\
+} while (0)
+
+#define STAILQ_REMOVE_AFTER(head, elm, field) do {                      \
+	if ((STAILQ_NEXT(elm, field) =					\
+	    STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL)	\
+		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
+} while (0)
+
+#define	STAILQ_REMOVE(head, elm, type, field) do {			\
+	if (STAILQ_FIRST((head)) == (elm)) {				\
+		STAILQ_REMOVE_HEAD((head), field);			\
+	} else {							\
+		struct type *curelm = (head)->stqh_first;		\
+		while (STAILQ_NEXT(curelm, field) != (elm))		\
+			curelm = STAILQ_NEXT(curelm, field);		\
+		STAILQ_REMOVE_AFTER(head, curelm, field);		\
+	}								\
+} while (0)
+
+#define	STAILQ_CONCAT(head1, head2) do {				\
+	if (!STAILQ_EMPTY((head2))) {					\
+		*(head1)->stqh_last = (head2)->stqh_first;		\
+		(head1)->stqh_last = (head2)->stqh_last;		\
+		STAILQ_INIT((head2));					\
+	}								\
+} while (0)
+
+#define	STAILQ_LAST(head, type, field)					\
+	(STAILQ_EMPTY((head)) ?	NULL :					\
+	        ((struct type *)(void *)				\
+		((char *)((head)->stqh_last) - offsetof(struct type, field))))
+
+#endif	/* !_SYS_QUEUE_H_ */
--- a/include/sys/tree.h
+++ b/include/sys/tree.h
@@ -1,8 +1,5 @@
-/*	$NetBSD: tree.h,v 1.8 2004/03/28 19:38:30 provos Exp $	*/
-/*	$OpenBSD: tree.h,v 1.7 2002/10/17 21:51:54 art Exp $	*/
-/* $FreeBSD: stable/10/sys/sys/tree.h 189204 2009-03-01 04:57:23Z bms $ */
-
-/*-
+/*	$OpenBSD: tree.h,v 1.30 2020/10/10 18:03:41 otto Exp $	*/
+/*
 * Copyright 2002 Niels Provos <provos@citi.umich.edu>
 * All rights reserved.
 *
@@ -30,9 +27,7 @@
 #ifndef	_SYS_TREE_H_
 #define	_SYS_TREE_H_

-#if HAVE_SYS_CDEFS_H
-#include <sys/cdefs.h>
-#endif
+#include <sys/_null.h>

 /*
 * This file defines data structures for different types of trees:
@@ -71,7 +66,7 @@ struct name {								\

 #define SPLAY_INIT(root) do {						\
 	(root)->sph_root = NULL;					\
-} while (/*CONSTCOND*/ 0)
+} while (0)

 #define SPLAY_ENTRY(type)						\
 struct {								\
@@ -89,32 +84,32 @@ struct {								\
 	SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(tmp, field);	\
 	SPLAY_RIGHT(tmp, field) = (head)->sph_root;			\
 	(head)->sph_root = tmp;						\
-} while (/*CONSTCOND*/ 0)
-	
+} while (0)
+
 #define SPLAY_ROTATE_LEFT(head, tmp, field) do {			\
 	SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(tmp, field);	\
 	SPLAY_LEFT(tmp, field) = (head)->sph_root;			\
 	(head)->sph_root = tmp;						\
-} while (/*CONSTCOND*/ 0)
+} while (0)

 #define SPLAY_LINKLEFT(head, tmp, field) do {				\
 	SPLAY_LEFT(tmp, field) = (head)->sph_root;			\
 	tmp = (head)->sph_root;						\
 	(head)->sph_root = SPLAY_LEFT((head)->sph_root, field);		\
-} while (/*CONSTCOND*/ 0)
+} while (0)

 #define SPLAY_LINKRIGHT(head, tmp, field) do {				\
 	SPLAY_RIGHT(tmp, field) = (head)->sph_root;			\
 	tmp = (head)->sph_root;						\
 	(head)->sph_root = SPLAY_RIGHT((head)->sph_root, field);	\
-} while (/*CONSTCOND*/ 0)
+} while (0)

 #define SPLAY_ASSEMBLE(head, node, left, right, field) do {		\
 	SPLAY_RIGHT(left, field) = SPLAY_LEFT((head)->sph_root, field);	\
 	SPLAY_LEFT(right, field) = SPLAY_RIGHT((head)->sph_root, field);\
 	SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(node, field);	\
 	SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(node, field);	\
-} while (/*CONSTCOND*/ 0)
+} while (0)

 /* Generates prototypes and inline functions */

@@ -125,7 +120,7 @@ struct type *name##_SPLAY_INSERT(struct name *, struct type *);		\
 struct type *name##_SPLAY_REMOVE(struct name *, struct type *);		\
 									\
 /* Finds the node with the same key as elm */				\
-static __inline struct type *						\
+static __unused __inline struct type *					\
 name##_SPLAY_FIND(struct name *head, struct type *elm)			\
 {									\
 	if (SPLAY_EMPTY(head))						\
@@ -136,7 +131,7 @@ name##_SPLAY_FIND(struct name *head, struct type *elm)			\
 	return (NULL);							\
 }									\
 									\
-static __inline struct type *						\
+static __unused __inline struct type *					\
 name##_SPLAY_NEXT(struct name *head, struct type *elm)			\
 {									\
 	name##_SPLAY(head, elm);					\
@@ -150,7 +145,7 @@ name##_SPLAY_NEXT(struct name *head, struct type *elm)			\
 	return (elm);							\
 }									\
 									\
-static __inline struct type *						\
+static __unused __inline struct type *					\
 name##_SPLAY_MIN_MAX(struct name *head, int val)			\
 {									\
 	name##_SPLAY_MINMAX(head, val);					\
@@ -215,7 +210,7 @@ name##_SPLAY(struct name *head, struct type *elm)			\
 	SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = NULL;\
 	__left = __right = &__node;					\
 \
-	while ((__comp = (cmp)(elm, (head)->sph_root)) != 0) {		\
+	while ((__comp = (cmp)(elm, (head)->sph_root))) {		\
 		if (__comp < 0) {					\
 			__tmp = SPLAY_LEFT((head)->sph_root, field);	\
 			if (__tmp == NULL)				\
@@ -305,7 +300,7 @@ struct name {								\

 #define RB_INIT(root) do {						\
 	(root)->rbh_root = NULL;					\
-} while (/*CONSTCOND*/ 0)
+} while (0)

 #define RB_BLACK	0
 #define RB_RED		1
@@ -328,12 +323,12 @@ struct {								\
 	RB_PARENT(elm, field) = parent;					\
 	RB_LEFT(elm, field) = RB_RIGHT(elm, field) = NULL;		\
 	RB_COLOR(elm, field) = RB_RED;					\
-} while (/*CONSTCOND*/ 0)
+} while (0)

 #define RB_SET_BLACKRED(black, red, field) do {				\
 	RB_COLOR(black, field) = RB_BLACK;				\
 	RB_COLOR(red, field) = RB_RED;					\
-} while (/*CONSTCOND*/ 0)
+} while (0)

 #ifndef RB_AUGMENT
 #define RB_AUGMENT(x)	do {} while (0)
@@ -341,11 +336,11 @@ struct {								\

 #define RB_ROTATE_LEFT(head, elm, tmp, field) do {			\
 	(tmp) = RB_RIGHT(elm, field);					\
-	if ((RB_RIGHT(elm, field) = RB_LEFT(tmp, field)) != NULL) {	\
+	if ((RB_RIGHT(elm, field) = RB_LEFT(tmp, field))) {		\
 		RB_PARENT(RB_LEFT(tmp, field), field) = (elm);		\
 	}								\
 	RB_AUGMENT(elm);						\
-	if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field)) != NULL) {	\
+	if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field))) {		\
 		if ((elm) == RB_LEFT(RB_PARENT(elm, field), field))	\
 			RB_LEFT(RB_PARENT(elm, field), field) = (tmp);	\
 		else							\
@@ -357,15 +352,15 @@ struct {								\
 	RB_AUGMENT(tmp);						\
 	if ((RB_PARENT(tmp, field)))					\
 		RB_AUGMENT(RB_PARENT(tmp, field));			\
-} while (/*CONSTCOND*/ 0)
+} while (0)

 #define RB_ROTATE_RIGHT(head, elm, tmp, field) do {			\
 	(tmp) = RB_LEFT(elm, field);					\
-	if ((RB_LEFT(elm, field) = RB_RIGHT(tmp, field)) != NULL) {	\
+	if ((RB_LEFT(elm, field) = RB_RIGHT(tmp, field))) {		\
 		RB_PARENT(RB_RIGHT(tmp, field), field) = (elm);		\
 	}								\
 	RB_AUGMENT(elm);						\
-	if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field)) != NULL) {	\
+	if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field))) {		\
 		if ((elm) == RB_LEFT(RB_PARENT(elm, field), field))	\
 			RB_LEFT(RB_PARENT(elm, field), field) = (tmp);	\
 		else							\
@@ -377,13 +372,13 @@ struct {								\
 	RB_AUGMENT(tmp);						\
 	if ((RB_PARENT(tmp, field)))					\
 		RB_AUGMENT(RB_PARENT(tmp, field));			\
-} while (/*CONSTCOND*/ 0)
+} while (0)

 /* Generates prototypes and inline functions */
 #define	RB_PROTOTYPE(name, type, field, cmp)				\
 	RB_PROTOTYPE_INTERNAL(name, type, field, cmp,)
 #define	RB_PROTOTYPE_STATIC(name, type, field, cmp)			\
-	RB_PROTOTYPE_INTERNAL(name, type, field, cmp, __unused static)
+	RB_PROTOTYPE_INTERNAL(name, type, field, cmp, __attribute__((__unused__)) static)
 #define RB_PROTOTYPE_INTERNAL(name, type, field, cmp, attr)		\
 attr void name##_RB_INSERT_COLOR(struct name *, struct type *);		\
 attr void name##_RB_REMOVE_COLOR(struct name *, struct type *, struct type *);\
@@ -402,13 +397,13 @@ attr struct type *name##_RB_MINMAX(struct name *, int);			\
 #define	RB_GENERATE(name, type, field, cmp)				\
 	RB_GENERATE_INTERNAL(name, type, field, cmp,)
 #define	RB_GENERATE_STATIC(name, type, field, cmp)			\
-	RB_GENERATE_INTERNAL(name, type, field, cmp, __unused static)
+	RB_GENERATE_INTERNAL(name, type, field, cmp, __attribute__((__unused__)) static)
 #define RB_GENERATE_INTERNAL(name, type, field, cmp, attr)		\
 attr void								\
 name##_RB_INSERT_COLOR(struct name *head, struct type *elm)		\
 {									\
 	struct type *parent, *gparent, *tmp;				\
-	while ((parent = RB_PARENT(elm, field)) != NULL &&		\
+	while ((parent = RB_PARENT(elm, field)) &&			\
 	    RB_COLOR(parent, field) == RB_RED) {			\
 		gparent = RB_PARENT(parent, field);			\
 		if (parent == RB_LEFT(gparent, field)) {		\
@@ -472,8 +467,7 @@ name##_RB_REMOVE_COLOR(struct name *head, struct type *parent, struct type *elm)
 				if (RB_RIGHT(tmp, field) == NULL ||	\
 				    RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK) {\
 					struct type *oleft;		\
-					if ((oleft = RB_LEFT(tmp, field)) \
-					    != NULL)			\
+					if ((oleft = RB_LEFT(tmp, field)))\
 						RB_COLOR(oleft, field) = RB_BLACK;\
 					RB_COLOR(tmp, field) = RB_RED;	\
 					RB_ROTATE_RIGHT(head, tmp, oleft, field);\
@@ -505,8 +499,7 @@ name##_RB_REMOVE_COLOR(struct name *head, struct type *parent, struct type *elm)
 				if (RB_LEFT(tmp, field) == NULL ||	\
 				    RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) {\
 					struct type *oright;		\
-					if ((oright = RB_RIGHT(tmp, field)) \
-					    != NULL)			\
+					if ((oright = RB_RIGHT(tmp, field)))\
 						RB_COLOR(oright, field) = RB_BLACK;\
 					RB_COLOR(tmp, field) = RB_RED;	\
 					RB_ROTATE_LEFT(head, tmp, oright, field);\
@@ -538,7 +531,7 @@ name##_RB_REMOVE(struct name *head, struct type *elm)			\
 	else {								\
 		struct type *left;					\
 		elm = RB_RIGHT(elm, field);				\
-		while ((left = RB_LEFT(elm, field)) != NULL)		\
+		while ((left = RB_LEFT(elm, field)))			\
 			elm = left;					\
 		child = RB_RIGHT(elm, field);				\
 		parent = RB_PARENT(elm, field);				\
@@ -571,7 +564,7 @@ name##_RB_REMOVE(struct name *head, struct type *elm)			\
 			left = parent;					\
 			do {						\
 				RB_AUGMENT(left);			\
-			} while ((left = RB_PARENT(left, field)) != NULL); \
+			} while ((left = RB_PARENT(left, field)));	\
 		}							\
 		goto color;						\
 	}								\
@@ -739,14 +732,9 @@ name##_RB_MINMAX(struct name *head, int val)				\
 	     (x) != NULL;						\
 	     (x) = name##_RB_NEXT(x))

-#define RB_FOREACH_FROM(x, name, y)					\
-	for ((x) = (y);							\
-	    ((x) != NULL) && ((y) = name##_RB_NEXT(x), (x) != NULL);	\
-	     (x) = (y))
-
 #define RB_FOREACH_SAFE(x, name, head, y)				\
 	for ((x) = RB_MIN(name, head);					\
-	    ((x) != NULL) && ((y) = name##_RB_NEXT(x), (x) != NULL);	\
+	    ((x) != NULL) && ((y) = name##_RB_NEXT(x), 1);		\
 	     (x) = (y))

 #define RB_FOREACH_REVERSE(x, name, head)				\
@@ -754,14 +742,265 @@ name##_RB_MINMAX(struct name *head, int val)				\
 	     (x) != NULL;						\
 	     (x) = name##_RB_PREV(x))

-#define RB_FOREACH_REVERSE_FROM(x, name, y)				\
-	for ((x) = (y);							\
-	    ((x) != NULL) && ((y) = name##_RB_PREV(x), (x) != NULL);	\
-	     (x) = (y))
-
 #define RB_FOREACH_REVERSE_SAFE(x, name, head, y)			\
 	for ((x) = RB_MAX(name, head);					\
-	    ((x) != NULL) && ((y) = name##_RB_PREV(x), (x) != NULL);	\
+	    ((x) != NULL) && ((y) = name##_RB_PREV(x), 1);		\
 	     (x) = (y))

+
+/*
+ * Copyright (c) 2016 David Gwynne <dlg@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+struct rb_type {
+	int		(*t_compare)(const void *, const void *);
+	void		(*t_augment)(void *);
+	unsigned int	  t_offset;	/* offset of rb_entry in type */
+};
+
+struct rb_tree {
+	struct rb_entry	*rbt_root;
+};
+
+struct rb_entry {
+	struct rb_entry	 *rbt_parent;
+	struct rb_entry	 *rbt_left;
+	struct rb_entry	 *rbt_right;
+	unsigned int	  rbt_color;
+};
+
+#define RBT_HEAD(_name, _type)						\
+struct _name {								\
+	struct rb_tree rbh_root;					\
+}
+
+#define RBT_ENTRY(_type)	struct rb_entry
+
+static inline void
+_rb_init(struct rb_tree *rbt)
+{
+	rbt->rbt_root = NULL;
+}
+
+static inline int
+_rb_empty(struct rb_tree *rbt)
+{
+	return (rbt->rbt_root == NULL);
+}
+
+void	*_rb_insert(const struct rb_type *, struct rb_tree *, void *);
+void	*_rb_remove(const struct rb_type *, struct rb_tree *, void *);
+void	*_rb_find(const struct rb_type *, struct rb_tree *, const void *);
+void	*_rb_nfind(const struct rb_type *, struct rb_tree *, const void *);
+void	*_rb_root(const struct rb_type *, struct rb_tree *);
+void	*_rb_min(const struct rb_type *, struct rb_tree *);
+void	*_rb_max(const struct rb_type *, struct rb_tree *);
+void	*_rb_next(const struct rb_type *, void *);
+void	*_rb_prev(const struct rb_type *, void *);
+void	*_rb_left(const struct rb_type *, void *);
+void	*_rb_right(const struct rb_type *, void *);
+void	*_rb_parent(const struct rb_type *, void *);
+void	 _rb_set_left(const struct rb_type *, void *, void *);
+void	 _rb_set_right(const struct rb_type *, void *, void *);
+void	 _rb_set_parent(const struct rb_type *, void *, void *);
+void	 _rb_poison(const struct rb_type *, void *, unsigned long);
+int	 _rb_check(const struct rb_type *, void *, unsigned long);
+
+#define RBT_INITIALIZER(_head)	{ { NULL } }
+
+#define RBT_PROTOTYPE(_name, _type, _field, _cmp)			\
+extern const struct rb_type *const _name##_RBT_TYPE;			\
+									\
+__unused static inline void						\
+_name##_RBT_INIT(struct _name *head)					\
+{									\
+	_rb_init(&head->rbh_root);					\
+}									\
+									\
+__unused static inline struct _type *					\
+_name##_RBT_INSERT(struct _name *head, struct _type *elm)		\
+{									\
+	return _rb_insert(_name##_RBT_TYPE, &head->rbh_root, elm);	\
+}									\
+									\
+__unused static inline struct _type *					\
+_name##_RBT_REMOVE(struct _name *head, struct _type *elm)		\
+{									\
+	return _rb_remove(_name##_RBT_TYPE, &head->rbh_root, elm);	\
+}									\
+									\
+__unused static inline struct _type *					\
+_name##_RBT_FIND(struct _name *head, const struct _type *key)		\
+{									\
+	return _rb_find(_name##_RBT_TYPE, &head->rbh_root, key);	\
+}									\
+									\
+__unused static inline struct _type *					\
+_name##_RBT_NFIND(struct _name *head, const struct _type *key)		\
+{									\
+	return _rb_nfind(_name##_RBT_TYPE, &head->rbh_root, key);	\
+}									\
+									\
+__unused static inline struct _type *					\
+_name##_RBT_ROOT(struct _name *head)					\
+{									\
+	return _rb_root(_name##_RBT_TYPE, &head->rbh_root);		\
+}									\
+									\
+__unused static inline int						\
+_name##_RBT_EMPTY(struct _name *head)					\
+{									\
+	return _rb_empty(&head->rbh_root);				\
+}									\
+									\
+__unused static inline struct _type *					\
+_name##_RBT_MIN(struct _name *head)					\
+{									\
+	return _rb_min(_name##_RBT_TYPE, &head->rbh_root);		\
+}									\
+									\
+__unused static inline struct _type *					\
+_name##_RBT_MAX(struct _name *head)					\
+{									\
+	return _rb_max(_name##_RBT_TYPE, &head->rbh_root);		\
+}									\
+									\
+__unused static inline struct _type *					\
+_name##_RBT_NEXT(struct _type *elm)					\
+{									\
+	return _rb_next(_name##_RBT_TYPE, elm);				\
+}									\
+									\
+__unused static inline struct _type *					\
+_name##_RBT_PREV(struct _type *elm)					\
+{									\
+	return _rb_prev(_name##_RBT_TYPE, elm);				\
+}									\
+									\
+__unused static inline struct _type *					\
+_name##_RBT_LEFT(struct _type *elm)					\
+{									\
+	return _rb_left(_name##_RBT_TYPE, elm);				\
+}									\
+									\
+__unused static inline struct _type *					\
+_name##_RBT_RIGHT(struct _type *elm)					\
+{									\
+	return _rb_right(_name##_RBT_TYPE, elm);			\
+}									\
+									\
+__unused static inline struct _type *					\
+_name##_RBT_PARENT(struct _type *elm)					\
+{									\
+	return _rb_parent(_name##_RBT_TYPE, elm);			\
+}									\
+									\
+__unused static inline void						\
+_name##_RBT_SET_LEFT(struct _type *elm, struct _type *left)		\
+{									\
+	_rb_set_left(_name##_RBT_TYPE, elm, left);			\
+}									\
+									\
+__unused static inline void						\
+_name##_RBT_SET_RIGHT(struct _type *elm, struct _type *right)		\
+{									\
+	_rb_set_right(_name##_RBT_TYPE, elm, right);			\
+}									\
+									\
+__unused static inline void						\
+_name##_RBT_SET_PARENT(struct _type *elm, struct _type *parent)		\
+{									\
+	_rb_set_parent(_name##_RBT_TYPE, elm, parent);			\
+}									\
+									\
+__unused static inline void						\
+_name##_RBT_POISON(struct _type *elm, unsigned long poison)		\
+{									\
+	_rb_poison(_name##_RBT_TYPE, elm, poison);			\
+}									\
+									\
+__unused static inline int						\
+_name##_RBT_CHECK(struct _type *elm, unsigned long poison)		\
+{									\
+	return _rb_check(_name##_RBT_TYPE, elm, poison);		\
+}
+
+#define RBT_GENERATE_INTERNAL(_name, _type, _field, _cmp, _aug)		\
+static int								\
+_name##_RBT_COMPARE(const void *lptr, const void *rptr)			\
+{									\
+	const struct _type *l = lptr, *r = rptr;			\
+	return _cmp(l, r);						\
+}									\
+static const struct rb_type _name##_RBT_INFO = {			\
+	_name##_RBT_COMPARE,						\
+	_aug,								\
+	offsetof(struct _type, _field),					\
+};									\
+const struct rb_type *const _name##_RBT_TYPE = &_name##_RBT_INFO
+
+#define RBT_GENERATE_AUGMENT(_name, _type, _field, _cmp, _aug)		\
+static void								\
+_name##_RBT_AUGMENT(void *ptr)						\
+{									\
+	struct _type *p = ptr;						\
+	return _aug(p);							\
+}									\
+RBT_GENERATE_INTERNAL(_name, _type, _field, _cmp, _name##_RBT_AUGMENT)
+
+#define RBT_GENERATE(_name, _type, _field, _cmp)			\
+    RBT_GENERATE_INTERNAL(_name, _type, _field, _cmp, NULL)
+
+#define RBT_INIT(_name, _head)		_name##_RBT_INIT(_head)
+#define RBT_INSERT(_name, _head, _elm)	_name##_RBT_INSERT(_head, _elm)
+#define RBT_REMOVE(_name, _head, _elm)	_name##_RBT_REMOVE(_head, _elm)
+#define RBT_FIND(_name, _head, _key)	_name##_RBT_FIND(_head, _key)
+#define RBT_NFIND(_name, _head, _key)	_name##_RBT_NFIND(_head, _key)
+#define RBT_ROOT(_name, _head)		_name##_RBT_ROOT(_head)
+#define RBT_EMPTY(_name, _head)		_name##_RBT_EMPTY(_head)
+#define RBT_MIN(_name, _head)		_name##_RBT_MIN(_head)
+#define RBT_MAX(_name, _head)		_name##_RBT_MAX(_head)
+#define RBT_NEXT(_name, _elm)		_name##_RBT_NEXT(_elm)
+#define RBT_PREV(_name, _elm)		_name##_RBT_PREV(_elm)
+#define RBT_LEFT(_name, _elm)		_name##_RBT_LEFT(_elm)
+#define RBT_RIGHT(_name, _elm)		_name##_RBT_RIGHT(_elm)
+#define RBT_PARENT(_name, _elm)		_name##_RBT_PARENT(_elm)
+#define RBT_SET_LEFT(_name, _elm, _l)	_name##_RBT_SET_LEFT(_elm, _l)
+#define RBT_SET_RIGHT(_name, _elm, _r)	_name##_RBT_SET_RIGHT(_elm, _r)
+#define RBT_SET_PARENT(_name, _elm, _p)	_name##_RBT_SET_PARENT(_elm, _p)
+#define RBT_POISON(_name, _elm, _p)	_name##_RBT_POISON(_elm, _p)
+#define RBT_CHECK(_name, _elm, _p)	_name##_RBT_CHECK(_elm, _p)
+
+#define RBT_FOREACH(_e, _name, _head)					\
+	for ((_e) = RBT_MIN(_name, (_head));				\
+	     (_e) != NULL;						\
+	     (_e) = RBT_NEXT(_name, (_e)))
+
+#define RBT_FOREACH_SAFE(_e, _name, _head, _n)				\
+	for ((_e) = RBT_MIN(_name, (_head));				\
+	     (_e) != NULL && ((_n) = RBT_NEXT(_name, (_e)), 1);	\
+	     (_e) = (_n))
+
+#define RBT_FOREACH_REVERSE(_e, _name, _head)				\
+	for ((_e) = RBT_MAX(_name, (_head));				\
+	     (_e) != NULL;						\
+	     (_e) = RBT_PREV(_name, (_e)))
+
+#define RBT_FOREACH_REVERSE_SAFE(_e, _name, _head, _n)			\
+	for ((_e) = RBT_MAX(_name, (_head));				\
+	     (_e) != NULL && ((_n) = RBT_PREV(_name, (_e)), 1);	\
+	     (_e) = (_n))
+
 #endif	/* _SYS_TREE_H_ */
--- a/include/sys/types.h
+++ b/include/sys/types.h
@@ -0,0 +1,25 @@
+/*
+ * Public domain
+ * sys/types.h compatibility shim
+ */
+
+#include_next <sys/types.h>
+
+#ifndef LIBCOMPAT_SYS_TYPES_H
+#define LIBCOMPAT_SYS_TYPES_H
+
+#include <stdint.h>
+
+#ifdef __MINGW32__
+#include <_bsd_types.h>
+#endif
+
+#if !defined(HAVE_ATTRIBUTE__DEAD) && !defined(__dead)
+#define __dead      __attribute__((__noreturn__))
+#endif
+
+#if !defined(HAVE_ATTRIBUTE__BOUNDED__) && !defined(__bounded__)
+# define __bounded__(x, y, z)
+#endif
+
+#endif
--- a/bgpq4.c
+++ b/bgpq4.c
@@ -1,3 +1,30 @@
+/*
+ * Copyright (c) 2019-2021 Job Snijders <job@sobornost.net>
+ * Copyright (c) 2007-2019 Alexandre Snarskii <snar@snar.spb.ru>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
 #if HAVE_CONFIG_H
 #include <config.h>
 #endif
@@ -14,16 +41,15 @@
 #include <strings.h>
 #include <unistd.h>

-#include "bgpq4.h"
+#include "extern.h"
 #include "sx_report.h"
-#include "expander_freeall.h"

 extern int debug_expander;
 extern int debug_aggregation;
 extern int pipelining;
 extern int expand_special_asn;

-int
+static int
 usage(int ecode)
 {
 	printf("\nUsage: bgpq4 [-h host[:port]] [-S sources] [-E|G <num>"
@@ -85,8 +111,8 @@ usage(int ecode)
 	exit(ecode);
 }

-void
-version()
+static void
+version(void)
 {
 	printf(PACKAGE_NAME " - a versatile utility to generate BGP filters\n"
 	    "version: " PACKAGE_VERSION "\n"
@@ -95,16 +121,16 @@ version()
 	exit(0);
 }

-void
-exclusive()
+static void
+exclusive(void)
 {
-	fprintf(stderr,"-E, -f <asnum>, -G <asnum>, and -t are mutually "
-	    "exclusive\n");
+	fprintf(stderr,"-E, -F, -K , -f <asnum>, -G <asnum>, and -t are mutually"
+	    " exclusive\n");
 	exit(1);
 }

-void
-vendor_exclusive()
+static void
+vendor_exclusive(void)
 {
 	fprintf(stderr, "-b (BIRD), -B (OpenBGPD), -F (formatted), -J (Junos),"
 	    " -j (JSON), -N (Nokia SR OS Classic), -n (Nokia SR OS MD-CLI),"
@@ -113,36 +139,37 @@ vendor_exclusive()
 	exit(1);
 }

-int
-parseasnumber(struct bgpq_expander* expander, char* optarg)
+static int
+parseasnumber(struct bgpq_expander *expander, char *asnstr)
 {
-	char* eon=NULL;
-	expander->asnumber=strtoul(optarg,&eon, 10);
+	char	*eon = NULL;
+
+	expander->asnumber = strtoul(asnstr, &eon, 10);
 	if (expander->asnumber < 1 || expander->asnumber > (65535ul * 65535)) {
-		sx_report(SX_FATAL,"Invalid AS number: %s\n", optarg);
+		sx_report(SX_FATAL, "Invalid AS number: %s\n", asnstr);
 		exit(1);
 	}
-	if(eon && *eon == '.') {
+	if (eon && *eon == '.') {
 		/* -f 3.3, for example */
-		uint32_t loas = strtoul(eon+1, &eon, 10);
-		if(expander->asnumber > 65535) {
+		uint32_t loas = strtoul(eon + 1, &eon, 10);
+		if (expander->asnumber > 65535) {
 			/* should prevent incorrect numbers like 65537.1 */
-			sx_report(SX_FATAL,"Invalid AS number: %s\n", optarg);
+			sx_report(SX_FATAL,"Invalid AS number: %s\n", asnstr);
 			exit(1);
 		}
-		if(loas < 1 || loas > 65535) {
-			sx_report(SX_FATAL,"Invalid AS number: %s\n", optarg);
+		if (loas < 1 || loas > 65535) {
+			sx_report(SX_FATAL,"Invalid AS number: %s\n", asnstr);
 			exit(1);
 		}
 		if (eon && *eon) {
 			sx_report(SX_FATAL,"Invalid symbol in AS number: "
-			    "%c (%s)\n", *eon, optarg);
+			    "%c (%s)\n", *eon, asnstr);
 			exit(1);
 		}
 		expander->asnumber=(expander->asnumber << 16) + loas;
 	} else if (eon && *eon) {
 		sx_report(SX_FATAL,"Invalid symbol in AS number: %c (%s)\n",
-			*eon, optarg);
+			*eon, asnstr);
 		exit(1);
 	}
 	return 0;
@@ -169,7 +196,8 @@ main(int argc, char* argv[])
 	if (getenv("IRRD_SOURCES"))
 		expander.sources=getenv("IRRD_SOURCES");

-	while ((c = getopt(argc,argv,"346a:AbBdDEeF:S:jJKf:l:L:m:M:NnW:pr:R:G:tTh:UwXsvz"))
+	while ((c = getopt(argc, argv,
+	    "346a:AbBdDEeF:S:jJKf:l:L:m:M:NnW:pr:R:G:tTh:UwXsvz"))
 	    !=EOF) {
 	switch (c) {
        case '3':
@@ -311,44 +339,44 @@ main(int argc, char* argv[])
 			break;
 		case 'M':
 			{
-			char* c, *d;
+			char *mc, *md;
 			expander.match = strdup(optarg);
-			c = d = expander.match;
-			while (*c) {
-				if (*c == '\\') {
-					if (*(c+1) == '\n') {
-						*d = '\n';
-						d++;
-						c += 2;
-					} else if (*(c + 1) == 'r') {
-						*d = '\r';
-						d++;
-						c += 2;
-					} else if (*(c + 1) == 't') {
-						*d = '\t';
-						d++;
-						c += 2;
-					} else if (*(c + 1) == '\\') {
-						*d = '\\';
-						d++;
-						c += 2;
+			mc = md = expander.match;
+			while (*mc) {
+				if (*mc == '\\') {
+					if (*(mc + 1) == '\n') {
+						*md = '\n';
+						md++;
+						mc += 2;
+					} else if (*(mc + 1) == 'r') {
+						*md = '\r';
+						md++;
+						mc += 2;
+					} else if (*(mc + 1) == 't') {
+						*md = '\t';
+						md++;
+						mc += 2;
+					} else if (*(mc + 1) == '\\') {
+						*md = '\\';
+						md++;
+						mc += 2;
 					} else {
 						sx_report(SX_FATAL, "Unsupported"
 						    " escape \%c (0x%2.2x) in "
 						    "'%s'\n",
-						    isprint(*c) ? *c : 20,
-						    *c, optarg);
+						    isprint(*mc) ? *mc : 20,
+						    *mc, optarg);
 						exit(1);
 					}
 				} else {
-					if (c != d) {
-						*d = *c;
+					if (mc != md) {
+						*md = *mc;
 					}
-					d++;
-					c++;
+					md++;
+					mc++;
 				}
 			}
-			*d = 0;
+			*md = 0;
 			}
 			break;
 		case 'N':
@@ -414,99 +442,121 @@ main(int argc, char* argv[])
 	argv += optind;

 	if (!widthSet) {
-		if (expander.generation==T_ASPATH) {
-			if (expander.vendor == V_CISCO) {
+		if (expander.generation == T_ASPATH) {
+			int vendor = expander.vendor;
+			switch (vendor) {
+			case V_ARISTA:
+			case V_CISCO:
+			case V_MIKROTIK:
 				expander.aswidth = 4;
-			} else if (expander.vendor == V_CISCO_XR) {
+				break;
+			case V_CISCO_XR:
 				expander.aswidth = 6;
-			} else if (expander.vendor == V_JUNIPER) {
+				break;
+			case V_JUNIPER:
+			case V_NOKIA:
+			case V_NOKIA_MD:
 				expander.aswidth = 8;
-			} else if (expander.vendor == V_MIKROTIK) {
-				expander.aswidth = 4;
-			} else if (expander.vendor == V_BIRD) {
+				break;
+			case V_BIRD:
 				expander.aswidth = 10;
-			} else if (expander.vendor == V_NOKIA ||
-			    expander.vendor == V_NOKIA_MD) {
-				expander.aswidth = 8;
-			} else if (expander.vendor == V_ARISTA) {
-				expander.aswidth = 4;
+				break;
 			}
 		} else if (expander.generation == T_OASPATH) {
-			if (expander.vendor == V_CISCO) {
+			int vendor = expander.vendor;
+			switch (vendor) {
+			case V_ARISTA:
+			case V_CISCO:
 				expander.aswidth = 5;
-			} else if (expander.vendor == V_CISCO_XR) {
+				break;
+			case V_CISCO_XR:
 				expander.aswidth = 7;
-			} else if (expander.vendor==V_JUNIPER) {
+				break;
+			case V_JUNIPER:
+			case V_NOKIA:
+			case V_NOKIA_MD:
 				expander.aswidth = 8;
-			} else if (expander.vendor == V_NOKIA ||
-			    expander.vendor == V_NOKIA_MD) {
-				expander.aswidth = 8;
-			} else if (expander.vendor == V_ARISTA) {
-				expander.aswidth = 5;
+				break;
 			}
 		}
 	}

-	if (!expander.generation) {
+	if (!expander.generation)
 		expander.generation = T_PREFIXLIST;
-	}

-	if (expander.vendor == V_CISCO_XR && expander.generation != T_PREFIXLIST &&
-	    expander.generation != T_ASPATH && expander.generation != T_OASPATH) {
+	if (expander.vendor == V_CISCO_XR
+	    && expander.generation != T_PREFIXLIST
+	    && expander.generation != T_ASPATH
+	    && expander.generation != T_OASPATH) {
 		sx_report(SX_FATAL, "Sorry, only prefix-sets and as-paths "
 		    "supported for IOS XR\n");
 	}
-	if (expander.vendor == V_BIRD && expander.generation != T_PREFIXLIST &&
-		expander.generation != T_ASPATH && expander.generation != T_ASSET) {
+	if (expander.vendor == V_BIRD
+	    && expander.generation != T_PREFIXLIST
+	    && expander.generation != T_ASPATH
+	    && expander.generation != T_ASSET) {
 		sx_report(SX_FATAL, "Sorry, only prefix-lists and as-paths/as-sets "
 		    "supported for BIRD output\n");
 	}
-	if (expander.vendor == V_JSON && expander.generation != T_PREFIXLIST &&
-		expander.generation != T_ASPATH && expander.generation != T_ASSET) {
+	if (expander.vendor == V_JSON
+	    && expander.generation != T_PREFIXLIST
+	    && expander.generation != T_ASPATH
+	    && expander.generation != T_ASSET) {
 		sx_report(SX_FATAL, "Sorry, only prefix-lists and as-paths/as-sets "
 		    "supported for JSON output\n");
 	}

-	if (expander.vendor == V_FORMAT && expander.generation != T_PREFIXLIST)
+	if (expander.vendor == V_FORMAT
+	    && expander.generation != T_PREFIXLIST)
 		sx_report(SX_FATAL, "Sorry, only prefix-lists supported in formatted "
 		    "output\n");

-	if (expander.vendor == V_HUAWEI && expander.generation != T_ASPATH &&
-	    expander.generation != T_OASPATH && expander.generation != T_PREFIXLIST)
+	if (expander.vendor == V_HUAWEI
+	    && expander.generation != T_ASPATH
+	    && expander.generation != T_OASPATH
+	    && expander.generation != T_PREFIXLIST)
 		sx_report(SX_FATAL, "Sorry, only as-paths and prefix-lists supported "
 		    "for Huawei output\n");

-	if (expander.generation == T_ROUTE_FILTER_LIST && expander.vendor != V_JUNIPER)
+	if (expander.generation == T_ROUTE_FILTER_LIST
+	    && expander.vendor != V_JUNIPER)
 		sx_report(SX_FATAL, "Route-filter-lists (-z) supported for Juniper (-J)"
 		    " output only\n");

-	if (expander.generation == T_ASSET && expander.vendor != V_JSON &&
-	    expander.vendor != V_OPENBGPD && expander.vendor != V_BIRD)
+	if (expander.generation == T_ASSET
+	    && expander.vendor != V_JSON
+	    && expander.vendor != V_OPENBGPD
+	    && expander.vendor != V_BIRD)
 		sx_report(SX_FATAL, "As-Sets (-t) supported for JSON (-j), OpenBGPD "
 		    "(-B) and BIRD (-b) output only\n");

-	if (aggregate && expander.vendor == V_JUNIPER && expander.generation == T_PREFIXLIST) {
+	if (aggregate
+	    && expander.vendor == V_JUNIPER
+	    && expander.generation == T_PREFIXLIST) {
 		sx_report(SX_FATAL, "Sorry, aggregation (-A) does not work in"
 		    " Juniper prefix-lists\nYou can try route-filters (-E) "
 		    "or route-filter-lists (-z) instead of prefix-lists\n.");
 		exit(1);
 	}

-	if (aggregate && (expander.vendor == V_NOKIA_MD || expander.vendor == V_NOKIA)
+	if (aggregate
+	    && (expander.vendor == V_NOKIA_MD || expander.vendor == V_NOKIA)
 	    && expander.generation != T_PREFIXLIST) {
 		sx_report(SX_FATAL, "Sorry, aggregation (-A) is not supported with "
 		    "ip-prefix-lists (-E) on Nokia.\n");
 		exit(1);
 	}

-	if (refine && (expander.vendor == V_NOKIA_MD || expander.vendor == V_NOKIA)
+	if (refine
+	    && (expander.vendor == V_NOKIA_MD || expander.vendor == V_NOKIA)
 	    && expander.generation != T_PREFIXLIST) {
 		sx_report(SX_FATAL, "Sorry, more-specifics (-R) is not supported with "
 		    "ip-prefix-lists (-E) on Nokia.\n");
 		exit(1);
 	}

-	if (refineLow && (expander.vendor == V_NOKIA_MD || expander.vendor == V_NOKIA)
+	if (refineLow
+	     && (expander.vendor == V_NOKIA_MD || expander.vendor == V_NOKIA)
 	     && expander.generation != T_PREFIXLIST) {
 		sx_report(SX_FATAL, "Sorry, more-specifics (-r) is not supported with "
 		    "ip-prefix-lists (-E) on Nokia.\n");
@@ -519,7 +569,8 @@ main(int argc, char* argv[])
 		exit(1);
 	}

-	if (expander.sequence && (expander.vendor != V_CISCO && expander.vendor != V_ARISTA)) {
+	if (expander.sequence
+	    && (expander.vendor != V_CISCO && expander.vendor != V_ARISTA)) {
 		sx_report(SX_FATAL, "Sorry, prefix-lists sequencing (-s) supported"
 		    " only for IOS and EOS\n");
 		exit(1);
@@ -538,10 +589,9 @@ main(int argc, char* argv[])
 			refine = 128;
 	}

-	if (refineLow && refineLow > refine) {
+	if (refineLow && refineLow > refine)
 		sx_report(SX_FATAL, "Incompatible values for -r %u and -R %u\n",
 		    refineLow, refine);
-	}

 	if (refine || refineLow) {
 		if (expander.family == AF_INET6 && refine > 128) {
@@ -573,13 +623,12 @@ main(int argc, char* argv[])
 		}

 		if (expander.generation < T_PREFIXLIST) {
-			if (refine) {
+			if (refine)
 				sx_report(SX_FATAL, "Sorry, more-specific filter (-R %u) "
 				    "supported only with prefix-list generation\n", refine);
-			} else {
+			else
 				sx_report(SX_FATAL, "Sorry, more-specific filter (-r %u) "
 				    "supported only with prefix-list generation\n", refineLow);
-			}
 		}
 	}

@@ -597,11 +646,10 @@ main(int argc, char* argv[])
 			 */
 			expander.maxlen = maxlen;
 		}
-	} else if (expander.family == AF_INET) {
+	} else if (expander.family == AF_INET)
 		expander.maxlen = 32;
-	} else if (expander.family == AF_INET6) {
+	else if (expander.family == AF_INET6)
 		expander.maxlen = 128;
-	}

 	if (expander.generation == T_EACL && expander.vendor == V_CISCO
 	    && expander.family == AF_INET6) {
@@ -634,32 +682,33 @@ main(int argc, char* argv[])
 		if (!strcmp(argv[0], "EXCEPT")) {
 			exceptmode = 1;
 		} else if (exceptmode) {
-			bgpq_expander_add_stop(&expander,argv[0]);
+			bgpq_expander_add_stop(&expander, argv[0]);
 		} else if (!strncasecmp(argv[0], "AS-", 3)) {
-			bgpq_expander_add_asset(&expander,argv[0]);
+			bgpq_expander_add_asset(&expander, argv[0]);
 		} else if (!strncasecmp(argv[0], "RS-", 3)) {
-			bgpq_expander_add_rset(&expander,argv[0]);
+			bgpq_expander_add_rset(&expander, argv[0]);
 		} else if (!strncasecmp(argv[0], "AS", 2)) {
-			char* c;
-			if ((c = strchr(argv[0], ':'))) {
-				if (!strncasecmp(c + 1, "AS-", 3)) {
+			char *ec;
+			if ((ec = strchr(argv[0], ':'))) {
+				if (!strncasecmp(ec + 1, "AS-", 3)) {
 					bgpq_expander_add_asset(&expander, argv[0]);
-				} else if (!strncasecmp(c + 1, "RS-", 3)) {
+				} else if (!strncasecmp(ec + 1, "RS-", 3)) {
 					bgpq_expander_add_rset(&expander, argv[0]);
 				} else {
 					SX_DEBUG(debug_expander,"Unknown sub-as"
 					    " object %s\n", argv[0]);
 				}
 			} else {
-				bgpq_expander_add_as(&expander,argv[0]);
+				bgpq_expander_add_as(&expander, argv[0]);
 			}
 		} else {
-			char* c = strchr(argv[0], '^');
-			if (!c && !bgpq_expander_add_prefix(&expander, argv[0])) {
+			char *ec = strchr(argv[0], '^');
+			if (!ec && !bgpq_expander_add_prefix(&expander, argv[0])) {
 				sx_report(SX_ERROR, "Unable to add prefix %s "
 				    "(bad prefix or address-family)\n", argv[0]);
 				exit(1);
-			} else if (c && !bgpq_expander_add_prefix_range(&expander, argv[0])){
+			} else if (ec && !bgpq_expander_add_prefix_range(&expander,
+				    argv[0])) {
 				sx_report(SX_ERROR, "Unable to add prefix-range "
 				    "%s (bad range or address-family)\n",
 				    argv[0]);
@@ -687,19 +736,19 @@ main(int argc, char* argv[])
 			sx_report(SX_FATAL,"Unreachable point... call snar\n");
 			exit(1);
 		case T_ASPATH:
-			bgpq4_print_aspath(stdout,&expander);
+			bgpq4_print_aspath(stdout, &expander);
 			break;
 		case T_OASPATH:
-			bgpq4_print_oaspath(stdout,&expander);
+			bgpq4_print_oaspath(stdout, &expander);
 			break;
 		case T_ASSET:
-			bgpq4_print_asset(stdout,&expander);
+			bgpq4_print_asset(stdout, &expander);
 			break;
 		case T_PREFIXLIST:
-			bgpq4_print_prefixlist(stdout,&expander);
+			bgpq4_print_prefixlist(stdout, &expander);
 			break;
 		case T_EACL:
-			bgpq4_print_eacl(stdout,&expander);
+			bgpq4_print_eacl(stdout, &expander);
 			break;
 		case T_ROUTE_FILTER_LIST:
 			bgpq4_print_route_filter_list(stdout, &expander);
--- a/printer.c
+++ b/printer.c
--- a/strlcpy.c
+++ b/strlcpy.c
@@ -1,72 +0,0 @@
-/*	$OpenBSD: strlcpy.c,v 1.4 1999/05/01 18:56:41 millert Exp $	*/
-
-/*
- * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
- * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
- * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
- * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#if HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifndef HAVE_STRLCPY
-
-#include <sys/types.h>
-#include <string.h>
-
-/*
- * Copy src to string dst of size siz.  At most siz-1 characters
- * will be copied.  Always NUL terminates (unless siz == 0).
- * Returns strlen(src); if retval >= siz, truncation occurred.
- */
-size_t
-strlcpy(dst, src, siz)
-	char *dst;
-	const char *src;
-	size_t siz;
-{
-	char *d = dst;
-	const char *s = src;
-	size_t n = siz;
-
-	/* Copy as many bytes as will fit */
-	if (n != 0 && --n != 0) {
-		do {
-			if ((*d++ = *s++) == 0)
-				break;
-		} while (--n != 0);
-	}
-
-	/* Not enough room in dst, add NUL and traverse rest of src */
-	if (n == 0) {
-		if (siz != 0)
-			*d = '\0';	/* NUL-terminate dst */
-		while (*s++)
-			;
-	}
-
-	return(s - src - 1);		/* count does not include NUL */
-}
-#endif
--- a/sx_maxsockbuf.c
+++ b/sx_maxsockbuf.c
@@ -1,3 +1,30 @@
+/*
+ * Copyright (c) 2019-2020 Job Snijders <job@sobornost.net>
+ * Copyright (c) 2007-2019 Alexandre Snarskii <snar@snar.spb.ru>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
@@ -9,21 +36,18 @@
 #include <string.h>
 #include <unistd.h>

+#include "extern.h"
 #include "sx_report.h"

-#ifndef SX_MAXSOCKBUF_MAX
-#define SX_MAXSOCKBUF_MAX (2*1024*1024)
-#endif
-
 int
 sx_maxsockbuf(int s, int dir)
-{ 
-	int optval = 0, voptval;
-	int hiconf = -1, loconf = -1;
-	unsigned int voptlen;
-	int phase = 0, iterations = 0;
+{
+	int		optval = 0, voptval;
+	int		hiconf = -1, loconf = -1;
+	unsigned int	voptlen;
+	int		phase = 0, iterations = 0;

-	if (s<0) { 
+	if (s < 0) {
 		sx_report(SX_FATAL,"Unable to maximize sockbuf on invalid "
 		    "socket %i\n", s);
 		exit(1);
@@ -37,30 +61,27 @@ sx_maxsockbuf(int s, int dir)
 		return -1;
 	}

-	for (;;) { 
+	for (;;) {
 		iterations++;

 		if (phase == 0)
-			optval<<=1; 
-		else { 
+			optval <<= 1;
+		else {
 			if (optval == (hiconf + loconf) / 2)
 				break;
 			optval = (hiconf + loconf) / 2;
 		}

-		if (optval > SX_MAXSOCKBUF_MAX && phase == 0) 
-			break;
-
 		if (setsockopt(s, SOL_SOCKET, dir, (void*)&optval,
 		    sizeof(optval)) == -1) {

 			if (phase == 0)
-				phase = 1; 
+				phase = 1;

-			hiconf = optval; 
+			hiconf = optval;

 			continue;
-		} else { 
+		} else {
 			loconf = optval;
 		}

@@ -71,39 +92,26 @@ sx_maxsockbuf(int s, int dir)
 			sx_report(SX_ERROR,"getsockopt failed: %s\n",
 			    strerror(errno));
 			return -1;
-		} else if (voptval < optval) { 
-			if (phase == 0) { 
+		} else if (voptval < optval) {
+			if (phase == 0) {
 				phase = 1;
 				optval >>= 1;
 				continue;
-			} else if (phase == 1) { 
+			} else if (phase == 1) {
 				phase = 2;
 				optval -= 2048;
 				continue;
 			} else
 				break;
-		} else if (voptval >= SX_MAXSOCKBUF_MAX) { 
-			/*
-			 * ... and getsockopt not failed and voptval>=optval.
-			 * Do not allow to increase sockbuf too much even in
-			 * case OS permits it
-			 */
-			break;
 		}
 	}

 	voptlen = sizeof(voptval);
 	if (getsockopt(s, SOL_SOCKET, dir, (void*)&voptval,
 	    &voptlen) == -1) {
-		sx_report(SX_ERROR,"getsockopt(final stage) failed: %s\n", 
+		sx_report(SX_ERROR,"getsockopt(final stage) failed: %s\n",
 		    strerror(errno));
 		return -1;
-	} else { 
-		/*
-		printf("Finally got %i bytes of recvspace in %i interations\n", 
-			voptval, iterations);
-		*/
-	}
-
-	return voptval;
+	} else
+		return voptval;
 }
--- a/sx_maxsockbuf.h
+++ b/sx_maxsockbuf.h
@@ -1,8 +0,0 @@
-#ifndef SX_MAXSOCKBUF_H_
-#define SX_MAXSOCKBUF_H_
-
-/* s - number of opened socket, dir is either SO_SNDBUF or SO_RCVBUF */
-int sx_maxsockbuf(int s, int dir);
-
-#endif
-
--- a/sx_prefix.c
+++ b/sx_prefix.c
@@ -1,6 +1,29 @@
-#if HAVE_CONFIG_H
-#include "config.h"
-#endif
+/*
+ * Copyright (c) 2019-2020 Job Snijders <job@sobornost.net>
+ * Copyright (c) 2007-2019 Alexandre Snarskii <snar@snar.spb.ru>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */

 #include <ctype.h>
 #include <errno.h>
@@ -12,13 +35,13 @@
 #include "sx_prefix.h"
 #include "sx_report.h"

-int debug_aggregation=0;
+int debug_aggregation = 0;
 extern int debug_expander;

 struct sx_prefix*
-sx_prefix_alloc(struct sx_prefix* p)
+sx_prefix_alloc(struct sx_prefix *p)
 {
-	struct sx_prefix* sp = malloc(sizeof(struct sx_prefix));
+	struct sx_prefix *sp = malloc(sizeof(struct sx_prefix));

 	if (!sp)
 		return NULL;
@@ -32,7 +55,7 @@ sx_prefix_alloc(struct sx_prefix* p)
 }

 void
-sx_prefix_destroy(struct sx_prefix* p)
+sx_prefix_destroy(struct sx_prefix *p)
 {
 	if (p)
 		free(p);
@@ -53,16 +76,16 @@ sx_radix_node_destroy(struct sx_radix_node *n)
 }

 void
-sx_prefix_adjust_masklen(struct sx_prefix* p)
+sx_prefix_adjust_masklen(struct sx_prefix *p)
 {
-	int nbytes = (p->family == AF_INET ? 4 : 16);
-	int i;
+	unsigned int	nbytes = (p->family == AF_INET ? 4 : 16);
+	unsigned int	i;

 	if (p->masklen == nbytes * 8)
 		return; /* mask is all ones */

 	for (i = nbytes -1; i > p->masklen / 8; i--) {
-		p->addr.addrs[i]=0;
+		p->addr.addrs[i] = 0;
 	}

 	for (i = 1; i <= 8 - p->masklen % 8; i++) {
@@ -70,10 +93,10 @@ sx_prefix_adjust_masklen(struct sx_prefix* p)
 	}
 }

-void
-sx_prefix_mask(struct sx_prefix* p, struct sx_prefix* q)
+static void
+sx_prefix_mask(struct sx_prefix *p, struct sx_prefix *q)
 {
-	int i;
+	unsigned int	i;

 	memset(q->addr.addrs, 0, sizeof(q->addr.addrs));

@@ -87,10 +110,10 @@ sx_prefix_mask(struct sx_prefix* p, struct sx_prefix* q)
 		q->addr.addrs[p->masklen / 8] |= (1 << (8 - i));
 }

-void
-sx_prefix_imask(struct sx_prefix* p, struct sx_prefix* q)
+static void
+sx_prefix_imask(struct sx_prefix *p, struct sx_prefix *q)
 {
-	int i;
+	unsigned int	i;

 	memset(q->addr.addrs, 0xff, sizeof(q->addr.addrs));

@@ -106,11 +129,11 @@ sx_prefix_imask(struct sx_prefix* p, struct sx_prefix* q)


 int
-sx_prefix_parse(struct sx_prefix* p, int af, char* text)
+sx_prefix_parse(struct sx_prefix *p, int af, char *text)
 {
-	char* c = NULL;
-	int masklen, ret;
-	char mtext[INET6_ADDRSTRLEN+5];
+	char	*c = NULL;
+	int	 masklen, ret;
+	char	 mtext[INET6_ADDRSTRLEN + 5];

 	strlcpy(mtext, text, sizeof(mtext));

@@ -119,7 +142,7 @@ sx_prefix_parse(struct sx_prefix* p, int af, char* text)
 	if (c) {
 		char* eod;
 		*c = 0;
-		masklen = strtol(c+1, &eod, 10);
+		masklen = strtol(c + 1, &eod, 10);
 		if (eod && eod[0] && !isspace(eod[0])) {
 			*c = '/';
 			sx_report(SX_ERROR, "Invalid masklen in prefix %s\n",
@@ -169,7 +192,7 @@ sx_prefix_parse(struct sx_prefix* p, int af, char* text)
 		if (masklen == -1)
 			p->masklen = 32;
 		else {
-			if(masklen < 0 || masklen > 32) {
+			if (masklen < 0 || masklen > 32) {
 				p->masklen = 32;
 			} else {
 				p->masklen = masklen;
@@ -202,10 +225,10 @@ fixups:
 	return 0;
 }

-int
-sx_prefix_isbitset(struct sx_prefix* p, int n)
+static int
+sx_prefix_isbitset(struct sx_prefix *p, int n)
 {
-	unsigned char s;
+	unsigned char	s;

 	/* bits outside the prefix considered unset */
 	if (p->family == AF_INET && (n < 0 || n > 32))
@@ -217,10 +240,10 @@ sx_prefix_isbitset(struct sx_prefix* p, int n)
 	return (s & (0x80 >> ((n - 1) % 8))) ? 1 : 0;
 }

-void
-sx_prefix_setbit(struct sx_prefix* p, int n)
+static void
+sx_prefix_setbit(struct sx_prefix *p, int n)
 {
-	unsigned char* s;
+	unsigned char	*s;

 	if (p->family == AF_INET && (n < 0 || n > 32))
 		return;
@@ -233,8 +256,8 @@ sx_prefix_setbit(struct sx_prefix* p, int n)
 }


-int
-sx_radix_tree_insert_specifics(struct sx_radix_tree* t, struct sx_prefix *p,
+static int
+sx_radix_tree_insert_specifics(struct sx_radix_tree *t, struct sx_prefix *p,
    unsigned min, unsigned max)
 {
 	struct sx_prefix *np;
@@ -258,12 +281,12 @@ sx_radix_tree_insert_specifics(struct sx_radix_tree* t, struct sx_prefix *p,
 }

 int
-sx_prefix_range_parse(struct sx_radix_tree* tree, int af, int maxlen,
-    char* text)
+sx_prefix_range_parse(struct sx_radix_tree *tree, int af, unsigned int maxlen,
+    char *text)
 {
-	char* d = strchr(text, '^');
-	struct sx_prefix *p;
-	unsigned long min, max;
+	char			*d = strchr(text, '^');
+	struct sx_prefix	*p;
+	unsigned long		 min, max = 0;

 	p = sx_prefix_alloc(NULL);

@@ -274,7 +297,7 @@ sx_prefix_range_parse(struct sx_radix_tree* tree, int af, int maxlen,

 	if (!sx_prefix_parse(p, 0, text)) {
 		sx_report(SX_ERROR, "Unable to parse prefix %s^%s\n", text,
-		    d+1);
+		    d + 1);
 		return 0;
 	}

@@ -299,8 +322,8 @@ sx_prefix_range_parse(struct sx_radix_tree* tree, int af, int maxlen,
 		min = p->masklen;
 		max = maxlen;
 	} else if (isdigit(d[1])) {
-		char* dm = NULL;
-		min = strtoul(d+1, &dm, 10);
+		char *dm = NULL;
+		min = strtoul(d + 1, &dm, 10);
 		if (dm && *dm == '-' && isdigit(dm[1])) {
 			max = strtoul(dm + 1, NULL, 10);
 		} else if (dm && *dm) {
@@ -340,10 +363,10 @@ sx_prefix_range_parse(struct sx_radix_tree* tree, int af, int maxlen,
 	return 1;
 }

-struct sx_prefix*
-sx_prefix_new(int af, char* text)
+struct sx_prefix *
+sx_prefix_new(int af, char *text)
 {
-	struct sx_prefix* p = NULL;
+	struct sx_prefix *p = NULL;

 	if (!text)
 		return NULL;
@@ -362,7 +385,7 @@ sx_prefix_new(int af, char* text)
 }

 int
-sx_prefix_fprint(FILE* f, struct sx_prefix* p)
+sx_prefix_fprint(FILE *f, struct sx_prefix *p)
 {
 	char buffer[128];

@@ -376,7 +399,7 @@ sx_prefix_fprint(FILE* f, struct sx_prefix* p)
 }

 int
-sx_prefix_snprintf_sep(struct sx_prefix* p, char* rbuffer, int srb, char* sep)
+sx_prefix_snprintf_sep(struct sx_prefix *p, char *rbuffer, int srb, char *sep)
 {
 	char buffer[128];

@@ -394,23 +417,22 @@ sx_prefix_snprintf_sep(struct sx_prefix* p, char* rbuffer, int srb, char* sep)
 }

 int
-sx_prefix_snprintf(struct sx_prefix* p, char* rbuffer, int srb)
+sx_prefix_snprintf(struct sx_prefix *p, char *rbuffer, int srb)
 {
 	return sx_prefix_snprintf_sep(p, rbuffer, srb, "/");
 }

 void
-sx_prefix_snprintf_fmt(struct sx_prefix* p, FILE* f,
-    const char* name, const char* format,
+sx_prefix_snprintf_fmt(struct sx_prefix *p, FILE *f,
+    const char *name, const char *format,
    unsigned int aggregateLow, unsigned int aggregateHi)
 {
-	unsigned off = 0;
-	const char* c = format;
-	struct sx_prefix *q = sx_prefix_alloc(NULL);
-	char prefix[128];
+	const char		*c = format;
+	struct sx_prefix	*q = sx_prefix_alloc(NULL);
+	char			 prefix[128];

 	while (*c) {
-		if(*c == '%') {
+		if (*c == '%') {
 			switch (*(c + 1)) {
 			case 'r':
 			case 'n':
@@ -461,7 +483,7 @@ sx_prefix_snprintf_fmt(struct sx_prefix* p, FILE* f,
 			}
 			c += 2;
 		} else if (*c == '\\') {
-			switch(*(c+1)) {
+			switch(*(c + 1)) {
 			case 'n':
 				fprintf(f, "\n");
 				break;
@@ -484,7 +506,7 @@ sx_prefix_snprintf_fmt(struct sx_prefix* p, FILE* f,
 }

 int
-sx_prefix_jsnprintf(struct sx_prefix* p, char* rbuffer, int srb)
+sx_prefix_jsnprintf(struct sx_prefix *p, char *rbuffer, int srb)
 {
 	char buffer[128];

@@ -500,7 +522,7 @@ sx_prefix_jsnprintf(struct sx_prefix* p, char* rbuffer, int srb)
 struct sx_radix_tree*
 sx_radix_tree_new(int af)
 {
-	struct sx_radix_tree* rt = malloc(sizeof(struct sx_radix_tree));
+	struct sx_radix_tree *rt = malloc(sizeof(struct sx_radix_tree));

 	if (!rt)
 		return NULL;
@@ -512,15 +534,15 @@ sx_radix_tree_new(int af)
 }

 int
-sx_radix_tree_empty(struct sx_radix_tree* t)
+sx_radix_tree_empty(struct sx_radix_tree *t)
 {
 	return t->head == NULL;
 }

 struct sx_radix_node*
-sx_radix_node_new(struct sx_prefix* prefix)
+sx_radix_node_new(struct sx_prefix *prefix)
 {
-	struct sx_radix_node* rn = malloc(sizeof(struct sx_radix_node));
+	struct sx_radix_node *rn = malloc(sizeof(struct sx_radix_node));

 	if (!rn)
 		return NULL;
@@ -533,20 +555,20 @@ sx_radix_node_new(struct sx_prefix* prefix)
 	return rn;
 }

-int
-sx_prefix_eqbits(struct sx_prefix* a, struct sx_prefix* b)
+static int
+sx_prefix_eqbits(struct sx_prefix *a, struct sx_prefix *b)
 {
-	int i;
-	int nbytes = (a->family == AF_INET ? 4 : 16);
+	unsigned int	i;
+	unsigned int	nbytes = (a->family == AF_INET ? 4 : 16);

 	for (i = 0; i < nbytes; i++) {

 		if (a->addr.addrs[i] == b->addr.addrs[i])
 			continue;
 		else {
-			int j;
+			unsigned int j;
 			for (j = 0; j < 8 && i * 8 + j <= a->masklen
-			    && i * 8 + j<= b->masklen; j++) {
+			    && i * 8 + j <= b->masklen; j++) {
 				if ((a->addr.addrs[i] & (0x80 >> j))
 				    != (b->addr.addrs[i] & (0x80 >> j)))
 					return i * 8 + j;
@@ -561,9 +583,9 @@ sx_prefix_eqbits(struct sx_prefix* a, struct sx_prefix* b)
 }

 struct sx_prefix*
-sx_prefix_overlay(struct sx_prefix* p, int n)
+sx_prefix_overlay(struct sx_prefix *p, int n)
 {
-	struct sx_prefix* sp = sx_prefix_alloc(p);
+	struct sx_prefix *sp = sx_prefix_alloc(p);
 	sp->masklen = n;
 	sx_prefix_adjust_masklen(sp);

@@ -571,7 +593,7 @@ sx_prefix_overlay(struct sx_prefix* p, int n)
 }

 void
-sx_radix_tree_unlink(struct sx_radix_tree* tree, struct sx_radix_node* node)
+sx_radix_tree_unlink(struct sx_radix_tree *tree, struct sx_radix_node *node)
 {
 next:
 	if (node->r && node->l)
@@ -603,14 +625,14 @@ next:
 			if (node->parent->r == node) {
 				node->parent->r = node->l;
 				node->l->parent = node->parent;
-			} else if(node->parent->l==node) {
+			} else if (node->parent->l==node) {
 				node->parent->l=node->l;
 				node->l->parent=node->parent;
 			} else {
 				sx_report(SX_ERROR,"Unlinking node which is not descendant "
 					"of its parent\n");
 			}
-		} else if(tree->head==node) {
+		} else if (tree->head==node) {
 			tree->head=node->l;
 			node->l->parent=NULL;
 		} else {
@@ -621,7 +643,7 @@ next:
 	} else {
 		/* the only case - node does not have descendants */
 		if (node->parent) {
-			if(node->parent->l == node)
+			if (node->parent->l == node)
 				node->parent->l = NULL;
 			else if (node->parent->r == node)
 				node->parent->r=NULL;
@@ -647,10 +669,10 @@ next:
 	
 			
 struct sx_radix_node*
-sx_radix_tree_lookup(struct sx_radix_tree* tree, struct sx_prefix* prefix)
+sx_radix_tree_lookup(struct sx_radix_tree *tree, struct sx_prefix *prefix)
 {
-	int eb;
-	struct sx_radix_node* candidate = NULL, *chead;
+	unsigned int 		 eb;
+	struct sx_radix_node	*candidate = NULL, *chead;

 	if (!tree || !prefix)
 		return NULL;
@@ -711,19 +733,19 @@ next:


 struct sx_radix_node*
-sx_radix_tree_insert(struct sx_radix_tree* tree, struct sx_prefix* prefix)
+sx_radix_tree_insert(struct sx_radix_tree *tree, struct sx_prefix *prefix)
 {
-	int eb;
-	struct sx_radix_node** candidate=NULL, *chead;
+	unsigned int		 eb;
+	struct sx_radix_node	**candidate=NULL, *chead;

 	if (!tree || !prefix)
 		return NULL;

-	if (tree->family!=prefix->family)
+	if (tree->family != prefix->family)
 		return NULL;

 	if (!tree->head) {
-		tree->head=sx_radix_node_new(prefix);
+		tree->head = sx_radix_node_new(prefix);
 		return tree->head;
 	}

@@ -735,7 +757,7 @@ next:
 	if (eb < prefix->masklen && eb < chead->prefix->masklen) {
 		struct sx_prefix *neoRoot = sx_prefix_alloc(prefix);
 		
-		struct sx_radix_node* rn, *ret=sx_radix_node_new(prefix);
+		struct sx_radix_node *rn, *ret=sx_radix_node_new(prefix);
 		neoRoot->masklen = eb;
 		sx_prefix_adjust_masklen(neoRoot);
 		rn=sx_radix_node_new(neoRoot);
@@ -762,7 +784,7 @@ next:
 		*candidate = rn;
 		return ret;
 	} else if (eb == prefix->masklen && eb < chead->prefix->masklen) {
-		struct sx_radix_node* ret = sx_radix_node_new(prefix);
+		struct sx_radix_node *ret = sx_radix_node_new(prefix);
 		if (sx_prefix_isbitset(chead->prefix, eb + 1)) {
 			ret->r = chead;
 		} else {
@@ -811,10 +833,11 @@ next:
 }

 void
-sx_radix_node_fprintf(struct sx_radix_node* node, void* udata)
+sx_radix_node_fprintf(struct sx_radix_node *node, void *udata)
 {
-	FILE* out = (udata?udata:stdout);
-	char buffer[128];
+	FILE	*out = (udata?udata:stdout);
+	char	 buffer[128];
+
 	if (!node) {
 		fprintf(out, "(null)\n");
 	} else {
@@ -824,10 +847,10 @@ sx_radix_node_fprintf(struct sx_radix_node* node, void* udata)
 }

 int
-sx_radix_node_foreach(struct sx_radix_node* node,
-    void (*func)(struct sx_radix_node*, void*), void* udata)
+sx_radix_node_foreach(struct sx_radix_node *node,
+    void (*func)(struct sx_radix_node*, void*), void *udata)
 {
-	func(node,udata);
+	func(node, udata);

 	if (node->l)
 		sx_radix_node_foreach(node->l, func, udata);
@@ -839,25 +862,27 @@ sx_radix_node_foreach(struct sx_radix_node* node,
 }

 int
-sx_radix_tree_foreach(struct sx_radix_tree* tree,
-	void (*func)(struct sx_radix_node*, void*), void* udata)
+sx_radix_tree_foreach(struct sx_radix_tree *tree,
+    void (*func)(struct sx_radix_node *, void *), void *udata)
 {
-	if(!func || !tree || !tree->head) return 0;
-	sx_radix_node_foreach(tree->head,func,udata);
+	if (!func || !tree || !tree->head)
+		return 0;
+
+	sx_radix_node_foreach(tree->head, func, udata);
 	return 0;
 }

-int
-sx_radix_node_aggregate(struct sx_radix_node* node)
+static int
+sx_radix_node_aggregate(struct sx_radix_node *node)
 {
-	if(node->l)
+	if (node->l)
 		sx_radix_node_aggregate(node->l);
-	if(node->r)
+	if (node->r)
 		sx_radix_node_aggregate(node->r);

-	if(debug_aggregation) {
+	if (debug_aggregation) {
 		printf("Aggregating on node: ");
-		sx_prefix_fprint(stdout,node->prefix);
+		sx_prefix_fprint(stdout, node->prefix);
 		printf(" %s%s%u,%u\n", node->isGlue?"Glue ":"",
 			node->isAggregate?"Aggregate ":"",node->aggregateLow,
 			node->aggregateHi);
@@ -900,7 +925,7 @@ sx_radix_node_aggregate(struct sx_radix_node* node)
 		if (!node->r->isAggregate && !node->l->isAggregate
 		    && !node->r->isGlue && !node->l->isGlue
 		    && node->r->prefix->masklen == node->l->prefix->masklen) {
-			if (node->r->prefix->masklen == node->prefix->masklen+1) {
+			if (node->r->prefix->masklen == node->prefix->masklen + 1) {
 				node->isAggregate = 1;
 				node->r->isGlue = 1;
 				node->l->isGlue = 1;
@@ -994,7 +1019,7 @@ sx_radix_node_aggregate(struct sx_radix_node* node)
 		    && node->l->aggregateHi == node->r->son->aggregateHi
 		    && node->l->aggregateLow == node->r->son->aggregateLow) {
 			if (node->l->prefix->masklen == node->prefix->masklen + 1
-			    && node->r->prefix->masklen == node->prefix->masklen+1) {
+			    && node->r->prefix->masklen == node->prefix->masklen + 1) {
 				if (node->isGlue) {
 					node->l->isGlue = 1;
 					node->r->son->isGlue = 1;
@@ -1019,7 +1044,7 @@ sx_radix_node_aggregate(struct sx_radix_node* node)
 }

 int
-sx_radix_tree_aggregate(struct sx_radix_tree* tree)
+sx_radix_tree_aggregate(struct sx_radix_tree *tree)
 {
 	if (tree && tree->head)
 		return sx_radix_node_aggregate(tree->head);
@@ -1028,7 +1053,7 @@ sx_radix_tree_aggregate(struct sx_radix_tree* tree)
 }

 static void
-setGlueUpTo(struct sx_radix_node* node, void* udata)
+setGlueUpTo(struct sx_radix_node *node, void *udata)
 {
 	unsigned refine = *(unsigned*)udata;

@@ -1036,8 +1061,8 @@ setGlueUpTo(struct sx_radix_node* node, void* udata)
 		node->isGlue = 1;
 }

-int
-sx_radix_node_refine(struct sx_radix_node* node, unsigned refine)
+static int
+sx_radix_node_refine(struct sx_radix_node *node, unsigned refine)
 {
 	if (!node->isGlue && node->prefix->masklen<refine) {
 		node->isAggregate = 1;
@@ -1079,7 +1104,7 @@ sx_radix_node_refine(struct sx_radix_node* node, unsigned refine)
 }
 	
 int
-sx_radix_tree_refine(struct sx_radix_tree* tree, unsigned refine)
+sx_radix_tree_refine(struct sx_radix_tree *tree, unsigned refine)
 {
 	if (tree && tree->head)
 		return sx_radix_node_refine(tree->head, refine);
@@ -1088,16 +1113,16 @@ sx_radix_tree_refine(struct sx_radix_tree* tree, unsigned refine)
 }

 static void
-setGlueFrom(struct sx_radix_node* node, void* udata)
+setGlueFrom(struct sx_radix_node *node, void *udata)
 {
 	unsigned refine = *(unsigned*)udata;

 	if (node && node->prefix->masklen <= refine)
-		node->isGlue=1;
+		node->isGlue = 1;
 }

 static int
-sx_radix_node_refineLow(struct sx_radix_node* node, unsigned refineLow)
+sx_radix_node_refineLow(struct sx_radix_node *node, unsigned refineLow)
 {
 	if (!node->isGlue && node->prefix->masklen<=refineLow) {

@@ -1148,7 +1173,7 @@ sx_radix_node_refineLow(struct sx_radix_node* node, unsigned refineLow)
 }

 int
-sx_radix_tree_refineLow(struct sx_radix_tree* tree, unsigned refineLow)
+sx_radix_tree_refineLow(struct sx_radix_tree *tree, unsigned refineLow)
 {
 	if (tree && tree->head)
 		return sx_radix_node_refineLow(tree->head, refineLow);
@@ -1159,10 +1184,10 @@ sx_radix_tree_refineLow(struct sx_radix_tree* tree, unsigned refineLow)
 #if SX_PTREE_TEST
 int
 main() {
-	struct sx_prefix* p;
-	int n;
-	struct sx_radix_tree* tree;
-	struct sx_radix_node* node;
+	struct sx_prefix	*p;
+	struct sx_radix_tree	*tree;
+	struct sx_radix_node	*node;
+	int			 n;

 	p = sx_prefix_new(0, "10.11.12.13/24");
 	sx_prefix_fprint(stdout, p);
@@ -1214,14 +1239,12 @@ main() {
 	sx_prefix_fprint(stdout, p);
 	printf("\n");

-#define SX_TEST_EBITS(a,b,susp) n = sx_prefix_eqbits(sx_prefix_new(0,a)),\
-		sx_prefix_new(0,b))); \
-		if (n != susp) \
-			printf("FAILED: %s eqbits %s=%i, not %i\n", a, b, n,
-			     susp);\
-		else
-			printf("OK, %s eqbits %s = %i, as suspected\n", a, b,
-			    n);
+#define SX_TEST_EBITS(a, b, susp) \
+	n = sx_prefix_eqbits(sx_prefix_new(0, a), sx_prefix_new(0, b)); \
+	if (n != susp) \
+		printf("FAILED: %s eqbits %s=%i, not %i\n", a, b, n, susp); \
+	else \
+		printf("OK, %s eqbits %s = %i, as suspected\n", a, b, n);
 	SX_TEST_EBITS("192.168.0.0/24", "192.168.1.0/24", 23);
 	SX_TEST_EBITS("192.168.0.0/32", "192.168.0.1/32", 31);
 #if SX_LIBPTREE_IPV6
--- a/sx_prefix.h
+++ b/sx_prefix.h
@@ -1,3 +1,29 @@
+/*
+ * Copyright (c) 2007-2019 Alexandre Snarskii <snar@snar.spb.ru>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
 #ifndef _SX_PREFIX_H_
 #define _SX_PREFIX_H_

@@ -8,7 +34,7 @@

 typedef struct sx_prefix { 
 	int family; 
-	int masklen; 
+	unsigned int masklen; 
 	union { 
 		struct in_addr  addr; 
 		struct in6_addr addr6; 
@@ -17,59 +43,59 @@ typedef struct sx_prefix {
 } sx_prefix_t;

 typedef struct sx_radix_node { 
-	struct sx_radix_node* parent, *l, *r, *son;
-	void* payload;
-	unsigned int isGlue:1;
-	unsigned int isAggregated:1;
-	unsigned int isAggregate:1;
-	unsigned int aggregateLow;
-	unsigned int aggregateHi;
-	struct sx_prefix *prefix;
+	struct sx_radix_node	*parent, *l, *r, *son;
+	void			*payload;
+	unsigned int 		 isGlue:1;
+	unsigned int 		 isAggregated:1;
+	unsigned int 		 isAggregate:1;
+	unsigned int 		 aggregateLow;
+	unsigned int 		 aggregateHi;
+	struct sx_prefix	*prefix;
 } sx_radix_node_t;

 typedef struct sx_radix_tree { 
-	int family;
-	struct sx_radix_node* head;
+	int 			 family;
+	struct sx_radix_node	*head;
 } sx_radix_tree_t;

 /* most common operations with the tree is to: lookup/insert/unlink */
-struct sx_radix_node* sx_radix_tree_lookup(struct sx_radix_tree* tree,
-	struct sx_prefix* prefix);
-struct sx_radix_node* sx_radix_tree_insert(struct sx_radix_tree* tree, 
-	struct sx_prefix* prefix);
-void sx_radix_tree_unlink(struct sx_radix_tree* t, struct sx_radix_node* n);
-struct sx_radix_node* sx_radix_tree_lookup_exact(struct sx_radix_tree* tree,
-	struct sx_prefix* prefix);
+struct sx_radix_node *sx_radix_tree_lookup(struct sx_radix_tree *tree,
+    struct sx_prefix *prefix);
+struct sx_radix_node *sx_radix_tree_insert(struct sx_radix_tree *tree, 
+    struct sx_prefix *prefix);
+void sx_radix_tree_unlink(struct sx_radix_tree *t, struct sx_radix_node *n);
+struct sx_radix_node *sx_radix_tree_lookup_exact(struct sx_radix_tree *tree,
+	struct sx_prefix *prefix);

-struct sx_prefix* sx_prefix_alloc(struct sx_prefix* p);
-void sx_prefix_destroy(struct sx_prefix* p);
-void sx_radix_node_destroy(struct sx_radix_node* p);
-void sx_prefix_adjust_masklen(struct sx_prefix* p);
-struct sx_prefix* sx_prefix_new(int af, char* text);
-int sx_prefix_parse(struct sx_prefix* p, int af, char* text);
-int sx_prefix_range_parse(struct sx_radix_tree* t, int af, int ml, char* text);
-int sx_prefix_fprint(FILE* f, struct sx_prefix* p);
-int sx_prefix_snprintf(struct sx_prefix* p, char* rbuffer, int srb);
-int sx_prefix_snprintf_sep(struct sx_prefix* p, char* rbuffer, int srb, char*);
-void sx_prefix_snprintf_fmt(struct sx_prefix* p, FILE* f,
-	const char* name, const char* fmt,
-	unsigned int aggregateLow, unsigned int aggregateHi);
-int sx_prefix_jsnprintf(struct sx_prefix* p, char* rbuffer, int srb);
-struct sx_radix_tree* sx_radix_tree_new(int af);
-struct sx_radix_node* sx_radix_node_new(struct sx_prefix* prefix);
-struct sx_prefix* sx_prefix_overlay(struct sx_prefix* p, int n);
-int  sx_radix_tree_empty(struct sx_radix_tree* t);
-void sx_radix_node_fprintf(struct sx_radix_node* node, void* udata);
-int  sx_radix_node_foreach(struct sx_radix_node* node, 
-	void (*func)(struct sx_radix_node*, void*), void* udata);
-int sx_radix_tree_foreach(struct sx_radix_tree* tree, 
-	void (*func)(struct sx_radix_node*, void*), void* udata);
-int sx_radix_tree_aggregate(struct sx_radix_tree* tree);
-int sx_radix_tree_refine(struct sx_radix_tree* tree, unsigned refine);
-int sx_radix_tree_refineLow(struct sx_radix_tree* tree, unsigned refineLow);
+struct sx_prefix *sx_prefix_alloc(struct sx_prefix *p);
+void sx_prefix_destroy(struct sx_prefix *p);
+void sx_radix_node_destroy(struct sx_radix_node *p);
+void sx_prefix_adjust_masklen(struct sx_prefix *p);
+struct sx_prefix *sx_prefix_new(int af, char *text);
+int sx_prefix_parse(struct sx_prefix *p, int af, char *text);
+int sx_prefix_range_parse(struct sx_radix_tree *t, int af, unsigned int ml, char *text);
+int sx_prefix_fprint(FILE *f, struct sx_prefix *p);
+int sx_prefix_snprintf(struct sx_prefix *p, char *rbuffer, int srb);
+int sx_prefix_snprintf_sep(struct sx_prefix *p, char *rbuffer, int srb, char *);
+void sx_prefix_snprintf_fmt(struct sx_prefix *p, FILE *f,
+    const char *name, const char *fmt, unsigned int aggregateLow,
+    unsigned int aggregateHi);
+int sx_prefix_jsnprintf(struct sx_prefix *p, char *rbuffer, int srb);
+struct sx_radix_tree *sx_radix_tree_new(int af);
+struct sx_radix_node *sx_radix_node_new(struct sx_prefix *prefix);
+struct sx_prefix *sx_prefix_overlay(struct sx_prefix *p, int n);
+int sx_radix_tree_empty(struct sx_radix_tree *t);
+void sx_radix_node_fprintf(struct sx_radix_node *node, void *udata);
+int  sx_radix_node_foreach(struct sx_radix_node *node, 
+	void (*func)(struct sx_radix_node *, void *), void *udata);
+int sx_radix_tree_foreach(struct sx_radix_tree *tree, 
+	void (*func)(struct sx_radix_node *, void *), void *udata);
+int sx_radix_tree_aggregate(struct sx_radix_tree *tree);
+int sx_radix_tree_refine(struct sx_radix_tree *tree, unsigned refine);
+int sx_radix_tree_refineLow(struct sx_radix_tree *tree, unsigned refineLow);

 #ifndef HAVE_STRLCPY
-size_t strlcpy(char* dst, const char* src, size_t size);
+size_t strlcpy(char *dst, const char *src, size_t size);
 #endif

 #endif
--- a/sx_report.c
+++ b/sx_report.c
@@ -1,6 +1,28 @@
-#if HAVE_CONFIG_H
-#include <config.h>
-#endif
+/*
+ * Copyright (c) 2007-2019 Alexandre Snarskii <snar@snar.spb.ru>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */

 #include <errno.h>
 #include <inttypes.h>
--- a/sx_report.h
+++ b/sx_report.h
@@ -1,3 +1,29 @@
+/*
+ * Copyright (c) 2007-2019 Alexandre Snarskii <snar@snar.spb.ru>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
 #ifndef SX_REPORT_H_
 #define SX_REPORT_H_

--- a/sx_slentry.c
+++ b/sx_slentry.c
@@ -1,35 +1,61 @@
+/*
+ * Copyright (c) 2007-2019 Alexandre Snarskii <snar@snar.spb.ru>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */

+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <strings.h>

-#include "sx_slentry.h"
+#include "extern.h"

-struct sx_slentry*
-sx_slentry_new(char* t)
+struct slentry *
+sx_slentry_new(char *t)
 {
-	struct sx_slentry* e = malloc(sizeof(struct sx_slentry));
+	struct slentry	*e = malloc(sizeof(struct slentry));

 	if (!e)
 		return NULL;

-	memset(e, 0, sizeof(struct sx_slentry));
+	memset(e, 0, sizeof(struct slentry));

-	if (t)
-		e->text = strdup(t);
+	e->text = strdup(t);

 	return e;
 }

-struct sx_tentry*
-sx_tentry_new(char* t)
+struct sx_tentry *
+sx_tentry_new(char *t)
 {
-	struct sx_tentry* te = malloc(sizeof(struct sx_tentry));
+	struct sx_tentry	*te = malloc(sizeof(struct sx_tentry));

 	if (!te)
 		return NULL;

 	memset(te, 0, sizeof(struct sx_tentry));
+
 	te->text = strdup(t);

 	return te;
--- a/sx_slentry.h
+++ b/sx_slentry.h
@@ -1,30 +0,0 @@
-#ifndef SX_SLENTRY_H_
-#define SX_SLENTRY_H_
-
-#if HAVE_SYS_QUEUE_H && HAVE_STAILQ_IN_SYS_QUEUE
-#include <sys/queue.h>
-#else
-#include "sys_queue.h"
-#endif
-
-#if HAVE_SYS_TREE_H
-#include <sys/tree.h>
-#else
-#include "sys_tree.h"
-#endif
-
-struct sx_slentry {
-	STAILQ_ENTRY(sx_slentry) next;
-	char*  text;
-};
-
-struct sx_slentry* sx_slentry_new(char* text);
-
-struct sx_tentry {
-	RB_ENTRY(sx_tentry) entry;
-	char* text;
-};
-
-struct sx_tentry* sx_tentry_new(char* text);
-
-#endif
--- a/sys_queue.h
+++ b/sys_queue.h
@@ -1,696 +0,0 @@
-/*-
- * Copyright (c) 1991, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)queue.h	8.5 (Berkeley) 8/20/94
- * $FreeBSD: stable/10/sys/sys/queue.h 251887 2013-06-18 02:57:56Z lstewart $
- */
-
-#ifndef _SYS_QUEUE_H_
-#define	_SYS_QUEUE_H_
-
-#if HAVE_SYS_CDEFS_H
-#include <sys/cdefs.h>
-#endif
-
-/*
- * This file defines four types of data structures: singly-linked lists,
- * singly-linked tail queues, lists and tail queues.
- *
- * A singly-linked list is headed by a single forward pointer. The elements
- * are singly linked for minimum space and pointer manipulation overhead at
- * the expense of O(n) removal for arbitrary elements. New elements can be
- * added to the list after an existing element or at the head of the list.
- * Elements being removed from the head of the list should use the explicit
- * macro for this purpose for optimum efficiency. A singly-linked list may
- * only be traversed in the forward direction.  Singly-linked lists are ideal
- * for applications with large datasets and few or no removals or for
- * implementing a LIFO queue.
- *
- * A singly-linked tail queue is headed by a pair of pointers, one to the
- * head of the list and the other to the tail of the list. The elements are
- * singly linked for minimum space and pointer manipulation overhead at the
- * expense of O(n) removal for arbitrary elements. New elements can be added
- * to the list after an existing element, at the head of the list, or at the
- * end of the list. Elements being removed from the head of the tail queue
- * should use the explicit macro for this purpose for optimum efficiency.
- * A singly-linked tail queue may only be traversed in the forward direction.
- * Singly-linked tail queues are ideal for applications with large datasets
- * and few or no removals or for implementing a FIFO queue.
- *
- * A list is headed by a single forward pointer (or an array of forward
- * pointers for a hash table header). The elements are doubly linked
- * so that an arbitrary element can be removed without a need to
- * traverse the list. New elements can be added to the list before
- * or after an existing element or at the head of the list. A list
- * may be traversed in either direction.
- *
- * A tail queue is headed by a pair of pointers, one to the head of the
- * list and the other to the tail of the list. The elements are doubly
- * linked so that an arbitrary element can be removed without a need to
- * traverse the list. New elements can be added to the list before or
- * after an existing element, at the head of the list, or at the end of
- * the list. A tail queue may be traversed in either direction.
- *
- * For details on the use of these macros, see the queue(3) manual page.
- *
- *
- *				SLIST	LIST	STAILQ	TAILQ
- * _HEAD			+	+	+	+
- * _HEAD_INITIALIZER		+	+	+	+
- * _ENTRY			+	+	+	+
- * _INIT			+	+	+	+
- * _EMPTY			+	+	+	+
- * _FIRST			+	+	+	+
- * _NEXT			+	+	+	+
- * _PREV			-	+	-	+
- * _LAST			-	-	+	+
- * _FOREACH			+	+	+	+
- * _FOREACH_FROM		+	+	+	+
- * _FOREACH_SAFE		+	+	+	+
- * _FOREACH_FROM_SAFE		+	+	+	+
- * _FOREACH_REVERSE		-	-	-	+
- * _FOREACH_REVERSE_FROM	-	-	-	+
- * _FOREACH_REVERSE_SAFE	-	-	-	+
- * _FOREACH_REVERSE_FROM_SAFE	-	-	-	+
- * _INSERT_HEAD			+	+	+	+
- * _INSERT_BEFORE		-	+	-	+
- * _INSERT_AFTER		+	+	+	+
- * _INSERT_TAIL			-	-	+	+
- * _CONCAT			-	-	+	+
- * _REMOVE_AFTER		+	-	+	-
- * _REMOVE_HEAD			+	-	+	-
- * _REMOVE			+	+	+	+
- * _SWAP			+	+	+	+
- *
- */
-#ifdef QUEUE_MACRO_DEBUG
-/* Store the last 2 places the queue element or head was altered */
-struct qm_trace {
-	unsigned long	 lastline;
-	unsigned long	 prevline;
-	const char	*lastfile;
-	const char	*prevfile;
-};
-
-#define	TRACEBUF	struct qm_trace trace;
-#define	TRACEBUF_INITIALIZER	{ __FILE__, __LINE__, NULL, 0 } ,
-#define	TRASHIT(x)	do {(x) = (void *)-1;} while (0)
-#define	QMD_SAVELINK(name, link)	void **name = (void *)&(link)
-
-#define	QMD_TRACE_HEAD(head) do {					\
-	(head)->trace.prevline = (head)->trace.lastline;		\
-	(head)->trace.prevfile = (head)->trace.lastfile;		\
-	(head)->trace.lastline = __LINE__;				\
-	(head)->trace.lastfile = __FILE__;				\
-} while (0)
-
-#define	QMD_TRACE_ELEM(elem) do {					\
-	(elem)->trace.prevline = (elem)->trace.lastline;		\
-	(elem)->trace.prevfile = (elem)->trace.lastfile;		\
-	(elem)->trace.lastline = __LINE__;				\
-	(elem)->trace.lastfile = __FILE__;				\
-} while (0)
-
-#else
-#define	QMD_TRACE_ELEM(elem)
-#define	QMD_TRACE_HEAD(head)
-#define	QMD_SAVELINK(name, link)
-#define	TRACEBUF
-#define	TRACEBUF_INITIALIZER
-#define	TRASHIT(x)
-#endif	/* QUEUE_MACRO_DEBUG */
-
-/*
- * Singly-linked List declarations.
- */
-#define	SLIST_HEAD(name, type)						\
-struct name {								\
-	struct type *slh_first;	/* first element */			\
-}
-
-#define	SLIST_HEAD_INITIALIZER(head)					\
-	{ NULL }
-
-#define	SLIST_ENTRY(type)						\
-struct {								\
-	struct type *sle_next;	/* next element */			\
-}
-
-/*
- * Singly-linked List functions.
- */
-#define	SLIST_EMPTY(head)	((head)->slh_first == NULL)
-
-#define	SLIST_FIRST(head)	((head)->slh_first)
-
-#define	SLIST_FOREACH(var, head, field)					\
-	for ((var) = SLIST_FIRST((head));				\
-	    (var);							\
-	    (var) = SLIST_NEXT((var), field))
-
-#define	SLIST_FOREACH_FROM(var, head, field)				\
-	for ((var) = ((var) ? (var) : SLIST_FIRST((head)));		\
-	    (var);							\
-	    (var) = SLIST_NEXT((var), field))
-
-#define	SLIST_FOREACH_SAFE(var, head, field, tvar)			\
-	for ((var) = SLIST_FIRST((head));				\
-	    (var) && ((tvar) = SLIST_NEXT((var), field), 1);		\
-	    (var) = (tvar))
-
-#define	SLIST_FOREACH_FROM_SAFE(var, head, field, tvar)			\
-	for ((var) = ((var) ? (var) : SLIST_FIRST((head)));		\
-	    (var) && ((tvar) = SLIST_NEXT((var), field), 1);		\
-	    (var) = (tvar))
-
-#define	SLIST_FOREACH_PREVPTR(var, varp, head, field)			\
-	for ((varp) = &SLIST_FIRST((head));				\
-	    ((var) = *(varp)) != NULL;					\
-	    (varp) = &SLIST_NEXT((var), field))
-
-#define	SLIST_INIT(head) do {						\
-	SLIST_FIRST((head)) = NULL;					\
-} while (0)
-
-#define	SLIST_INSERT_AFTER(slistelm, elm, field) do {			\
-	SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field);	\
-	SLIST_NEXT((slistelm), field) = (elm);				\
-} while (0)
-
-#define	SLIST_INSERT_HEAD(head, elm, field) do {			\
-	SLIST_NEXT((elm), field) = SLIST_FIRST((head));			\
-	SLIST_FIRST((head)) = (elm);					\
-} while (0)
-
-#define	SLIST_NEXT(elm, field)	((elm)->field.sle_next)
-
-#define	SLIST_REMOVE(head, elm, type, field) do {			\
-	QMD_SAVELINK(oldnext, (elm)->field.sle_next);			\
-	if (SLIST_FIRST((head)) == (elm)) {				\
-		SLIST_REMOVE_HEAD((head), field);			\
-	}								\
-	else {								\
-		struct type *curelm = SLIST_FIRST((head));		\
-		while (SLIST_NEXT(curelm, field) != (elm))		\
-			curelm = SLIST_NEXT(curelm, field);		\
-		SLIST_REMOVE_AFTER(curelm, field);			\
-	}								\
-	TRASHIT(*oldnext);						\
-} while (0)
-
-#define SLIST_REMOVE_AFTER(elm, field) do {				\
-	SLIST_NEXT(elm, field) =					\
-	    SLIST_NEXT(SLIST_NEXT(elm, field), field);			\
-} while (0)
-
-#define	SLIST_REMOVE_HEAD(head, field) do {				\
-	SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field);	\
-} while (0)
-
-#define SLIST_SWAP(head1, head2, type) do {				\
-	struct type *swap_first = SLIST_FIRST(head1);			\
-	SLIST_FIRST(head1) = SLIST_FIRST(head2);			\
-	SLIST_FIRST(head2) = swap_first;				\
-} while (0)
-
-/*
- * Singly-linked Tail queue declarations.
- */
-#define	STAILQ_HEAD(name, type)						\
-struct name {								\
-	struct type *stqh_first;/* first element */			\
-	struct type **stqh_last;/* addr of last next element */		\
-}
-
-#define	STAILQ_HEAD_INITIALIZER(head)					\
-	{ NULL, &(head).stqh_first }
-
-#define	STAILQ_ENTRY(type)						\
-struct {								\
-	struct type *stqe_next;	/* next element */			\
-}
-
-/*
- * Singly-linked Tail queue functions.
- */
-#define	STAILQ_CONCAT(head1, head2) do {				\
-	if (!STAILQ_EMPTY((head2))) {					\
-		*(head1)->stqh_last = (head2)->stqh_first;		\
-		(head1)->stqh_last = (head2)->stqh_last;		\
-		STAILQ_INIT((head2));					\
-	}								\
-} while (0)
-
-#define	STAILQ_EMPTY(head)	((head)->stqh_first == NULL)
-
-#define	STAILQ_FIRST(head)	((head)->stqh_first)
-
-#define	STAILQ_FOREACH(var, head, field)				\
-	for((var) = STAILQ_FIRST((head));				\
-	   (var);							\
-	   (var) = STAILQ_NEXT((var), field))
-
-#define	STAILQ_FOREACH_FROM(var, head, field)				\
-	for ((var) = ((var) ? (var) : STAILQ_FIRST((head)));		\
-	   (var);							\
-	   (var) = STAILQ_NEXT((var), field))
-
-#define	STAILQ_FOREACH_SAFE(var, head, field, tvar)			\
-	for ((var) = STAILQ_FIRST((head));				\
-	    (var) && ((tvar) = STAILQ_NEXT((var), field), 1);		\
-	    (var) = (tvar))
-
-#define	STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar)		\
-	for ((var) = ((var) ? (var) : STAILQ_FIRST((head)));		\
-	    (var) && ((tvar) = STAILQ_NEXT((var), field), 1);		\
-	    (var) = (tvar))
-
-#define	STAILQ_INIT(head) do {						\
-	STAILQ_FIRST((head)) = NULL;					\
-	(head)->stqh_last = &STAILQ_FIRST((head));			\
-} while (0)
-
-#define	STAILQ_INSERT_AFTER(head, tqelm, elm, field) do {		\
-	if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
-		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
-	STAILQ_NEXT((tqelm), field) = (elm);				\
-} while (0)
-
-#define	STAILQ_INSERT_HEAD(head, elm, field) do {			\
-	if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL)	\
-		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
-	STAILQ_FIRST((head)) = (elm);					\
-} while (0)
-
-#define	STAILQ_INSERT_TAIL(head, elm, field) do {			\
-	STAILQ_NEXT((elm), field) = NULL;				\
-	*(head)->stqh_last = (elm);					\
-	(head)->stqh_last = &STAILQ_NEXT((elm), field);			\
-} while (0)
-
-#define	STAILQ_LAST(head, type, field)					\
-	(STAILQ_EMPTY((head)) ? NULL :					\
-	    __containerof((head)->stqh_last, struct type, field.stqe_next))
-
-#define	STAILQ_NEXT(elm, field)	((elm)->field.stqe_next)
-
-#define	STAILQ_REMOVE(head, elm, type, field) do {			\
-	QMD_SAVELINK(oldnext, (elm)->field.stqe_next);			\
-	if (STAILQ_FIRST((head)) == (elm)) {				\
-		STAILQ_REMOVE_HEAD((head), field);			\
-	}								\
-	else {								\
-		struct type *curelm = STAILQ_FIRST((head));		\
-		while (STAILQ_NEXT(curelm, field) != (elm))		\
-			curelm = STAILQ_NEXT(curelm, field);		\
-		STAILQ_REMOVE_AFTER(head, curelm, field);		\
-	}								\
-	TRASHIT(*oldnext);						\
-} while (0)
-
-#define STAILQ_REMOVE_AFTER(head, elm, field) do {			\
-	if ((STAILQ_NEXT(elm, field) =					\
-	     STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL)	\
-		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
-} while (0)
-
-#define	STAILQ_REMOVE_HEAD(head, field) do {				\
-	if ((STAILQ_FIRST((head)) =					\
-	     STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)		\
-		(head)->stqh_last = &STAILQ_FIRST((head));		\
-} while (0)
-
-#define STAILQ_SWAP(head1, head2, type) do {				\
-	struct type *swap_first = STAILQ_FIRST(head1);			\
-	struct type **swap_last = (head1)->stqh_last;			\
-	STAILQ_FIRST(head1) = STAILQ_FIRST(head2);			\
-	(head1)->stqh_last = (head2)->stqh_last;			\
-	STAILQ_FIRST(head2) = swap_first;				\
-	(head2)->stqh_last = swap_last;					\
-	if (STAILQ_EMPTY(head1))					\
-		(head1)->stqh_last = &STAILQ_FIRST(head1);		\
-	if (STAILQ_EMPTY(head2))					\
-		(head2)->stqh_last = &STAILQ_FIRST(head2);		\
-} while (0)
-
-
-/*
- * List declarations.
- */
-#define	LIST_HEAD(name, type)						\
-struct name {								\
-	struct type *lh_first;	/* first element */			\
-}
-
-#define	LIST_HEAD_INITIALIZER(head)					\
-	{ NULL }
-
-#define	LIST_ENTRY(type)						\
-struct {								\
-	struct type *le_next;	/* next element */			\
-	struct type **le_prev;	/* address of previous next element */	\
-}
-
-/*
- * List functions.
- */
-
-#if (defined(_KERNEL) && defined(INVARIANTS))
-#define	QMD_LIST_CHECK_HEAD(head, field) do {				\
-	if (LIST_FIRST((head)) != NULL &&				\
-	    LIST_FIRST((head))->field.le_prev !=			\
-	     &LIST_FIRST((head)))					\
-		panic("Bad list head %p first->prev != head", (head));	\
-} while (0)
-
-#define	QMD_LIST_CHECK_NEXT(elm, field) do {				\
-	if (LIST_NEXT((elm), field) != NULL &&				\
-	    LIST_NEXT((elm), field)->field.le_prev !=			\
-	     &((elm)->field.le_next))					\
-	     	panic("Bad link elm %p next->prev != elm", (elm));	\
-} while (0)
-
-#define	QMD_LIST_CHECK_PREV(elm, field) do {				\
-	if (*(elm)->field.le_prev != (elm))				\
-		panic("Bad link elm %p prev->next != elm", (elm));	\
-} while (0)
-#else
-#define	QMD_LIST_CHECK_HEAD(head, field)
-#define	QMD_LIST_CHECK_NEXT(elm, field)
-#define	QMD_LIST_CHECK_PREV(elm, field)
-#endif /* (_KERNEL && INVARIANTS) */
-
-#define	LIST_EMPTY(head)	((head)->lh_first == NULL)
-
-#define	LIST_FIRST(head)	((head)->lh_first)
-
-#define	LIST_FOREACH(var, head, field)					\
-	for ((var) = LIST_FIRST((head));				\
-	    (var);							\
-	    (var) = LIST_NEXT((var), field))
-
-#define	LIST_FOREACH_FROM(var, head, field)				\
-	for ((var) = ((var) ? (var) : LIST_FIRST((head)));		\
-	    (var);							\
-	    (var) = LIST_NEXT((var), field))
-
-#define	LIST_FOREACH_SAFE(var, head, field, tvar)			\
-	for ((var) = LIST_FIRST((head));				\
-	    (var) && ((tvar) = LIST_NEXT((var), field), 1);		\
-	    (var) = (tvar))
-
-#define	LIST_FOREACH_FROM_SAFE(var, head, field, tvar)			\
-	for ((var) = ((var) ? (var) : LIST_FIRST((head)));		\
-	    (var) && ((tvar) = LIST_NEXT((var), field), 1);		\
-	    (var) = (tvar))
-
-#define	LIST_INIT(head) do {						\
-	LIST_FIRST((head)) = NULL;					\
-} while (0)
-
-#define	LIST_INSERT_AFTER(listelm, elm, field) do {			\
-	QMD_LIST_CHECK_NEXT(listelm, field);				\
-	if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
-		LIST_NEXT((listelm), field)->field.le_prev =		\
-		    &LIST_NEXT((elm), field);				\
-	LIST_NEXT((listelm), field) = (elm);				\
-	(elm)->field.le_prev = &LIST_NEXT((listelm), field);		\
-} while (0)
-
-#define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
-	QMD_LIST_CHECK_PREV(listelm, field);				\
-	(elm)->field.le_prev = (listelm)->field.le_prev;		\
-	LIST_NEXT((elm), field) = (listelm);				\
-	*(listelm)->field.le_prev = (elm);				\
-	(listelm)->field.le_prev = &LIST_NEXT((elm), field);		\
-} while (0)
-
-#define	LIST_INSERT_HEAD(head, elm, field) do {				\
-	QMD_LIST_CHECK_HEAD((head), field);				\
-	if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL)	\
-		LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
-	LIST_FIRST((head)) = (elm);					\
-	(elm)->field.le_prev = &LIST_FIRST((head));			\
-} while (0)
-
-#define	LIST_NEXT(elm, field)	((elm)->field.le_next)
-
-#define	LIST_PREV(elm, head, type, field)				\
-	((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL :		\
-	    __containerof((elm)->field.le_prev, struct type, field.le_next))
-
-#define	LIST_REMOVE(elm, field) do {					\
-	QMD_SAVELINK(oldnext, (elm)->field.le_next);			\
-	QMD_SAVELINK(oldprev, (elm)->field.le_prev);			\
-	QMD_LIST_CHECK_NEXT(elm, field);				\
-	QMD_LIST_CHECK_PREV(elm, field);				\
-	if (LIST_NEXT((elm), field) != NULL)				\
-		LIST_NEXT((elm), field)->field.le_prev = 		\
-		    (elm)->field.le_prev;				\
-	*(elm)->field.le_prev = LIST_NEXT((elm), field);		\
-	TRASHIT(*oldnext);						\
-	TRASHIT(*oldprev);						\
-} while (0)
-
-#define LIST_SWAP(head1, head2, type, field) do {			\
-	struct type *swap_tmp = LIST_FIRST((head1));			\
-	LIST_FIRST((head1)) = LIST_FIRST((head2));			\
-	LIST_FIRST((head2)) = swap_tmp;					\
-	if ((swap_tmp = LIST_FIRST((head1))) != NULL)			\
-		swap_tmp->field.le_prev = &LIST_FIRST((head1));		\
-	if ((swap_tmp = LIST_FIRST((head2))) != NULL)			\
-		swap_tmp->field.le_prev = &LIST_FIRST((head2));		\
-} while (0)
-
-/*
- * Tail queue declarations.
- */
-#define	TAILQ_HEAD(name, type)						\
-struct name {								\
-	struct type *tqh_first;	/* first element */			\
-	struct type **tqh_last;	/* addr of last next element */		\
-	TRACEBUF							\
-}
-
-#define	TAILQ_HEAD_INITIALIZER(head)					\
-	{ NULL, &(head).tqh_first, TRACEBUF_INITIALIZER }
-
-#define	TAILQ_ENTRY(type)						\
-struct {								\
-	struct type *tqe_next;	/* next element */			\
-	struct type **tqe_prev;	/* address of previous next element */	\
-	TRACEBUF							\
-}
-
-/*
- * Tail queue functions.
- */
-#if (defined(_KERNEL) && defined(INVARIANTS))
-#define	QMD_TAILQ_CHECK_HEAD(head, field) do {				\
-	if (!TAILQ_EMPTY(head) &&					\
-	    TAILQ_FIRST((head))->field.tqe_prev !=			\
-	     &TAILQ_FIRST((head)))					\
-		panic("Bad tailq head %p first->prev != head", (head));	\
-} while (0)
-
-#define	QMD_TAILQ_CHECK_TAIL(head, field) do {				\
-	if (*(head)->tqh_last != NULL)					\
-	    	panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); 	\
-} while (0)
-
-#define	QMD_TAILQ_CHECK_NEXT(elm, field) do {				\
-	if (TAILQ_NEXT((elm), field) != NULL &&				\
-	    TAILQ_NEXT((elm), field)->field.tqe_prev !=			\
-	     &((elm)->field.tqe_next))					\
-		panic("Bad link elm %p next->prev != elm", (elm));	\
-} while (0)
-
-#define	QMD_TAILQ_CHECK_PREV(elm, field) do {				\
-	if (*(elm)->field.tqe_prev != (elm))				\
-		panic("Bad link elm %p prev->next != elm", (elm));	\
-} while (0)
-#else
-#define	QMD_TAILQ_CHECK_HEAD(head, field)
-#define	QMD_TAILQ_CHECK_TAIL(head, headname)
-#define	QMD_TAILQ_CHECK_NEXT(elm, field)
-#define	QMD_TAILQ_CHECK_PREV(elm, field)
-#endif /* (_KERNEL && INVARIANTS) */
-
-#define	TAILQ_CONCAT(head1, head2, field) do {				\
-	if (!TAILQ_EMPTY(head2)) {					\
-		*(head1)->tqh_last = (head2)->tqh_first;		\
-		(head2)->tqh_first->field.tqe_prev = (head1)->tqh_last;	\
-		(head1)->tqh_last = (head2)->tqh_last;			\
-		TAILQ_INIT((head2));					\
-		QMD_TRACE_HEAD(head1);					\
-		QMD_TRACE_HEAD(head2);					\
-	}								\
-} while (0)
-
-#define	TAILQ_EMPTY(head)	((head)->tqh_first == NULL)
-
-#define	TAILQ_FIRST(head)	((head)->tqh_first)
-
-#define	TAILQ_FOREACH(var, head, field)					\
-	for ((var) = TAILQ_FIRST((head));				\
-	    (var);							\
-	    (var) = TAILQ_NEXT((var), field))
-
-#define	TAILQ_FOREACH_FROM(var, head, field)				\
-	for ((var) = ((var) ? (var) : TAILQ_FIRST((head)));		\
-	    (var);							\
-	    (var) = TAILQ_NEXT((var), field))
-
-#define	TAILQ_FOREACH_SAFE(var, head, field, tvar)			\
-	for ((var) = TAILQ_FIRST((head));				\
-	    (var) && ((tvar) = TAILQ_NEXT((var), field), 1);		\
-	    (var) = (tvar))
-
-#define	TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar)			\
-	for ((var) = ((var) ? (var) : TAILQ_FIRST((head)));		\
-	    (var) && ((tvar) = TAILQ_NEXT((var), field), 1);		\
-	    (var) = (tvar))
-
-#define	TAILQ_FOREACH_REVERSE(var, head, headname, field)		\
-	for ((var) = TAILQ_LAST((head), headname);			\
-	    (var);							\
-	    (var) = TAILQ_PREV((var), headname, field))
-
-#define	TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field)		\
-	for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname));	\
-	    (var);							\
-	    (var) = TAILQ_PREV((var), headname, field))
-
-#define	TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)	\
-	for ((var) = TAILQ_LAST((head), headname);			\
-	    (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);	\
-	    (var) = (tvar))
-
-#define	TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar) \
-	for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname));	\
-	    (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);	\
-	    (var) = (tvar))
-
-#define	TAILQ_INIT(head) do {						\
-	TAILQ_FIRST((head)) = NULL;					\
-	(head)->tqh_last = &TAILQ_FIRST((head));			\
-	QMD_TRACE_HEAD(head);						\
-} while (0)
-
-#define	TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
-	QMD_TAILQ_CHECK_NEXT(listelm, field);				\
-	if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
-		TAILQ_NEXT((elm), field)->field.tqe_prev = 		\
-		    &TAILQ_NEXT((elm), field);				\
-	else {								\
-		(head)->tqh_last = &TAILQ_NEXT((elm), field);		\
-		QMD_TRACE_HEAD(head);					\
-	}								\
-	TAILQ_NEXT((listelm), field) = (elm);				\
-	(elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field);		\
-	QMD_TRACE_ELEM(&(elm)->field);					\
-	QMD_TRACE_ELEM(&listelm->field);				\
-} while (0)
-
-#define	TAILQ_INSERT_BEFORE(listelm, elm, field) do {			\
-	QMD_TAILQ_CHECK_PREV(listelm, field);				\
-	(elm)->field.tqe_prev = (listelm)->field.tqe_prev;		\
-	TAILQ_NEXT((elm), field) = (listelm);				\
-	*(listelm)->field.tqe_prev = (elm);				\
-	(listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field);		\
-	QMD_TRACE_ELEM(&(elm)->field);					\
-	QMD_TRACE_ELEM(&listelm->field);				\
-} while (0)
-
-#define	TAILQ_INSERT_HEAD(head, elm, field) do {			\
-	QMD_TAILQ_CHECK_HEAD(head, field);				\
-	if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL)	\
-		TAILQ_FIRST((head))->field.tqe_prev =			\
-		    &TAILQ_NEXT((elm), field);				\
-	else								\
-		(head)->tqh_last = &TAILQ_NEXT((elm), field);		\
-	TAILQ_FIRST((head)) = (elm);					\
-	(elm)->field.tqe_prev = &TAILQ_FIRST((head));			\
-	QMD_TRACE_HEAD(head);						\
-	QMD_TRACE_ELEM(&(elm)->field);					\
-} while (0)
-
-#define	TAILQ_INSERT_TAIL(head, elm, field) do {			\
-	QMD_TAILQ_CHECK_TAIL(head, field);				\
-	TAILQ_NEXT((elm), field) = NULL;				\
-	(elm)->field.tqe_prev = (head)->tqh_last;			\
-	*(head)->tqh_last = (elm);					\
-	(head)->tqh_last = &TAILQ_NEXT((elm), field);			\
-	QMD_TRACE_HEAD(head);						\
-	QMD_TRACE_ELEM(&(elm)->field);					\
-} while (0)
-
-#define	TAILQ_LAST(head, headname)					\
-	(*(((struct headname *)((head)->tqh_last))->tqh_last))
-
-#define	TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
-
-#define	TAILQ_PREV(elm, headname, field)				\
-	(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
-
-#define	TAILQ_REMOVE(head, elm, field) do {				\
-	QMD_SAVELINK(oldnext, (elm)->field.tqe_next);			\
-	QMD_SAVELINK(oldprev, (elm)->field.tqe_prev);			\
-	QMD_TAILQ_CHECK_NEXT(elm, field);				\
-	QMD_TAILQ_CHECK_PREV(elm, field);				\
-	if ((TAILQ_NEXT((elm), field)) != NULL)				\
-		TAILQ_NEXT((elm), field)->field.tqe_prev = 		\
-		    (elm)->field.tqe_prev;				\
-	else {								\
-		(head)->tqh_last = (elm)->field.tqe_prev;		\
-		QMD_TRACE_HEAD(head);					\
-	}								\
-	*(elm)->field.tqe_prev = TAILQ_NEXT((elm), field);		\
-	TRASHIT(*oldnext);						\
-	TRASHIT(*oldprev);						\
-	QMD_TRACE_ELEM(&(elm)->field);					\
-} while (0)
-
-#define TAILQ_SWAP(head1, head2, type, field) do {			\
-	struct type *swap_first = (head1)->tqh_first;			\
-	struct type **swap_last = (head1)->tqh_last;			\
-	(head1)->tqh_first = (head2)->tqh_first;			\
-	(head1)->tqh_last = (head2)->tqh_last;				\
-	(head2)->tqh_first = swap_first;				\
-	(head2)->tqh_last = swap_last;					\
-	if ((swap_first = (head1)->tqh_first) != NULL)			\
-		swap_first->field.tqe_prev = &(head1)->tqh_first;	\
-	else								\
-		(head1)->tqh_last = &(head1)->tqh_first;		\
-	if ((swap_first = (head2)->tqh_first) != NULL)			\
-		swap_first->field.tqe_prev = &(head2)->tqh_first;	\
-	else								\
-		(head2)->tqh_last = &(head2)->tqh_first;		\
-} while (0)
-
-#endif /* !_SYS_QUEUE_H_ */
Author	SHA1	Message	Date
Job Snijders	b1074667e8	Add missing closure in bird aspath output	2021-08-20 10:58:07 +00:00
Job Snijders	bdc455d72e	Update information on SOURCES	2021-08-20 10:22:19 +00:00
Job Snijders	8cc7ba2751	Bump version	2021-08-20 10:08:59 +00:00
Job Snijders	06b430b420	align bgpq4_print_cisco_aspath and bgpq4_print_cisco_oaspath	2021-08-20 03:51:51 +00:00
Job Snijders	8c51669da9	Clarify what options are mutually exclusive This fixes #20	2021-08-20 03:06:26 +00:00
Job Snijders	dc1270f10f	Improve mikrotik output This fixes #32	2021-08-20 02:44:37 +00:00
Job Snijders	362f747f0f	Let OS decide on buffer size	2021-08-20 02:10:31 +00:00
Job Snijders	6c8c6cfec1	Reduce memory usage	2021-08-20 01:58:38 +00:00
Job Snijders	fb29cd54e1	make local functions static	2021-08-20 01:12:43 +00:00
Job Snijders	903704ef3b	Update CHANGES	2021-08-20 01:03:18 +00:00
Job Snijders	b481111cf6	Replace ASN storage facility with Red Black tree macros (RB_)	2021-08-20 00:50:56 +00:00
Job Snijders	80b7dcf4de	KNF & renaming	2021-08-19 20:21:25 +00:00
Job Snijders	5ce7d7bfea	Untangle function and KNF	2021-08-19 19:59:21 +00:00
Job Snijders	8ec260f03f	chop off first and last line	2021-08-19 16:08:37 +00:00
Job Snijders	675155356d	Make note of Ben's extra aggregation trick	2021-08-19 16:02:03 +00:00
Job Snijders	da750ed48f	KNF	2021-08-19 15:39:19 +00:00
Job Snijders	7fdb481130	bump version	2021-08-19 15:31:25 +00:00
Job Snijders	fa84d146b3	Also put manpage in distribution tarball	2021-08-19 15:30:02 +00:00
Job Snijders	c90c59dba8	Update manpage and readme	2021-08-19 15:20:53 +00:00
Job Snijders	5730525f11	Fix manpage escaping	2021-08-19 15:04:07 +00:00
Job Snijders	78f57867cc	Improve manpage	2021-08-19 14:59:58 +00:00
Job Snijders	2391fdb317	Typo	2021-08-19 14:06:01 +00:00
Job Snijders	9f8d82db21	Ensure all queries end with a newline	2021-08-19 13:19:05 +00:00
Job Snijders	a6792d2495	bump version	2021-08-19 08:20:32 +00:00
Caleb Xu	af202a821b	compat: don't build when strlcpy is present (#47 )	2021-08-19 08:19:44 +00:00
Job Snijders	ed8ee8368d	Additionally add copyright file in the root directory.	2021-08-18 20:54:46 +00:00
Job Snijders	bf5f10def9	Rework where newlines are inserted	2021-08-18 16:56:13 +00:00
Job Snijders	1f7572c2f1	KNF	2021-08-18 12:28:57 +00:00
Job Snijders	34cc813446	Remove reference to bgpq4.spec	2021-08-18 10:57:49 +00:00
Job Snijders	5c57bb2bb6	Remove old spec file	2021-08-18 09:49:04 +00:00
Job Snijders	e6bf77058a	remove sx_slentry.h	2021-08-18 02:05:40 +00:00
Job Snijders	139e0d972b	include stdio	2021-08-18 02:01:03 +00:00
Job Snijders	99f036b186	KNF	2021-08-18 01:58:47 +00:00
Job Snijders	cb98214f0c	remove stale comment	2021-08-18 01:38:47 +00:00
Job Snijders	ed28cf6734	Update README	2021-08-18 01:31:25 +00:00
Job Snijders	9ac2087d24	KNF	2021-08-18 01:16:29 +00:00
Job Snijders	58adb550bd	KNF	2021-08-18 00:50:22 +00:00
Job Snijders	773849fc3a	Release 0.0.9	2021-08-18 00:46:52 +00:00
Job Snijders	40656fbbbf	Clean up comments	2021-08-18 00:40:02 +00:00
Job Snijders	4a8dc682fd	Add more free() to counter memory errors	2021-08-18 00:38:44 +00:00
Job Snijders	450286a010	plug memory leaks	2021-08-18 00:18:26 +00:00
Job Snijders	a055f6f2ee	Adding a free(), KNF	2021-08-17 23:51:18 +00:00
Job Snijders	c4c5866fa3	Fold freeall functions into expander.c	2021-08-17 23:03:29 +00:00
Job Snijders	6074f816e0	rename main program and add AM conditional	2021-08-17 23:00:06 +00:00
Job Snijders	cb15aea505	Release 0.0.8	2021-08-17 22:54:15 +00:00
Job Snijders	f1a339985a	Fix SX_TEST_EBITS	2021-08-17 22:51:22 +00:00
Job Snijders	24daa48a67	Style fixes	2021-08-17 22:33:04 +00:00
Job Snijders	b21c8b30ca	remove unused includes	2021-08-17 22:23:33 +00:00
Job Snijders	270e04dd23	The string returned by inet_ntoa() resides in a static memory area	2021-08-17 22:20:16 +00:00
Job Snijders	32a3520e62	Fix -Wstrict-aliasing messages Moving from uint32 -> struct in_addr	2021-08-17 22:16:56 +00:00
Job Snijders	b816c1023b	Fix more warnings	2021-08-17 20:19:17 +00:00
Job Snijders	85d833ca48	Fix style and compiler warnings	2021-08-17 19:34:30 +00:00
Job Snijders	791f3d7790	Fixing style and compiler warnings	2021-08-17 18:03:03 +00:00
Job Snijders	6a4207f940	rename headerfile	2021-08-17 17:26:10 +00:00
Job Snijders	af10798afd	Move to Brent Cooks portable	2021-08-17 17:18:59 +00:00
Job Snijders	81112ec2de	install libtool	2021-08-17 14:36:30 +00:00
Job Snijders	08801e2068	Change macro for manpage	2021-08-17 14:30:18 +00:00
Job Snijders	b1a9f4f089	Add 0.0.7 changelog	2021-08-17 14:27:06 +00:00
Job Snijders	408b7d8852	add _null.h to include Makefile	2021-08-17 14:25:47 +00:00
Job Snijders	3754a01a2b	No need for -O0 libcompat	2021-08-17 14:22:33 +00:00
Job Snijders	8bc07f3cb0	use portability shim for string.h	2021-08-17 14:19:10 +00:00
Job Snijders	bbcd4ae18f	set libcompat_la	2021-08-17 12:52:14 +00:00
Job Snijders	f1e9242814	define bgpq4_LDADD	2021-08-17 12:50:08 +00:00
Job Snijders	222b89e631	add types.h	2021-08-17 12:36:33 +00:00
Job Snijders	ea95e6d27a	add types.h	2021-08-17 12:34:21 +00:00
Job Snijders	dc0e8c32f7	Use OpenBSD string.h	2021-08-17 12:33:00 +00:00
Job Snijders	21b574fc91	Current OpenBSD queue.h has STAILQ_	2021-08-17 12:23:50 +00:00
Job Snijders	757dc33bb0	Add compat dir to AM flags	2021-08-17 12:19:29 +00:00
Job Snijders	82146e291b	Add _null.h from OpenBSD	2021-08-17 12:14:07 +00:00
Job Snijders	ac93dcfeef	include local headers too	2021-08-17 12:11:05 +00:00
Job Snijders	e6d488ca5b	Sync with latest OpenBSD tree.h/queue.h	2021-08-17 12:11:05 +00:00
Job Snijders	dee79b0408	Sync to latest strlcpy() from OpenBSD	2021-08-17 12:11:05 +00:00
Job Snijders	6f7a8db6aa	Add m4/ dir to cleanup list	2021-08-17 12:11:05 +00:00
Job Snijders	276b2cfc52	clean up maintainer files	2021-08-17 12:11:05 +00:00
Job Snijders	82b44b1304	Add license to each individual file	2021-08-17 12:11:05 +00:00
Job Snijders	4eb9566de8	Reorganize automake	2021-08-17 12:11:05 +00:00
Job Snijders	f473454ff7	Reorganize compat dir	2021-08-17 12:11:05 +00:00
Job Snijders	16fd7f7668	move .h into include dir	2021-08-17 12:11:05 +00:00
Job Snijders	a0b9343551	Move strlcpy into compat dir	2021-08-17 12:11:05 +00:00
Job Snijders	d998a73652	KNF	2021-08-17 12:11:05 +00:00
Job Snijders	0b554d4aa1	KNF	2021-08-17 10:12:40 +00:00
Job Snijders	406b984aa4	KNF	2021-08-12 08:25:36 +00:00
Stefan Marti	c2223849fc	Huawei aspath bugfix (#44 ) * bugfix huawei input as-path * bgpq4_print_huawei_oaspath bug fix	2021-07-13 11:10:22 +00:00
Tony Lee	56432d3c74	Update bgpq4_printer.c (#43 ) Correction Juniper route filter list ouput.	2021-07-03 18:41:45 +02:00
Robert Scheck	65f157581b	Remove unused markdown check (no more bgpq4.html) (#41 )	2021-04-26 23:33:25 +00:00
Robert Scheck	d103cc6e3b	Bump version to 0.0.7 to match GitHub tags (#42 )	2021-04-26 23:33:02 +00:00