[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"))
		parser.add_argument("--quiet", action="store_true",
			help=_("Enable quiet mode"))

		# 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"),
		)

		# Show the database version
		version = subparsers.add_parser("version",
			help=_("Show database version"))
		version.set_defaults(func=self.handle_version)

		# 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()

		# Configure logging
		if args.debug:
			location.logger.set_level(logging.DEBUG)
		elif args.quiet:
			location.logger.set_level(logging.WARNING)

		# 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_version(self, db, ns):
		"""
			Print the version of the database
		"""
		t = time.strftime(
			"%a, %d %b %Y %H:%M:%S GMT", time.gmtime(db.created_at),
		)

		print(t)

	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:
				country = db.get_country(network.country_code)

				print(format % (
					_("Country"),
					country.name if country else 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),
				)

			# Anonymous Proxy
			if network.has_flag(location.NETWORK_FLAG_ANONYMOUS_PROXY):
				print(format % (
					_("Anonymous Proxy"), _("yes"),
				))

			# Satellite Provider
			if network.has_flag(location.NETWORK_FLAG_SATELLITE_PROVIDER):
				print(format % (
					_("Satellite Provider"), _("yes"),
				))

			# Anycast
			if network.has_flag(location.NETWORK_FLAG_ANYCAST):
				print(format % (
					_("Anycast"), _("yes"),
				))

		return ret

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

		# Format everything like this
		format = "%-24s %s\n"

		# 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(format % ("aut-num:", "AS%s" % a.number))
			f.write(format % ("name:", a.name))

		flags = {
			location.NETWORK_FLAG_ANONYMOUS_PROXY    : "is-anonymous-proxy:",
			location.NETWORK_FLAG_SATELLITE_PROVIDER : "is-satellite-provider:",
			location.NETWORK_FLAG_ANYCAST            : "is-anycast:",
		}

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

			if n.country_code:
				f.write(format % ("country:", n.country_code))

			if n.asn:
				f.write(format % ("aut-num:", n.asn))

			# Print all flags
			for flag in flags:
				if n.has_flag(flag):
					f.write(format % (flags[flag], "yes"))

	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"))
bc1f5f53 MT	124	parser.add_argument("--quiet", action="store_true",
bc1f5f53 MT	125	help=_("Enable quiet mode"))
5118a4b8	126
ddb184be MT	127	# version
ddb184be MT	128	parser.add_argument("--version", action="version",
d2714e4a	129	version="%(prog)s @VERSION@")
ddb184be	130
2538ed9a MT	131	# database
	132	parser.add_argument("--database", "-d",
	133	default="@databasedir@/database.db", help=_("Path to database"),
	134	)
	135
726f9984 MT	136	# public key
	137	parser.add_argument("--public-key", "-k",
	138	default="@databasedir@/signing-key.pem", help=_("Public Signing Key"),
	139	)
	140
9f64f1eb MT	141	# Show the database version
	142	version = subparsers.add_parser("version",
	143	help=_("Show database version"))
	144	version.set_defaults(func=self.handle_version)
	145
5118a4b8 MT	146	# lookup an IP address
	147	lookup = subparsers.add_parser("lookup",
	148	help=_("Lookup one or multiple IP addresses"),
	149	)
	150	lookup.add_argument("address", nargs="+")
	151	lookup.set_defaults(func=self.handle_lookup)
	152
a68a46f5 MT	153	# Dump the whole database
	154	dump = subparsers.add_parser("dump",
	155	help=_("Dump the entire database"),
	156	)
	157	dump.add_argument("output", nargs="?", type=argparse.FileType("w"))
	158	dump.set_defaults(func=self.handle_dump)
	159
fadc1af0 MT	160	# Get AS
	161	get_as = subparsers.add_parser("get-as",
	162	help=_("Get information about one or multiple Autonomous Systems"),
	163	)
	164	get_as.add_argument("asn", nargs="+")
	165	get_as.set_defaults(func=self.handle_get_as)
	166
