HttpService/Frontend improvements (#782)

- zenhttp: added `GetServiceUri()`/`GetExternalHost()`
  - enables code to quickly generate an externally reachable URI for a given service
- frontend: improved Uri handling (better defaults)
  - added support for 404 page (to make it easier to find a good URL)

9 files changed, 191 insertions, 35 deletions

diff --git a/src/zenhttp/httpserver.cpp b/src/zenhttp/httpserver.cpp
index f2fe4738f..3cefa0ad8 100644
--- a/src/zenhttp/httpserver.cpp
+++ b/src/zenhttp/httpserver.cpp
@@ -23,6 +23,7 @@
 #include <zencore/logging.h>
 #include <zencore/stream.h>
 #include <zencore/string.h>
+#include <zencore/system.h>
 #include <zencore/testing.h>
 #include <zencore/thread.h>
 #include <zenhttp/packageformat.h>
@@ -1014,7 +1015,28 @@ HttpRequestRouter::HandleRequest(zen::HttpServerRequest& Request)
 int
 HttpServer::Initialize(int BasePort, std::filesystem::path DataDir)
 {
-	return OnInitialize(BasePort, std::move(DataDir));
+	m_EffectivePort = OnInitialize(BasePort, std::move(DataDir));
+	m_ExternalHost	= OnGetExternalHost();
+	return m_EffectivePort;
+}
+
+std::string
+HttpServer::OnGetExternalHost() const
+{
+	return GetMachineName();
+}
+
+std::string
+HttpServer::GetServiceUri(const HttpService* Service) const
+{
+	if (Service)
+	{
+		return fmt::format("http://{}:{}{}", m_ExternalHost, m_EffectivePort, Service->BaseUri());
+	}
+	else
+	{
+		return fmt::format("http://{}:{}", m_ExternalHost, m_EffectivePort);
+	}
 }
 
 void
diff --git a/src/zenhttp/include/zenhttp/httpserver.h b/src/zenhttp/include/zenhttp/httpserver.h
index 350532126..00cbc6c14 100644
--- a/src/zenhttp/include/zenhttp/httpserver.h
+++ b/src/zenhttp/include/zenhttp/httpserver.h
@@ -219,8 +219,21 @@ public:
 	void RequestExit();
 	void Close();
 
+	/** Returns a canonical http:// URI for the given service, using the external
+	 *  IP and the port the server is actually listening on. Only valid
+	 *  after Initialize() has returned successfully.
+	 */
+	std::string GetServiceUri(const HttpService* Service) const;
+
+	/** Returns the external host string (IP or hostname) determined during Initialize().
+	 *  Only valid after Initialize() has returned successfully.
+	 */
+	std::string_view GetExternalHost() const { return m_ExternalHost; }
+
 private:
 	std::vector<HttpService*> m_KnownServices;
+	int						  m_EffectivePort = 0;
+	std::string				  m_ExternalHost;
 
 	virtual void OnRegisterService(HttpService& Service)				   = 0;
 	virtual int	 OnInitialize(int BasePort, std::filesystem::path DataDir) = 0;
@@ -228,6 +241,9 @@ private:
 	virtual void OnRun(bool IsInteractiveSession)						   = 0;
 	virtual void OnRequestExit()										   = 0;
 	virtual void OnClose()												   = 0;
+
+protected:
+	virtual std::string OnGetExternalHost() const;
 };
 
 struct HttpServerPluginConfig
diff --git a/src/zenhttp/servers/httpasio.cpp b/src/zenhttp/servers/httpasio.cpp
index fbc7fe401..0c0238886 100644
--- a/src/zenhttp/servers/httpasio.cpp
+++ b/src/zenhttp/servers/httpasio.cpp
@@ -7,6 +7,7 @@
 #include <zencore/fmtutils.h>
 #include <zencore/logging.h>
 #include <zencore/memory/llm.h>
+#include <zencore/system.h>
 #include <zencore/thread.h>
 #include <zencore/trace.h>
 #include <zencore/windows.h>
@@ -506,6 +507,8 @@ public:
 	HttpService*			   RouteRequest(std::string_view Url);
 	IHttpRequestFilter::Result FilterRequest(HttpServerRequest& Request);
 
