[location/libloc.git] / src / python / location-query.in

#!/usr/bin/python3
###############################################################################
#                                                                             #
# libloc - A library to determine the location of someone on the Internet     #
#                                                                             #
# Copyright (C) 2017 IPFire Development Team <info@ipfire.org>                #
#                                                                             #
# This library is free software; you can redistribute it and/or               #
# modify it under the terms of the GNU Lesser General Public                  #
# License as published by the Free Software Foundation; either                #
# version 2.1 of the License, or (at your option) any later version.          #
#                                                                             #
# This library is distributed in the hope that it will be useful,             #
# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU           #
# Lesser General Public License for more details.                             #
#                                                                             #
###############################################################################

import argparse
import ipaddress
import os
import socket
import sys
import time

# Load our location module
import location
from location.i18n import _

# Output formatters

class OutputFormatter(object):
	def __init__(self, ns):
		self.ns = ns

	def __enter__(self):
		# Open the output
		self.open()

		return self

	def __exit__(self, type, value, tb):
		if tb is None:
			self.close()

	@property
	def name(self):
		if "country_code" in self.ns:
			return "networks_country_%s" % self.ns.country_code[0]

		elif "asn" in self.ns:
			return "networks_AS%s" % self.ns.asn[0]

	def open(self):
		pass

	def close(self):
		pass

	def network(self, network):
		print(network)


class IpsetOutputFormatter(OutputFormatter):
	"""
		For nftables
	"""
	def open(self):
		print("create %s hash:net family inet hashsize 1024 maxelem 65536" % self.name)

	def network(self, network):
		print("add %s %s" % (self.name, network))


class NftablesOutputFormatter(OutputFormatter):
	"""
		For nftables
	"""
	def open(self):
		print("define %s = {" % self.name)

	def close(self):
		print("}")

	def network(self, network):
		print("	%s," % network)


class XTGeoIPOutputFormatter(OutputFormatter):
	"""
		Formats the output in that way, that it can be loaded by
		the xt_geoip kernel module from xtables-addons.
	"""
	def network(self, network):
		n = ipaddress.ip_network("%s" % network)

		for address in (n.network_address, n.broadcast_address):
			bytes = socket.inet_pton(
				socket.AF_INET6 if address.version == 6 else socket.AF_INET,
				"%s" % address,
			)

			os.write(1, bytes)