da3e360e MT	167	# Search for AS
	168	search_as = subparsers.add_parser("search-as",
	169	help=_("Search for Autonomous Systems that match the string"),
	170	)
	171	search_as.add_argument("query", nargs=1)
	172	search_as.set_defaults(func=self.handle_search_as)
	173
43154ed7 MT	174	# List all networks in an AS
	175	list_networks_by_as = subparsers.add_parser("list-networks-by-as",
	176	help=_("Lists all networks in an AS"),
	177	)
	178	list_networks_by_as.add_argument("asn", nargs=1, type=int)
44e5ef71	179	list_networks_by_as.add_argument("--family", choices=("ipv6", "ipv4"))
4439e317 MT	180	list_networks_by_as.add_argument("--output-format",
4439e317 MT	181	choices=self.output_formats.keys(), default="list")
43154ed7 MT	182	list_networks_by_as.set_defaults(func=self.handle_list_networks_by_as)
43154ed7 MT	183
ccc7ab4e	184	# List all networks in a country
b5cdfad7	185	list_networks_by_cc = subparsers.add_parser("list-networks-by-cc",
ccc7ab4e MT	186	help=_("Lists all networks in a country"),
ccc7ab4e MT	187	)
b5cdfad7	188	list_networks_by_cc.add_argument("country_code", nargs=1)
44e5ef71	189	list_networks_by_cc.add_argument("--family", choices=("ipv6", "ipv4"))
4439e317 MT	190	list_networks_by_cc.add_argument("--output-format",
4439e317 MT	191	choices=self.output_formats.keys(), default="list")
b5cdfad7	192	list_networks_by_cc.set_defaults(func=self.handle_list_networks_by_cc)
ccc7ab4e	193
bbdb2e0a MT	194	# List all networks with flags
	195	list_networks_by_flags = subparsers.add_parser("list-networks-by-flags",
	196	help=_("Lists all networks with flags"),
	197	)
	198	list_networks_by_flags.add_argument("--anonymous-proxy",
	199	action="store_true", help=_("Anonymous Proxies"),
	200	)
	201	list_networks_by_flags.add_argument("--satellite-provider",
	202	action="store_true", help=_("Satellite Providers"),
	203	)
	204	list_networks_by_flags.add_argument("--anycast",
	205	action="store_true", help=_("Anycasts"),
	206	)
44e5ef71	207	list_networks_by_flags.add_argument("--family", choices=("ipv6", "ipv4"))
bbdb2e0a MT	208	list_networks_by_flags.add_argument("--output-format",
	209	choices=self.output_formats.keys(), default="list")
	210	list_networks_by_flags.set_defaults(func=self.handle_list_networks_by_flags)
	211
78f37815 MT	212	args = parser.parse_args()
78f37815 MT	213
bc1f5f53	214	# Configure logging
f9de5e61 MT	215	if args.debug:
f9de5e61 MT	216	location.logger.set_level(logging.DEBUG)
bc1f5f53 MT	217	elif args.quiet:
bc1f5f53 MT	218	location.logger.set_level(logging.WARNING)
f9de5e61	219
78f37815 MT	220	# Print usage if no action was given
	221	if not "func" in args:
	222	parser.print_usage()
	223	sys.exit(2)
	224
	225	return args
5118a4b8 MT	226
	227	def run(self):
	228	# Parse command line arguments
	229	args = self.parse_cli()
	230
2538ed9a MT	231	# Open database
	232	try:
	233	db = location.Database(args.database)
	234	except FileNotFoundError as e:
	235	sys.stderr.write("location-query: Could not open database %s: %s\n" \
	236	% (args.database, e))
	237	sys.exit(1)
	238
6961aaf3 MT	239	# Translate family (if present)
	240	if "family" in args:
	241	if args.family == "ipv6":
	242	args.family = socket.AF_INET6
	243	elif args.family == "ipv4":
	244	args.family = socket.AF_INET
	245	else:
	246	args.family = 0
44e5ef71	247
5118a4b8	248	# Call function
2538ed9a	249	ret = args.func(db, args)
5118a4b8 MT	250
	251	# Return with exit code
	252	if ret:
	253	sys.exit(ret)
	254
	255	# Otherwise just exit
	256	sys.exit(0)
	257