+	bool IsLoopbackOnly() const;
+
 	asio::io_service						 m_IoService;
 	asio::io_service::work					 m_Work{m_IoService};
 	std::unique_ptr<asio_http::HttpAcceptor> m_Acceptor;
@@ -1601,7 +1604,8 @@ struct HttpAcceptor
 
 	void StopAccepting() { m_IsStopped = true; }
 
-	int GetAcceptPort() { return m_Acceptor.local_endpoint().port(); }
+	int	 GetAcceptPort() const { return m_Acceptor.local_endpoint().port(); }
+	bool IsLoopbackOnly() const { return m_Acceptor.local_endpoint().address().is_loopback(); }
 
 	bool IsValid() const { return m_IsValid; }
 
@@ -1975,6 +1979,12 @@ HttpAsioServerImpl::FilterRequest(HttpServerRequest& Request)
 	return RequestFilter->FilterRequest(Request);
 }
 
+bool
+HttpAsioServerImpl::IsLoopbackOnly() const
+{
+	return m_Acceptor && m_Acceptor->IsLoopbackOnly();
+}
+
 }  // namespace zen::asio_http
 
 //////////////////////////////////////////////////////////////////////////
@@ -1987,12 +1997,13 @@ public:
 	HttpAsioServer(const AsioConfig& Config);
 	~HttpAsioServer();
 
-	virtual void OnRegisterService(HttpService& Service) override;
-	virtual int	 OnInitialize(int BasePort, std::filesystem::path DataDir) override;
-	virtual void OnSetHttpRequestFilter(IHttpRequestFilter* RequestFilter) override;
-	virtual void OnRun(bool IsInteractiveSession) override;
-	virtual void OnRequestExit() override;
-	virtual void OnClose() override;
+	virtual void		OnRegisterService(HttpService& Service) override;
+	virtual int			OnInitialize(int BasePort, std::filesystem::path DataDir) override;
+	virtual void		OnSetHttpRequestFilter(IHttpRequestFilter* RequestFilter) override;
+	virtual void		OnRun(bool IsInteractiveSession) override;
+	virtual void		OnRequestExit() override;
+	virtual void		OnClose() override;
+	virtual std::string OnGetExternalHost() const override;
 
 private:
 	Event			 m_ShutdownEvent;
@@ -2067,6 +2078,29 @@ HttpAsioServer::OnInitialize(int BasePort, std::filesystem::path DataDir)
 	return m_BasePort;
 }
 
+std::string
+HttpAsioServer::OnGetExternalHost() const
+{
+	if (m_Impl->IsLoopbackOnly())
+	{
+		return "127.0.0.1";
+	}
+
+	// Use the UDP connect trick: connecting a UDP socket to an external address
+	// causes the OS to select the appropriate local interface without sending any data.
+	try
+	{
+		asio::io_service	  IoService;
+		asio::ip::udp::socket Sock(IoService, asio::ip::udp::v4());
+		Sock.connect(asio::ip::udp::endpoint(asio::ip::address::from_string("8.8.8.8"), 80));
+		return Sock.local_endpoint().address().to_string();
+	}
+	catch (const std::exception&)
+	{
+		return GetMachineName();
+	}
+}
+
 void
 HttpAsioServer::OnRun(bool IsInteractive)
 {
diff --git a/src/zenhttp/servers/httpmulti.cpp b/src/zenhttp/servers/httpmulti.cpp
index 310ac9dc0..584e06cbf 100644
--- a/src/zenhttp/servers/httpmulti.cpp
+++ b/src/zenhttp/servers/httpmulti.cpp
@@ -117,6 +117,16 @@ HttpMultiServer::OnClose()
 	}
 }
 