class CLI(object):
	output_formats = {
		"ipset"    : IpsetOutputFormatter,
		"list"     : OutputFormatter,
		"nftables" : NftablesOutputFormatter,
		"xt_geoip" : XTGeoIPOutputFormatter,
	}

	def parse_cli(self):
		parser = argparse.ArgumentParser(
			description=_("Location Database Command Line Interface"),
		)
		subparsers = parser.add_subparsers()

		# Global configuration flags
		parser.add_argument("--debug", action="store_true",
			help=_("Enable debug output"))

		# version
		parser.add_argument("--version", action="version",
			version="%(prog)s @VERSION@")

		# database
		parser.add_argument("--database", "-d",
			default="@databasedir@/database.db", help=_("Path to database"),
		)

		# public key
		parser.add_argument("--public-key", "-k",
			default="@databasedir@/signing-key.pem", help=_("Public Signing Key"),
		)

		# lookup an IP address
		lookup = subparsers.add_parser("lookup",
			help=_("Lookup one or multiple IP addresses"),
		)
		lookup.add_argument("address", nargs="+")
		lookup.set_defaults(func=self.handle_lookup)

		# Dump the whole database
		dump = subparsers.add_parser("dump",
			help=_("Dump the entire database"),
		)
		dump.add_argument("output", nargs="?", type=argparse.FileType("w"))
		dump.set_defaults(func=self.handle_dump)

		# Get AS
		get_as = subparsers.add_parser("get-as",
			help=_("Get information about one or multiple Autonomous Systems"),
		)
		get_as.add_argument("asn", nargs="+")
		get_as.set_defaults(func=self.handle_get_as)

		# Search for AS
		search_as = subparsers.add_parser("search-as",
			help=_("Search for Autonomous Systems that match the string"),
		)
		search_as.add_argument("query", nargs=1)
		search_as.set_defaults(func=self.handle_search_as)

		# List all networks in an AS
		list_networks_by_as = subparsers.add_parser("list-networks-by-as",
			help=_("Lists all networks in an AS"),
		)
		list_networks_by_as.add_argument("asn", nargs=1, type=int)
		list_networks_by_as.add_argument("--family", choices=("ipv6", "ipv4"))
		list_networks_by_as.add_argument("--output-format",
			choices=self.output_formats.keys(), default="list")
		list_networks_by_as.set_defaults(func=self.handle_list_networks_by_as)

		# List all networks in a country
		list_networks_by_cc = subparsers.add_parser("list-networks-by-cc",
			help=_("Lists all networks in a country"),
		)
		list_networks_by_cc.add_argument("country_code", nargs=1)
		list_networks_by_cc.add_argument("--family", choices=("ipv6", "ipv4"))
		list_networks_by_cc.add_argument("--output-format",
			choices=self.output_formats.keys(), default="list")
		list_networks_by_cc.set_defaults(func=self.handle_list_networks_by_cc)

		# List all networks with flags
		list_networks_by_flags = subparsers.add_parser("list-networks-by-flags",
			help=_("Lists all networks with flags"),
		)
		list_networks_by_flags.add_argument("--anonymous-proxy",
			action="store_true", help=_("Anonymous Proxies"),
		)
		list_networks_by_flags.add_argument("--satellite-provider",
			action="store_true", help=_("Satellite Providers"),
		)
		list_networks_by_flags.add_argument("--anycast",
			action="store_true", help=_("Anycasts"),
		)
		list_networks_by_flags.add_argument("--family", choices=("ipv6", "ipv4"))
		list_networks_by_flags.add_argument("--output-format",
			choices=self.output_formats.keys(), default="list")
		list_networks_by_flags.set_defaults(func=self.handle_list_networks_by_flags)

		args = parser.parse_args()

		# Print usage if no action was given
		if not "func" in args:
			parser.print_usage()
			sys.exit(2)

		return args

	def run(self):
		# Parse command line arguments
		args = self.parse_cli()

		# Open database
		try:
			db = location.Database(args.database)
		except FileNotFoundError as e:
			sys.stderr.write("location-query: Could not open database %s: %s\n" \
				% (args.database, e))
			sys.exit(1)

		# Translate family (if present)
		if "family" in args:
			if args.family == "ipv6":
				args.family = socket.AF_INET6
			elif args.family == "ipv4":
				args.family = socket.AF_INET
			else:
				args.family = 0

		# Call function
		ret = args.func(db, args)

		# Return with exit code
		if ret:
			sys.exit(ret)

		# Otherwise just exit
		sys.exit(0)

	def handle_lookup(self, db, ns):
		ret = 0

		format = "  %-24s: %s"

		for address in ns.address:
			try:
				network = db.lookup(address)
			except ValueError:
				print(_("Invalid IP address: %s") % address, file=sys.stderr)

			args = {
				"address" : address,
				"network" : network,
			}

			# Nothing found?
			if not network:
				print(_("Nothing found for %(address)s") % args, file=sys.stderr)
				ret = 1
				continue

			print("%s:" % address)
			print(format % (_("Network"), network))

			# Print country
			if network.country_code:
				print(format % (_("Country"), network.country_code))

			# Print AS information
			if network.asn:
				autonomous_system = db.get_as(network.asn)

				print(format % (
					_("Autonomous System"),
					autonomous_system or "AS%s" % network.asn),
				)

		return ret

	def handle_dump(self, db, ns):
		# Use output file or write to stdout
		f = ns.output or sys.stdout

		# Write metadata
		f.write("#\n# Location Database Export\n#\n")

		f.write("# Generated: %s\n" % time.strftime(
			"%a, %d %b %Y %H:%M:%S GMT", time.gmtime(db.created_at),
		))

		if db.vendor:
			f.write("# Vendor:    %s\n" % db.vendor)

		if db.license:
			f.write("# License:   %s\n" % db.license)

		f.write("#\n")

		if db.description:
			for line in db.description.splitlines():
				f.write("# %s\n" % line)

			f.write("#\n")

		# Iterate over all ASes
		for a in db.ases:
			f.write("\n")
			f.write("aut-num:        AS%s\n" % a.number)
			f.write("name:           %s\n" % a.name)

		# Iterate over all networks
		for n in db.networks:
			f.write("\n")
			f.write("net:            %s\n" % n)

			if n.country_code:
				f.write("country:        %s\n" % n.country_code)

			if n.asn:
				f.write("autnum:         %s\n" % n.asn)

	def handle_get_as(self, db, ns):
		"""
			Gets information about Autonomous Systems
		"""
		ret = 0

		for asn in ns.asn:
			try:
				asn = int(asn)
			except ValueError:
				print(_("Invalid ASN: %s") % asn, file=sys.stderr)
				ret = 1
				continue

			# Fetch AS from database
			a = db.get_as(asn)

			# Nothing found
			if not a:
				print(_("Could not find AS%s") % asn, file=sys.stderr)
				ret = 1
				continue

			print(_("AS%(asn)s belongs to %(name)s") % { "asn" : a.number, "name" : a.name })

		return ret

	def handle_search_as(self, db, ns):
		for query in ns.query:
			# Print all matches ASes
			for a in db.search_as(query):
				print(a)

	def __get_output_formatter(self, ns):
		try:
			cls = self.output_formats[ns.output_format]
		except KeyError:
			cls = OutputFormatter

		return cls(ns)

	def handle_list_networks_by_as(self, db, ns):
		with self.__get_output_formatter(ns) as f:
			for asn in ns.asn:
				# Print all matching networks
				for n in db.search_networks(asn=asn, family=ns.family):
					f.network(n)

	def handle_list_networks_by_cc(self, db, ns):
		with self.__get_output_formatter(ns) as f:
			for country_code in ns.country_code:
				# Print all matching networks
				for n in db.search_networks(country_code=country_code, family=ns.family):
					f.network(n)

	def handle_list_networks_by_flags(self, db, ns):
		flags = 0

		if ns.anonymous_proxy:
			flags |= location.NETWORK_FLAG_ANONYMOUS_PROXY

		if ns.satellite_provider:
			flags |= location.NETWORK_FLAG_SATELLITE_PROVIDER

		if ns.anycast:
			flags |= location.NETWORK_FLAG_ANYCAST

		with self.__get_output_formatter(ns) as f:
			for n in db.search_networks(flags=flags, family=ns.family):
				f.network(n)


