BDEPEND=>=app-portage/elt-patches-20170815
DEFINED_PHASES=configure install postinst preinst prepare setup test
DEPEND=drop-root? ( sys-libs/libcap-ng ) net-libs/libpcap smi? ( net-libs/libsmi ) ssl? ( !libressl? ( >=dev-libs/openssl-0.9.6m:0= ) libressl? ( dev-libs/libressl:= ) ) drop-root? ( virtual/pkgconfig ) test? ( || ( app-arch/sharutils sys-freebsd/freebsd-ubin ) dev-lang/perl ) !<sys-devel/gettext-0.18.1.1-r3 || ( >=sys-devel/automake-1.16.1:1.16 >=sys-devel/automake-1.15.1:1.15 ) >=sys-devel/autoconf-2.69 >=sys-devel/libtool-2.4 sys-apps/baselayout
DESCRIPTION=A Tool for network monitoring and data acquisition
EAPI=7
HOMEPAGE=http://www.tcpdump.org/ https://github.com/the-tcpdump-group/tcpdump
IUSE=+drop-root libressl smi ssl samba suid test
KEYWORDS=*
LICENSE=BSD
RDEPEND=drop-root? ( sys-libs/libcap-ng ) net-libs/libpcap smi? ( net-libs/libsmi ) ssl? ( !libressl? ( >=dev-libs/openssl-0.9.6m:0= ) libressl? ( dev-libs/libressl:= ) ) sys-apps/baselayout
SLOT=0
SRC_URI=http://www.tcpdump.org/release/tcpdump-4.9.2.tar.gz
_eclasses_=autotools	d0e5375d47f4c809f406eb892e531513	eutils	06133990e861be0fe60c2b428fd025d9	flag-o-matic	5d5921a298e95441da2f85be419894c0	libtool	f143db5a74ccd9ca28c1234deffede96	multilib	b2f01ad412baf81650c23fcf0975fa33	toolchain-funcs	1e35303c63cd707f6c3422b4493d5607	user	059bd54dd6b0acf0eb8961c4ec0c2b64
_md5_=ad31722c2c652861643b832d95684a84