+std::string
+HttpMultiServer::OnGetExternalHost() const
+{
+	if (!m_Servers.empty())
+	{
+		return std::string(m_Servers.front()->GetExternalHost());
+	}
+	return HttpServer::OnGetExternalHost();
+}
+
 void
 HttpMultiServer::AddServer(Ref<HttpServer> Server)
 {
diff --git a/src/zenhttp/servers/httpmulti.h b/src/zenhttp/servers/httpmulti.h
index 1897587a9..97699828a 100644
--- a/src/zenhttp/servers/httpmulti.h
+++ b/src/zenhttp/servers/httpmulti.h
@@ -15,12 +15,13 @@ public:
 	HttpMultiServer();
 	~HttpMultiServer();
 
-	virtual void OnRegisterService(HttpService& Service) override;
-	virtual void OnSetHttpRequestFilter(IHttpRequestFilter* RequestFilter) override;
-	virtual int	 OnInitialize(int BasePort, std::filesystem::path DataDir) override;
-	virtual void OnRun(bool IsInteractiveSession) override;
-	virtual void OnRequestExit() override;
-	virtual void OnClose() override;
+	virtual void		OnRegisterService(HttpService& Service) override;
+	virtual void		OnSetHttpRequestFilter(IHttpRequestFilter* RequestFilter) override;
+	virtual int			OnInitialize(int BasePort, std::filesystem::path DataDir) override;
+	virtual void		OnRun(bool IsInteractiveSession) override;
+	virtual void		OnRequestExit() override;
+	virtual void		OnClose() override;
+	virtual std::string OnGetExternalHost() const override;
 
 	void AddServer(Ref<HttpServer> Server);
 
diff --git a/src/zenhttp/servers/httpsys.cpp b/src/zenhttp/servers/httpsys.cpp
index 6995ffca9..e93ae4853 100644
--- a/src/zenhttp/servers/httpsys.cpp
+++ b/src/zenhttp/servers/httpsys.cpp
@@ -12,6 +12,7 @@
 #include <zencore/memory/llm.h>
 #include <zencore/scopeguard.h>
 #include <zencore/string.h>
+#include <zencore/system.h>
 #include <zencore/timer.h>
 #include <zencore/trace.h>
 #include <zenhttp/packageformat.h>
@@ -27,6 +28,7 @@
 
 #	include <atomic>
 #	include <http.h>
+#	include <asio.hpp>	 // for resolving addresses for GetExternalHost
 
 namespace zen {
 
@@ -93,12 +95,13 @@ public:
 
 	// HttpServer interface implementation
 
-	virtual int	 OnInitialize(int BasePort, std::filesystem::path DataDir) override;
-	virtual void OnRun(bool TestMode) override;
-	virtual void OnRequestExit() override;
-	virtual void OnRegisterService(HttpService& Service) override;
-	virtual void OnSetHttpRequestFilter(IHttpRequestFilter* RequestFilter) override;
-	virtual void OnClose() override;
+	virtual int			OnInitialize(int BasePort, std::filesystem::path DataDir) override;
+	virtual void		OnRun(bool TestMode) override;
+	virtual void		OnRequestExit() override;
+	virtual void		OnRegisterService(HttpService& Service) override;
+	virtual void		OnSetHttpRequestFilter(IHttpRequestFilter* RequestFilter) override;
+	virtual void		OnClose() override;
+	virtual std::string OnGetExternalHost() const override;
 
 	WorkerThreadPool& WorkPool();
 
@@ -2290,6 +2293,40 @@ HttpSysServer::OnRequestExit()
 	m_ShutdownEvent.Set();
 }
 
+std::string
+HttpSysServer::OnGetExternalHost() const
+{
+	// Check whether we registered a public wildcard URL (http://*:port/) or fell back to loopback
+	bool IsPublic = false;
+	for (const auto& Uri : m_BaseUris)
+	{
+		if (Uri.find(L'*') != std::wstring::npos)
+		{
+			IsPublic = true;
+			break;
+		}
+	}
+
+	if (!IsPublic)
+	{
+		return "127.0.0.1";
+	}
+
+	// Use the UDP connect trick: connecting a UDP socket to an external address
+	// causes the OS to select the appropriate local interface without sending any data.
+	try
+	{
+		asio::io_service	  IoService;
+		asio::ip::udp::socket Sock(IoService, asio::ip::udp::v4());
+		Sock.connect(asio::ip::udp::endpoint(asio::ip::address::from_string("8.8.8.8"), 80));
+		return Sock.local_endpoint().address().to_string();
+	}
+	catch (const std::exception&)
+	{
+		return GetMachineName();
+	}
+}
+
 void
 HttpSysServer::OnRegisterService(HttpService& Service)
 {
diff --git a/src/zenserver/frontend/frontend.cpp b/src/zenserver/frontend/frontend.cpp
index 1cf451e91..579a65c5a 100644
--- a/src/zenserver/frontend/frontend.cpp
+++ b/src/zenserver/frontend/frontend.cpp
@@ -114,6 +114,8 @@ HttpFrontendService::HandleRequest(zen::HttpServerRequest& Request)
 {
 	using namespace std::literals;
 
+	ExtendableStringBuilder<256> UriBuilder;
+
 	std::string_view Uri = Request.RelativeUriWithExtension();
 	for (; Uri.length() > 0 && Uri[0] == '/'; Uri = Uri.substr(1))
 		;
@@ -121,6 +123,11 @@ HttpFrontendService::HandleRequest(zen::HttpServerRequest& Request)
 	{
 		Uri = "index.html"sv;
 	}
+	else if (Uri.back() == '/')
+	{
+		UriBuilder << Uri << "index.html"sv;
+		Uri = UriBuilder;
+	}
 
 	// Dismiss if the URI contains .. anywhere to prevent arbitrary file reads
 	if (Uri.find("..") != Uri.npos)
@@ -145,27 +152,47 @@ HttpFrontendService::HandleRequest(zen::HttpServerRequest& Request)
 		return Request.WriteResponse(HttpResponseCode::Forbidden);
 	}
 
-	// The given content directory overrides any zip-fs discovered in the binary
-	if (!m_Directory.empty())
-	{
-		auto		 FullPath = m_Directory / std::filesystem::path(Uri).make_preferred();
-		FileContents File	  = ReadFile(FullPath);
-
-		if (!File.ErrorCode)
+	auto WriteResponseForUri = [this,
+								&Request](std::string_view InUri, HttpResponseCode ResponseCode, HttpContentType ContentType) -> bool {
+		// The given content directory overrides any zip-fs discovered in the binary
+		if (!m_Directory.empty())
 		{
-			return Request.WriteResponse(HttpResponseCode::OK, ContentType, File.Data[0]);
+			auto		 FullPath = m_Directory / std::filesystem::path(InUri).make_preferred();
+			FileContents File	  = ReadFile(FullPath);
+
+			if (!File.ErrorCode)
+			{
+				Request.WriteResponse(ResponseCode, ContentType, File.Data[0]);
+
+				return true;
+			}
 		}
-	}
 
-	if (m_ZipFs)
-	{
-		if (IoBuffer FileBuffer = m_ZipFs->GetFile(Uri))
+		if (m_ZipFs)
 		{
-			return Request.WriteResponse(HttpResponseCode::OK, ContentType, FileBuffer);
+			if (IoBuffer FileBuffer = m_ZipFs->GetFile(InUri))
+			{
+				Request.WriteResponse(HttpResponseCode::OK, ContentType, FileBuffer);
+
+				return true;
+			}
 		}
-	}
 
-	Request.WriteResponse(HttpResponseCode::NotFound, HttpContentType::kText, "Not found"sv);
+		return false;
+	};
+
+	if (WriteResponseForUri(Uri, HttpResponseCode::OK, ContentType))
+	{
+		return;
+	}
+	else if (WriteResponseForUri("404.html"sv, HttpResponseCode::NotFound, HttpContentType::kHTML))
+	{
+		return;
+	}
+	else
+	{
+		Request.WriteResponse(HttpResponseCode::NotFound, HttpContentType::kText, "Not found"sv);
+	}
 }
 
 }  // namespace zen
diff --git a/src/zenserver/frontend/html.zip b/src/zenserver/frontend/html.zip
index d70a5a62b..3d90c18a8 100644
--- a/src/zenserver/frontend/html.zip
+++ b/src/zenserver/frontend/html.zip
diff --git a/src/zenserver/storage/zenstorageserver.cpp b/src/zenserver/storage/zenstorageserver.cpp
index ff854b72d..3d81db656 100644
--- a/src/zenserver/storage/zenstorageserver.cpp
+++ b/src/zenserver/storage/zenstorageserver.cpp
@@ -700,6 +700,15 @@ ZenStorageServer::Run()
 
 	ZEN_INFO(ZEN_APP_NAME " now running (pid: {})", GetCurrentProcessId());
 
+	if (m_FrontendService)
+	{
+		ZEN_INFO("frontend link: {}", m_Http->GetServiceUri(m_FrontendService.get()));
+	}
+	else
+	{
+		ZEN_INFO("frontend service disabled");
+	}
+
 #if ZEN_PLATFORM_WINDOWS
 	if (zen::windows::IsRunningOnWine())
 	{