def main():
	# Run the command line interface
	c = CLI()
	c.run()

main()
Commit	Line	Data
5118a4b8 MT	1	#!/usr/bin/python3
	2	###############################################################################
	3	# #
	4	# libloc - A library to determine the location of someone on the Internet #
	5	# #
	6	# Copyright (C) 2017 IPFire Development Team <info@ipfire.org> #
	7	# #
	8	# This library is free software; you can redistribute it and/or #
	9	# modify it under the terms of the GNU Lesser General Public #
	10	# License as published by the Free Software Foundation; either #
	11	# version 2.1 of the License, or (at your option) any later version. #
	12	# #
	13	# This library is distributed in the hope that it will be useful, #
	14	# but WITHOUT ANY WARRANTY; without even the implied warranty of #
	15	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU #
	16	# Lesser General Public License for more details. #
	17	# #
	18	###############################################################################
	19
	20	import argparse
4439e317 MT	21	import ipaddress
	22	import os
	23	import socket
5118a4b8	24	import sys
a68a46f5	25	import time
5118a4b8 MT	26
	27	# Load our location module
	28	import location
7dccb767	29	from location.i18n import _
5118a4b8	30
4439e317 MT	31	# Output formatters
	32
	33	class OutputFormatter(object):
71e0ad0b MT	34	def __init__(self, ns):
	35	self.ns = ns
	36
4439e317 MT	37	def __enter__(self):
	38	# Open the output
	39	self.open()
	40
	41	return self
	42
	43	def __exit__(self, type, value, tb):
	44	if tb is None:
	45	self.close()
	46
71e0ad0b MT	47	@property
	48	def name(self):
	49	if "country_code" in self.ns:
	50	return "networks_country_%s" % self.ns.country_code[0]
	51
	52	elif "asn" in self.ns:
	53	return "networks_AS%s" % self.ns.asn[0]
	54
4439e317 MT	55	def open(self):
	56	pass
	57
	58	def close(self):
	59	pass
	60
	61	def network(self, network):
	62	print(network)
	63
	64
6da14cc1 MT	65	class IpsetOutputFormatter(OutputFormatter):
	66	"""
	67	For nftables
	68	"""
	69	def open(self):
	70	print("create %s hash:net family inet hashsize 1024 maxelem 65536" % self.name)
	71
	72	def network(self, network):
	73	print("add %s %s" % (self.name, network))
	74
	75
