DEFINED_PHASES=setup
DEPEND=>=net-libs/libmnl-1.0.3 >=net-libs/libnfnetlink-1.0.0 virtual/pkgconfig !<sys-devel/gettext-0.18.1.1-r3 || ( >=sys-devel/automake-1.13:1.13 >=sys-devel/automake-1.15:1.15 ) >=sys-devel/autoconf-2.69 >=sys-devel/libtool-2.4
DESCRIPTION=programming interface (API) to the in-kernel connection tracking state table
EAPI=5
HOMEPAGE=http://www.netfilter.org/projects/libnetfilter_conntrack/
IUSE=static-libs
KEYWORDS=*
LICENSE=GPL-2
RDEPEND=>=net-libs/libmnl-1.0.3 >=net-libs/libnfnetlink-1.0.0
SLOT=0
SRC_URI=http://www.netfilter.org/projects/libnetfilter_conntrack/files/libnetfilter_conntrack-1.0.6.tar.bz2
_eclasses_=autotools	999c8f6cf5d91495cb0779588f20716c	eutils	06133990e861be0fe60c2b428fd025d9	libtool	52d0e17251d04645ffaa61bfdd858944	linux-info	a238cd46144175b5f6538caa13bdf180	multilib	3972ca401cf7dbb430df9995f5d8d580	toolchain-funcs	6198c04daba0e1307bd844df7d37f423	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
_md5_=bfc4cd46a2c307c0c272bd8aa120db5a