9f64f1eb MT	258	def handle_version(self, db, ns):
	259	"""
	260	Print the version of the database
	261	"""
	262	t = time.strftime(
	263	"%a, %d %b %Y %H:%M:%S GMT", time.gmtime(db.created_at),
	264	)
	265
	266	print(t)
	267
2538ed9a	268	def handle_lookup(self, db, ns):
5118a4b8 MT	269	ret = 0
5118a4b8 MT	270
fbf925c8 MT	271	format = " %-24s: %s"
fbf925c8 MT	272
5118a4b8 MT	273	for address in ns.address:
5118a4b8 MT	274	try:
fbf925c8	275	network = db.lookup(address)
5118a4b8	276	except ValueError:
9f2f5d13	277	print(_("Invalid IP address: %s") % address, file=sys.stderr)
5118a4b8 MT	278
	279	args = {
	280	"address" : address,
fbf925c8	281	"network" : network,
5118a4b8 MT	282	}
	283
	284	# Nothing found?
fbf925c8	285	if not network:
9f2f5d13	286	print(_("Nothing found for %(address)s") % args, file=sys.stderr)
5118a4b8 MT	287	ret = 1
	288	continue
	289
fbf925c8 MT	290	print("%s:" % address)
fbf925c8 MT	291	print(format % (_("Network"), network))
5118a4b8	292
fbf925c8 MT	293	# Print country
fbf925c8 MT	294	if network.country_code:
072ca100 MT	295	country = db.get_country(network.country_code)
	296
	297	print(format % (
	298	_("Country"),
	299	country.name if country else network.country_code),
	300	)
5118a4b8	301
fbf925c8 MT	302	# Print AS information
	303	if network.asn:
	304	autonomous_system = db.get_as(network.asn)
5118a4b8	305
fbf925c8 MT	306	print(format % (
	307	_("Autonomous System"),
	308	autonomous_system or "AS%s" % network.asn),
	309	)
5118a4b8	310
ee83fe2e MT	311	# Anonymous Proxy
	312	if network.has_flag(location.NETWORK_FLAG_ANONYMOUS_PROXY):
	313	print(format % (
	314	_("Anonymous Proxy"), _("yes"),
	315	))
	316
	317	# Satellite Provider
	318	if network.has_flag(location.NETWORK_FLAG_SATELLITE_PROVIDER):
	319	print(format % (
	320	_("Satellite Provider"), _("yes"),
	321	))
	322
	323	# Anycast
	324	if network.has_flag(location.NETWORK_FLAG_ANYCAST):
	325	print(format % (
	326	_("Anycast"), _("yes"),
	327	))
	328
5118a4b8 MT	329	return ret
5118a4b8 MT	330
a68a46f5 MT	331	def handle_dump(self, db, ns):
	332	# Use output file or write to stdout
	333	f = ns.output or sys.stdout
	334
d6d06375 MT	335	# Format everything like this
	336	format = "%-24s %s\n"
	337
a68a46f5 MT	338	# Write metadata
	339	f.write("#\n# Location Database Export\n#\n")
	340
	341	f.write("# Generated: %s\n" % time.strftime(
	342	"%a, %d %b %Y %H:%M:%S GMT", time.gmtime(db.created_at),
	343	))
	344
	345	if db.vendor:
	346	f.write("# Vendor: %s\n" % db.vendor)
	347
	348	if db.license:
	349	f.write("# License: %s\n" % db.license)
	350
	351	f.write("#\n")
	352
	353	if db.description:
	354	for line in db.description.splitlines():
	355	f.write("# %s\n" % line)
	356
	357	f.write("#\n")
	358
	359	# Iterate over all ASes
	360	for a in db.ases:
	361	f.write("\n")
