client/Main: add option --resolve-forwarded-to

Author: MaxKellermann

debian/changelog

@@ -1,6 +1,6 @@
 cm4all-pond (0.33) unstable; urgency=low
 
-  * 
+  * client: add option --resolve-forwarded-to
 
  --   
 

doc/index.rst

@@ -224,6 +224,10 @@ The following command-line options are available:
 
  Show the address of the server each request was forwarded to.
 
+.. option:: --resolve-forwarded-to
+
+ Show the name of the server each request was forwarded to.
+
 .. option:: --no-referer
 
  Do not show the HTTP ``Referer`` request header.

meson.build

@@ -173,6 +173,15 @@ executable('cm4all-pond',
   install: true,
   install_dir: 'sbin')
 
+client_sources = []
+
+if avahi_dep.found()
+  client_sources += [
+    'src/client/SimpleAddressResolver.cxx',
+    'src/client/CachedAddressResolver.cxx',
+  ]
+endif
+
 executable('cm4all-pond-client',
   'src/client/Main.cxx',
   'src/client/ResultWriter.cxx',
@@ -182,6 +191,7 @@ executable('cm4all-pond-client',
   'src/client/Client.cxx',
   'src/client/Send.cxx',
   'src/client/Open.cxx',
+  client_sources,
   include_directories: inc,
   dependencies: [
     libgeoip,

src/client/CachedAddressResolver.cxx

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: BSD-2-Clause
+// Copyright CM4all GmbH
+// author: Max Kellermann <[email protected]>
+
+#include "CachedAddressResolver.hxx"
+
+const char *
+CachedAddressResolver::ResolveAddress(std::string address) noexcept
+{
+	auto i = cache.find(address);
+	if (i == cache.end()) {
+		auto name = simple.ResolveAddress(address.c_str());
+		i = cache.emplace(std::move(address), std::move(name)).first;
+	}
+
+	return i->second.empty() ? nullptr : i->second.c_str();
+}

src/client/CachedAddressResolver.hxx

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: BSD-2-Clause
+// Copyright CM4all GmbH
+// author: Max Kellermann <[email protected]>
+
+#pragma once
+
+#include "SimpleAddressResolver.hxx"
+
+#include <unordered_map>
+
+/**
+ * A caching wrapper for #SimpleAddressResolver.
+ */
+class CachedAddressResolver final {
+	SimpleAddressResolver simple;
+
+	std::unordered_map<std::string, std::string> cache;
+
+public:
+	[[gnu::pure]]
+	const char *ResolveAddress(std::string address) noexcept;
+};

src/client/Main.cxx

@@ -73,6 +73,10 @@ struct QueryOptions {
 #endif
 	bool track_visitors = false;
 	bool per_site_nested = false;
+
+#ifdef HAVE_AVAHI
+	bool resolve_forwarded_to = false;
+#endif
 };
 
 static void
@@ -211,9 +215,14 @@ ParseFilterItem(Filter &filter, PondGroupSitePayload &group_site,
 		options.track_visitors = true;
 	else if (StringIsEqual(p, "--host"))
 		options.one_line.show_host = true;
-	else if (StringIsEqual(p, "--forwarded-to"))
+	else if (StringIsEqual(p, "--forwarded-to")) {
+		options.one_line.show_forwarded_to = true;
+#ifdef HAVE_AVAHI
+	} else if (StringIsEqual(p, "--resolve-forwarded-to")) {
 		options.one_line.show_forwarded_to = true;
-	else if (StringIsEqual(p, "--no-referer"))
+		options.resolve_forwarded_to = true;
+#endif
+	} else if (StringIsEqual(p, "--no-referer"))
 		options.one_line.show_http_referer = false;
 	else if (StringIsEqual(p, "--no-agent"))
 		options.one_line.show_user_agent = false;
@@ -311,6 +320,9 @@ Query(const PondServerSpecification &server, ConstBuffer<const char *> args)
 				   geoip_v4, geoip_v6,
 #endif
 				   options.track_visitors,
+#ifdef HAVE_AVAHI
+				   options.resolve_forwarded_to,
+#endif
 				   options.one_line,
 				   options.jsonl,
 				   single_site,
@@ -575,6 +587,9 @@ try {
 			   "    [--anonymize] [--track-visitors]\n"
 			   "    [--per-site=PATH] [--per-site-file=FILENAME] [--per-site-nested]\n"
 			   "    [--host] [--forwarded-to] [--no-referer] [--no-agent]\n"
+#ifdef HAVE_AVAHI
+			   "    [--resolve-forwarded-to]\n"
+#endif
 			   "    [--iso8601]\n"
 			   "    [--jsonl]\n"
 			   "    [type=http_access|http_error|submission]\n"

src/client/ResultWriter.cxx

@@ -18,6 +18,11 @@
 #include "util/Macros.hxx"
 #include "util/SpanCast.hxx"
 
+#ifdef HAVE_AVAHI
+#include "net/HostParser.hxx"
+#include "util/StringSplit.hxx"
+#endif
+
 #include <algorithm>
 
 #include <fcntl.h>
@@ -113,6 +118,9 @@ ResultWriter::ResultWriter(bool _raw, bool _gzip,
 			   GeoIP *_geoip_v4, GeoIP *_geoip_v6,
 #endif
 			   bool _track_visitors,
+#ifdef HAVE_AVAHI
+			   bool _resolve_forwarded_to,
+#endif
 			   const Net::Log::OneLineOptions _one_line_options,
 			   bool _jsonl,
 			   bool _single_site,
@@ -126,6 +134,9 @@ ResultWriter::ResultWriter(bool _raw, bool _gzip,
 #endif
 	 per_site(_per_site, _per_site_filename, _per_site_nested),
 	 one_line_options(_one_line_options),
+#ifdef HAVE_AVAHI
+	 resolve_forwarded_to(_resolve_forwarded_to),
+#endif
 	 jsonl(_jsonl),
 	 raw(_raw), gzip(_gzip),
 	 track_visitors(_track_visitors)
@@ -174,8 +185,21 @@ ResultWriter::LookupGeoIP(const char *address) const noexcept
 #endif // HAVE_LIBGEOIP
 
 void
-ResultWriter::Append(const Net::Log::Datagram &d)
+ResultWriter::Append(Net::Log::Datagram &&d)
 {
+#ifdef HAVE_AVAHI
+	if (resolve_forwarded_to && d.forwarded_to != nullptr) {
+		/* extract the IP address, stripping the port and
+		   square brackets (IPv6) */
+		if (const auto e = ExtractHost(d.forwarded_to); !e.host.empty())
+			/* remove the scope name (IPv6) because Avahi
+			   doesn't understand it and query the Avahi
+			   address resolver */
+			if (const char *name = address_resolver.ResolveAddress(std::string{Split(e.host, '%').first}))
+				d.forwarded_to = name;
+	}
+#endif // HAVE_AVAHI
+
 	if (buffer_fill > sizeof(buffer) - 16384)
 		FlushBuffer();
 
@@ -229,7 +253,7 @@ void
 ResultWriter::Write(std::span<const std::byte> payload)
 {
 	if (per_site.IsDefined()) {
-		const auto d = Net::Log::ParseDatagram(payload);
+		auto d = Net::Log::ParseDatagram(payload);
 		if (d.site == nullptr)
 			// TODO: where to log datagrams without a site?
 			return;
@@ -285,7 +309,7 @@ ResultWriter::Write(std::span<const std::byte> payload)
 			/* skip this site */
 			return;
 
-		Append(d);
+		Append(std::move(d));
 	} else if (socket.IsDefined()) {
 		/* if fd2 is a packet socket, send raw
 		   datagrams to it */

src/client/ResultWriter.hxx

@@ -12,6 +12,10 @@
 #include "net/log/OneLine.hxx"
 #include "config.h"
 
+#ifdef HAVE_AVAHI
+#include "CachedAddressResolver.hxx"
+#endif
+
 #ifdef HAVE_LIBGEOIP
 #include <GeoIP.h>
 #endif
@@ -51,6 +55,12 @@ class ResultWriter {
 
 	Net::Log::OneLineOptions one_line_options;
 
+#ifdef HAVE_AVAHI
+	CachedAddressResolver address_resolver;
+
+	const bool resolve_forwarded_to;
+#endif // HAVE_AVAHI
+
 	const bool jsonl;
 
 	const bool raw, gzip, track_visitors;
@@ -64,6 +74,9 @@ public:
 		     GeoIP *_geoip_v4, GeoIP *_geoip_v6,
 #endif
 		     bool _track_visitors,
+#ifdef HAVE_AVAHI
+		     bool _resolve_forwarded_to,
+#endif
 		     Net::Log::OneLineOptions _one_line_options,
 		     bool _jsonl,
 		     bool _single_site,
@@ -104,5 +117,5 @@ private:
 	const char *LookupGeoIP(const char *address) const noexcept;
 #endif
 
-	void Append(const Net::Log::Datagram &d);
+	void Append(Net::Log::Datagram &&d);
 };

src/client/SimpleAddressResolver.cxx

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: BSD-2-Clause
+// Copyright CM4all GmbH
+// author: Max Kellermann <[email protected]>
+
+#include "SimpleAddressResolver.hxx"
+#include "util/PrintException.hxx"
+#include "util/ScopeExit.hxx"
+
+#include <avahi-client/lookup.h>
+
+struct SimpleAddressResolver::Data {
+	EventLoop &event_loop;
+
+	std::string name;
+
+	void Callback(AvahiResolverEvent event,
+		      const char *_name) noexcept {
+		if (event == AVAHI_RESOLVER_FOUND)
+			name = _name;
+		event_loop.Break();
+	}
+
+	static void Callback([[maybe_unused]] AvahiAddressResolver *r,
+			     [[maybe_unused]] AvahiIfIndex interface,
+			     [[maybe_unused]] AvahiProtocol protocol,
+			     AvahiResolverEvent event,
+			     [[maybe_unused]] const AvahiAddress *a,
+			     const char *name,
+			     [[maybe_unused]] AvahiLookupResultFlags flags,
+			     void *userdata) noexcept {
+		auto &data = *(Data *)userdata;
+		data.Callback(event, name);
+	}
+};
+
+std::string
+SimpleAddressResolver::ResolveAddress(const char *address_string) noexcept
+{
+	AvahiAddress address_buffer;
+
+	if (state == State::ERROR)
+		return {};
+
+	const auto *const address = avahi_address_parse(address_string,
+							AVAHI_PROTO_UNSPEC,
+							&address_buffer);
+	if (address == nullptr)
+		return {};
+
+	if (state != State::READY) {
+		/* wait until the Avahi client is connected */
+		event_loop.Run();
+		if (state != State::READY)
+			return {};
+	}
+
+	Data data{event_loop};
+	auto *const resolver =
+		avahi_address_resolver_new(avahi_client.GetClient(),
+					   AVAHI_IF_UNSPEC,
+					   AVAHI_PROTO_UNSPEC,
+					   //address->proto,
+					   address,
+					   AvahiLookupFlags{},
+					   Data::Callback, &data);
+	AtScopeExit(resolver) { avahi_address_resolver_free(resolver); };
+
+	/* wait until the Avahi address resolver finishes */
+	event_loop.Run();
+
+	return std::move(data.name);
+}
+
+void
+SimpleAddressResolver::OnAvahiConnect([[maybe_unused]] AvahiClient *client) noexcept
+{
+	state = State::READY;
+	event_loop.Break();
+}
+
+void
+SimpleAddressResolver::OnAvahiDisconnect() noexcept
+{
+	state = State::ERROR;
+	event_loop.Break();
+}
+
+bool
+SimpleAddressResolver::OnAvahiError(std::exception_ptr e) noexcept
+{
+	state = State::ERROR;
+	PrintException(std::move(e));
+	event_loop.Break();
+	return true;
+}

src/client/SimpleAddressResolver.hxx

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: BSD-2-Clause
+// Copyright CM4all GmbH
+// author: Max Kellermann <[email protected]>
+
+#pragma once
+
+#include "event/Loop.hxx"
+#include "lib/avahi/Client.hxx"
+#include "lib/avahi/ConnectionListener.hxx"
+#include "lib/avahi/ErrorHandler.hxx"
+
+#include <string>
+
+/**
+ * A simple synchronous wrapper for the Avahi address resolver.  An
+ * EventLoop is used to execute the Avahi client, and completion
+ * invokes EventLoop::Break().  This is a kludge to make the client
+ * synchronous.
+ */
+class SimpleAddressResolver final : Avahi::ConnectionListener, Avahi::ErrorHandler {
+	EventLoop event_loop;
+	Avahi::Client avahi_client{event_loop, *this};
+
+	enum class State {
+		INIT,
+		READY,
+		ERROR,
+	} state = State::INIT;
+
+	struct Data;
+
+public:
+	SimpleAddressResolver() noexcept {
+		avahi_client.AddListener(*this);
+	}
+
+	~SimpleAddressResolver() noexcept {
+		avahi_client.RemoveListener(*this);
+	}
+
+	[[gnu::pure]]
+	std::string ResolveAddress(const char *address) noexcept;
+
+private:
+	// virtual methods from class Avahi::ConnectionListener
+	void OnAvahiConnect(AvahiClient *client) noexcept override;
+	void OnAvahiDisconnect() noexcept override;
+
+	// virtual methods from class Avahi::ErrorHandler
+	bool OnAvahiError(std::exception_ptr e) noexcept override;
+};