71e0ad0b MT	76	class NftablesOutputFormatter(OutputFormatter):
	77	"""
	78	For nftables
	79	"""
	80	def open(self):
	81	print("define %s = {" % self.name)
	82
	83	def close(self):
	84	print("}")
	85
	86	def network(self, network):
	87	print(" %s," % network)
	88
	89
4439e317 MT	90	class XTGeoIPOutputFormatter(OutputFormatter):
	91	"""
	92	Formats the output in that way, that it can be loaded by
	93	the xt_geoip kernel module from xtables-addons.
	94	"""
	95	def network(self, network):
	96	n = ipaddress.ip_network("%s" % network)
	97
	98	for address in (n.network_address, n.broadcast_address):
	99	bytes = socket.inet_pton(
	100	socket.AF_INET6 if address.version == 6 else socket.AF_INET,
	101	"%s" % address,
	102	)
	103
	104	os.write(1, bytes)
	105
	106
5118a4b8	107	class CLI(object):
4439e317	108	output_formats = {
6da14cc1	109	"ipset" : IpsetOutputFormatter,
4439e317	110	"list" : OutputFormatter,
71e0ad0b	111	"nftables" : NftablesOutputFormatter,
4439e317 MT	112	"xt_geoip" : XTGeoIPOutputFormatter,
	113	}
	114
5118a4b8 MT	115	def parse_cli(self):
	116	parser = argparse.ArgumentParser(
	117	description=_("Location Database Command Line Interface"),
	118	)
	119	subparsers = parser.add_subparsers()
	120
	121	# Global configuration flags
	122	parser.add_argument("--debug", action="store_true",
	123	help=_("Enable debug output"))
	124
ddb184be MT	125	# version
ddb184be MT	126	parser.add_argument("--version", action="version",
d2714e4a	127	version="%(prog)s @VERSION@")
ddb184be	128
2538ed9a MT	129	# database
	130	parser.add_argument("--database", "-d",
	131	default="@databasedir@/database.db", help=_("Path to database"),
	132	)
	133
726f9984 MT	134	# public key
	135	parser.add_argument("--public-key", "-k",
	136	default="@databasedir@/signing-key.pem", help=_("Public Signing Key"),
	137	)
	138
5118a4b8 MT	139	# lookup an IP address
	140	lookup = subparsers.add_parser("lookup",
	141	help=_("Lookup one or multiple IP addresses"),
	142	)
	143	lookup.add_argument("address", nargs="+")
	144	lookup.set_defaults(func=self.handle_lookup)
	145
a68a46f5 MT	146	# Dump the whole database
	147	dump = subparsers.add_parser("dump",
	148	help=_("Dump the entire database"),
	149	)
	150	dump.add_argument("output", nargs="?", type=argparse.FileType("w"))
	151	dump.set_defaults(func=self.handle_dump)
	152
fadc1af0 MT	153	# Get AS
	154	get_as = subparsers.add_parser("get-as",
	155	help=_("Get information about one or multiple Autonomous Systems"),
	156	)
	157	get_as.add_argument("asn", nargs="+")
	158	get_as.set_defaults(func=self.handle_get_as)
	159
da3e360e MT	160	# Search for AS
	161	search_as = subparsers.add_parser("search-as",
	162	help=_("Search for Autonomous Systems that match the string"),
	163	)
	164	search_as.add_argument("query", nargs=1)
	165	search_as.set_defaults(func=self.handle_search_as)
	166
43154ed7 MT	167	# List all networks in an AS
	168	list_networks_by_as = subparsers.add_parser("list-networks-by-as",
	169	help=_("Lists all networks in an AS"),
	170	)
	171	list_networks_by_as.add_argument("asn", nargs=1, type=int)