d6d06375 MT	362	f.write(format % ("aut-num:", "AS%s" % a.number))
	363	f.write(format % ("name:", a.name))
	364
	365	flags = {
	366	location.NETWORK_FLAG_ANONYMOUS_PROXY : "is-anonymous-proxy:",
	367	location.NETWORK_FLAG_SATELLITE_PROVIDER : "is-satellite-provider:",
	368	location.NETWORK_FLAG_ANYCAST : "is-anycast:",
	369	}
a68a46f5 MT	370
	371	# Iterate over all networks
	372	for n in db.networks:
	373	f.write("\n")
d6d06375	374	f.write(format % ("net:", n))
a68a46f5 MT	375
a68a46f5 MT	376	if n.country_code:
d6d06375	377	f.write(format % ("country:", n.country_code))
a68a46f5 MT	378
a68a46f5 MT	379	if n.asn:
03cd8096	380	f.write(format % ("aut-num:", n.asn))
d6d06375 MT	381
	382	# Print all flags
	383	for flag in flags:
	384	if n.has_flag(flag):
	385	f.write(format % (flags[flag], "yes"))
a68a46f5	386
2538ed9a	387	def handle_get_as(self, db, ns):
fadc1af0 MT	388	"""
	389	Gets information about Autonomous Systems
	390	"""
	391	ret = 0
	392
	393	for asn in ns.asn:
	394	try:
	395	asn = int(asn)
	396	except ValueError:
9f2f5d13	397	print(_("Invalid ASN: %s") % asn, file=sys.stderr)
fadc1af0 MT	398	ret = 1
	399	continue
	400
	401	# Fetch AS from database
2538ed9a	402	a = db.get_as(asn)
fadc1af0 MT	403
	404	# Nothing found
	405	if not a:
9f2f5d13	406	print(_("Could not find AS%s") % asn, file=sys.stderr)
fadc1af0 MT	407	ret = 1
	408	continue
	409
	410	print(_("AS%(asn)s belongs to %(name)s") % { "asn" : a.number, "name" : a.name })
	411
	412	return ret
5118a4b8	413
2538ed9a	414	def handle_search_as(self, db, ns):
da3e360e MT	415	for query in ns.query:
da3e360e MT	416	# Print all matches ASes
2538ed9a	417	for a in db.search_as(query):
da3e360e MT	418	print(a)
da3e360e MT	419
4439e317 MT	420	def __get_output_formatter(self, ns):
	421	try:
	422	cls = self.output_formats[ns.output_format]
	423	except KeyError:
	424	cls = OutputFormatter
	425
71e0ad0b	426	return cls(ns)
4439e317	427
43154ed7	428	def handle_list_networks_by_as(self, db, ns):
4439e317 MT	429	with self.__get_output_formatter(ns) as f:
	430	for asn in ns.asn:
	431	# Print all matching networks
44e5ef71	432	for n in db.search_networks(asn=asn, family=ns.family):
4439e317	433	f.network(n)
43154ed7	434
ccc7ab4e	435	def handle_list_networks_by_cc(self, db, ns):
4439e317 MT	436	with self.__get_output_formatter(ns) as f:
	437	for country_code in ns.country_code:
	438	# Print all matching networks
44e5ef71	439	for n in db.search_networks(country_code=country_code, family=ns.family):
4439e317 MT	440	f.network(n)
4439e317 MT	441
bbdb2e0a MT	442	def handle_list_networks_by_flags(self, db, ns):
	443	flags = 0
	444
	445	if ns.anonymous_proxy:
	446	flags \|= location.NETWORK_FLAG_ANONYMOUS_PROXY
	447
	448	if ns.satellite_provider:
	449	flags \|= location.NETWORK_FLAG_SATELLITE_PROVIDER
	450
	451	if ns.anycast:
	452	flags \|= location.NETWORK_FLAG_ANYCAST
	453
	454	with self.__get_output_formatter(ns) as f:
44e5ef71	455	for n in db.search_networks(flags=flags, family=ns.family):
bbdb2e0a MT	456	f.network(n)
bbdb2e0a MT	457
ccc7ab4e	458
5118a4b8 MT	459	def main():
	460	# Run the command line interface
	461	c = CLI()
	462	c.run()
	463
	464	main()