44e5ef71	172	list_networks_by_as.add_argument("--family", choices=("ipv6", "ipv4"))
4439e317 MT	173	list_networks_by_as.add_argument("--output-format",
4439e317 MT	174	choices=self.output_formats.keys(), default="list")
43154ed7 MT	175	list_networks_by_as.set_defaults(func=self.handle_list_networks_by_as)
43154ed7 MT	176
ccc7ab4e	177	# List all networks in a country
b5cdfad7	178	list_networks_by_cc = subparsers.add_parser("list-networks-by-cc",
ccc7ab4e MT	179	help=_("Lists all networks in a country"),
ccc7ab4e MT	180	)
b5cdfad7	181	list_networks_by_cc.add_argument("country_code", nargs=1)
44e5ef71	182	list_networks_by_cc.add_argument("--family", choices=("ipv6", "ipv4"))
4439e317 MT	183	list_networks_by_cc.add_argument("--output-format",
4439e317 MT	184	choices=self.output_formats.keys(), default="list")
b5cdfad7	185	list_networks_by_cc.set_defaults(func=self.handle_list_networks_by_cc)
ccc7ab4e	186
bbdb2e0a MT	187	# List all networks with flags
	188	list_networks_by_flags = subparsers.add_parser("list-networks-by-flags",
	189	help=_("Lists all networks with flags"),
	190	)
	191	list_networks_by_flags.add_argument("--anonymous-proxy",
	192	action="store_true", help=_("Anonymous Proxies"),
	193	)
	194	list_networks_by_flags.add_argument("--satellite-provider",
	195	action="store_true", help=_("Satellite Providers"),
	196	)
	197	list_networks_by_flags.add_argument("--anycast",
	198	action="store_true", help=_("Anycasts"),
	199	)
44e5ef71	200	list_networks_by_flags.add_argument("--family", choices=("ipv6", "ipv4"))
bbdb2e0a MT	201	list_networks_by_flags.add_argument("--output-format",
	202	choices=self.output_formats.keys(), default="list")
	203	list_networks_by_flags.set_defaults(func=self.handle_list_networks_by_flags)
	204
78f37815 MT	205	args = parser.parse_args()
	206
	207	# Print usage if no action was given
	208	if not "func" in args:
	209	parser.print_usage()
	210	sys.exit(2)
	211
	212	return args
5118a4b8 MT	213
	214	def run(self):
	215	# Parse command line arguments
	216	args = self.parse_cli()
	217
2538ed9a MT	218	# Open database
	219	try:
	220	db = location.Database(args.database)
	221	except FileNotFoundError as e:
	222	sys.stderr.write("location-query: Could not open database %s: %s\n" \
	223	% (args.database, e))
	224	sys.exit(1)
	225
6961aaf3 MT	226	# Translate family (if present)
	227	if "family" in args:
	228	if args.family == "ipv6":
	229	args.family = socket.AF_INET6
	230	elif args.family == "ipv4":
	231	args.family = socket.AF_INET
	232	else:
	233	args.family = 0
44e5ef71	234
5118a4b8	235	# Call function
2538ed9a	236	ret = args.func(db, args)
5118a4b8 MT	237
	238	# Return with exit code
	239	if ret:
	240	sys.exit(ret)
	241
	242	# Otherwise just exit
	243	sys.exit(0)
	244
2538ed9a	245	def handle_lookup(self, db, ns):
5118a4b8 MT	246	ret = 0
5118a4b8 MT	247
fbf925c8 MT	248	format = " %-24s: %s"
fbf925c8 MT	249
5118a4b8 MT	250	for address in ns.address:
5118a4b8 MT	251	try:
fbf925c8	252	network = db.lookup(address)
5118a4b8	253	except ValueError:
9f2f5d13	254	print(_("Invalid IP address: %s") % address, file=sys.stderr)
5118a4b8 MT	255
	256	args = {
	257	"address" : address,
fbf925c8	258	"network" : network,
5118a4b8 MT	259	}
	260
	261	# Nothing found?
fbf925c8	262	if not network:
9f2f5d13	263	print(_("Nothing found for %(address)s") % args, file=sys.stderr)
5118a4b8 MT	264	ret = 1
	265	continue
	266
fbf925c8 MT	267	print("%s:" % address)
fbf925c8 MT	268	print(format % (_("Network"), network))
5118a4b8	269
fbf925c8 MT	270	# Print country
	271	if network.country_code:
	272	print(format % (_("Country"), network.country_code))
5118a4b8	273
fbf925c8 MT	274	# Print AS information
	275	if network.asn:
	276	autonomous_system = db.get_as(network.asn)
5118a4b8	277
fbf925c8 MT	278	print(format % (
	279	_("Autonomous System"),
	280	autonomous_system or "AS%s" % network.asn),
	281	)
5118a4b8 MT	282
	283	return ret
	284
a68a46f5 MT	285	def handle_dump(self, db, ns):
	286	# Use output file or write to stdout
	287	f = ns.output or sys.stdout
	288
	289	# Write metadata
	290	f.write("#\n# Location Database Export\n#\n")
	291
	292	f.write("# Generated: %s\n" % time.strftime(
	293	"%a, %d %b %Y %H:%M:%S GMT", time.gmtime(db.created_at),
	294	))
	295
	296	if db.vendor:
	297	f.write("# Vendor: %s\n" % db.vendor)
	298
	299	if db.license:
	300	f.write("# License: %s\n" % db.license)
	301
	302	f.write("#\n")
	303
	304	if db.description:
	305	for line in db.description.splitlines():
	306	f.write("# %s\n" % line)
	307
	308	f.write("#\n")
	309
	310	# Iterate over all ASes
	311	for a in db.ases:
	312	f.write("\n")
	313	f.write("aut-num: AS%s\n" % a.number)
	314	f.write("name: %s\n" % a.name)
	315
	316	# Iterate over all networks
	317	for n in db.networks:
	318	f.write("\n")
	319	f.write("net: %s\n" % n)
	320
	321	if n.country_code:
	322	f.write("country: %s\n" % n.country_code)
	323
	324	if n.asn:
	325	f.write("autnum: %s\n" % n.asn)
	326
2538ed9a	327	def handle_get_as(self, db, ns):
fadc1af0 MT	328	"""
	329	Gets information about Autonomous Systems
	330	"""
	331	ret = 0
	332
	333	for asn in ns.asn:
	334	try:
	335	asn = int(asn)
	336	except ValueError:
9f2f5d13	337	print(_("Invalid ASN: %s") % asn, file=sys.stderr)
fadc1af0 MT	338	ret = 1
	339	continue
	340
	341	# Fetch AS from database
2538ed9a	342	a = db.get_as(asn)
fadc1af0 MT	343
	344	# Nothing found
	345	if not a:
9f2f5d13	346	print(_("Could not find AS%s") % asn, file=sys.stderr)
fadc1af0 MT	347	ret = 1
	348	continue
	349
	350	print(_("AS%(asn)s belongs to %(name)s") % { "asn" : a.number, "name" : a.name })
	351
	352	return ret
5118a4b8	353
2538ed9a	354	def handle_search_as(self, db, ns):
da3e360e MT	355	for query in ns.query:
da3e360e MT	356	# Print all matches ASes
2538ed9a	357	for a in db.search_as(query):
da3e360e MT	358	print(a)
da3e360e MT	359
4439e317 MT	360	def __get_output_formatter(self, ns):
	361	try:
	362	cls = self.output_formats[ns.output_format]
	363	except KeyError:
	364	cls = OutputFormatter
	365
71e0ad0b	366	return cls(ns)
4439e317	367
43154ed7	368	def handle_list_networks_by_as(self, db, ns):
4439e317 MT	369	with self.__get_output_formatter(ns) as f:
	370	for asn in ns.asn:
	371	# Print all matching networks
44e5ef71	372	for n in db.search_networks(asn=asn, family=ns.family):
4439e317	373	f.network(n)
43154ed7	374
ccc7ab4e	375	def handle_list_networks_by_cc(self, db, ns):
4439e317 MT	376	with self.__get_output_formatter(ns) as f:
	377	for country_code in ns.country_code:
	378	# Print all matching networks
44e5ef71	379	for n in db.search_networks(country_code=country_code, family=ns.family):
4439e317 MT	380	f.network(n)
4439e317 MT	381
bbdb2e0a MT	382	def handle_list_networks_by_flags(self, db, ns):
	383	flags = 0
	384
	385	if ns.anonymous_proxy:
	386	flags \|= location.NETWORK_FLAG_ANONYMOUS_PROXY
	387
	388	if ns.satellite_provider:
	389	flags \|= location.NETWORK_FLAG_SATELLITE_PROVIDER
	390
	391	if ns.anycast:
	392	flags \|= location.NETWORK_FLAG_ANYCAST
	393
	394	with self.__get_output_formatter(ns) as f:
44e5ef71	395	for n in db.search_networks(flags=flags, family=ns.family):
bbdb2e0a MT	396	f.network(n)
bbdb2e0a MT	397
ccc7ab4e	398
5118a4b8 MT	399	def main():
	400	# Run the command line interface
	401	c = CLI()
	402	c.run()
	403
	404	main()