feat: harden route discovery and session exports

Author: apple050620312

WinMTRDialog-exporter.cpp

@@ -53,6 +53,8 @@ namespace {
 	case WinMTRProbeOutcome::scheduler_skipped: return L"scheduler_skipped";
 	case WinMTRProbeOutcome::cached: return L"cached";
 	case WinMTRProbeOutcome::late_discarded: return L"late_discarded";
+	case WinMTRProbeOutcome::post_destination_discarded:
+		return L"post_destination_discarded";
 	}
 	return L"none";
 }
@@ -88,6 +90,20 @@ struct ExportRow final {
 	return result;
 }
 
+[[nodiscard]] std::wstring isoUtcTimestamp(std::uint64_t unixMilliseconds)
+{
+	if (unixMilliseconds == 0) return {};
+	constexpr std::uint64_t windowsEpochOffset = 116'444'736'000'000'000ull;
+	ULARGE_INTEGER ticks{};
+	ticks.QuadPart = windowsEpochOffset + unixMilliseconds * 10'000ull;
+	FILETIME fileTime{ ticks.LowPart, ticks.HighPart };
+	SYSTEMTIME utc{};
+	if (!FileTimeToSystemTime(&fileTime, &utc)) return {};
+	return std::format(L"{:04}-{:02}-{:02}T{:02}:{:02}:{:02}.{:03}Z",
+		utc.wYear, utc.wMonth, utc.wDay, utc.wHour, utc.wMinute, utc.wSecond,
+		utc.wMilliseconds);
+}
+
 [[nodiscard]] std::wstring primaryHost(const s_nethost& hop)
 {
 	auto name = hop.getName();
@@ -138,7 +154,13 @@ struct ExportRow final {
 	const auto headers = exportHeaders();
 	const CString targetLabel = localized(IDS_EXPORT_TARGET_LABEL);
 	std::wostringstream out;
-	out << targetLabel.GetString() << L"：" << snapshot.target << L"\r\n";
+	out << targetLabel.GetString() << L"：" << snapshot.target << L"\r\n"
+		<< L"Started UTC\t" << isoUtcTimestamp(snapshot.started_at_unix_ms) << L"\r\n"
+		<< L"Ended UTC\t";
+	if (snapshot.ended_at_unix_ms != 0) {
+		out << isoUtcTimestamp(snapshot.ended_at_unix_ms);
+	}
+	out << L"\r\nDuration (ms)\t" << snapshot.duration_ms << L"\r\n";
 	for (size_t index = 0; index < headers.size(); ++index) {
 		if (index != 0) out << L'\t';
 		out << headers[index];
@@ -186,7 +208,14 @@ struct ExportRow final {
 	}
 	out << L"<h1>" << htmlEscape(reportTitle.GetString()) << L"</h1><p>"
 		<< htmlEscape(targetLabel.GetString()) << L"：<code>" << htmlEscape(snapshot.target)
-		<< L"</code></p><table><thead><tr>";
+		<< L"</code></p><dl><dt>Started UTC</dt><dd>"
+		<< isoUtcTimestamp(snapshot.started_at_unix_ms)
+		<< L"</dd><dt>Ended UTC</dt><dd>";
+	if (snapshot.ended_at_unix_ms != 0) {
+		out << isoUtcTimestamp(snapshot.ended_at_unix_ms);
+	}
+	out << L"</dd><dt>Duration (ms)</dt><dd>" << snapshot.duration_ms
+		<< L"</dd></dl><table><thead><tr>";
 	for (const auto header : headers) out << L"<th>" << header << L"</th>";
 	out << L"</tr></thead><tbody>";
 	for (const auto& row : makeRows(snapshot)) {
@@ -215,12 +244,18 @@ struct ExportRow final {
 {
 	const auto headers = exportHeaders();
 	std::wostringstream out;
+	out << L"started_at_utc,ended_at_utc,duration_ms,";
 	for (size_t index = 0; index < headers.size(); ++index) {
 		if (index != 0) out << L',';
 		out << csvCell(headers[index]);
 	}
 	out << L"\r\n";
 	for (const auto& row : makeRows(snapshot)) {
+		out << csvCell(isoUtcTimestamp(snapshot.started_at_unix_ms)) << L',';
+		if (snapshot.ended_at_unix_ms != 0) {
+			out << csvCell(isoUtcTimestamp(snapshot.ended_at_unix_ms));
+		}
+		out << L',' << snapshot.duration_ms << L',';
 		for (size_t index = 0; index < row.cells.size(); ++index) {
 			if (index != 0) out << L',';
 			out << csvCell(row.cells[index]);
@@ -258,7 +293,14 @@ struct ExportRow final {
 		<< L"\r\n  \"statistics\": {\"loss\":\"timed_out/completed\","
 		<< L"\"stddev\":\"sample_standard_deviation\","
 		<< L"\"jitter\":\"ewma_absolute_consecutive_delta_alpha_1_16\"},"
-		<< L"\r\n  \"target\": \"" << jsonEscape(snapshot.target) << L"\",\r\n  \"hops\": [";
+		<< L"\r\n  \"target\": \"" << jsonEscape(snapshot.target) << L"\","
+		<< L"\r\n  \"started_at_utc\": \""
+		<< isoUtcTimestamp(snapshot.started_at_unix_ms) << L"\","
+		<< L"\r\n  \"ended_at_utc\": ";
+	if (snapshot.ended_at_unix_ms == 0) out << L"null";
+	else out << L'\"' << isoUtcTimestamp(snapshot.ended_at_unix_ms) << L'\"';
+	out << L",\r\n  \"duration_ms\": " << snapshot.duration_ms << L','
+		<< L"\r\n  \"hops\": [";
 	for (size_t hopIndex = 0; hopIndex < snapshot.hops.size(); ++hopIndex) {
 		const auto& hop = snapshot.hops[hopIndex];
 		if (hopIndex != 0) out << L',';
@@ -276,6 +318,8 @@ struct ExportRow final {
 			<< L"\"scheduler_skipped\":" << hop.scheduler_skipped << L','
 			<< L"\"cache_skipped\":" << hop.cache_skipped << L','
 			<< L"\"late_completions\":" << hop.late_completions << L','
+			<< L"\"post_destination_completions\":"
+			<< hop.post_destination_completions << L','
 			<< L"\"scheduler_late_slots\":" << hop.scheduler_late_slots << L','
 			<< L"\"scheduler_lateness_total_ms\":"
 			<< hop.scheduler_lateness_total_ms << L','
@@ -296,7 +340,11 @@ struct ExportRow final {
 		for (size_t responderIndex = 0; responderIndex < hop.responders.size(); ++responderIndex) {
 			const auto& responder = hop.responders[responderIndex];
 			if (responderIndex != 0) out << L',';
-			out << L"{\"host\":\"" << jsonEscape(responder.getName()) << L"\","
+			out << L"{\"id\":\"" << std::format(L"{:016x}", responder.stable_id)
+				<< L"\","
+				<< L"\"hit_count\":" << responder.hit_count << L','
+				<< L"\"last_seen_sequence\":" << responder.last_seen_sequence << L','
+				<< L"\"host\":\"" << jsonEscape(responder.getName()) << L"\","
 				<< L"\"ip\":\"" << jsonEscape(addr_to_string(responder.addr)) << L"\","
 				<< L"\"country\":\"" << jsonEscape(responder.country) << L"\","
 				<< L"\"asn\":\"" << jsonEscape(responder.asn) << L"\","

WinMTRNet-ClassDef.ixx

@@ -54,6 +54,9 @@ export struct WinMTRTraceSnapshot final {
 	std::uint64_t session_id = 0;
 	std::uint64_t data_epoch = 0;
 	std::uint64_t revision = 0;
+	std::uint64_t started_at_unix_ms = 0;
+	std::uint64_t ended_at_unix_ms = 0;
+	std::uint64_t duration_ms = 0;
 	std::wstring target;
 	SOCKADDR_INET target_address = {};
 	ADDRESS_FAMILY address_family = AF_UNSPEC;
@@ -151,6 +154,10 @@ private:
 	std::uint64_t reply_sequence = 0;
 	std::uint64_t completed_cycles = 0;
 	std::uint64_t data_revision = 0;
+	std::uint64_t session_started_at_unix_ms = 0;
+	std::uint64_t session_ended_at_unix_ms = 0;
+	std::uint64_t session_started_tick = 0;
+	std::uint64_t session_ended_tick = 0;
 	unsigned session_start_ttl = WinMTRUtils::DEFAULT_START_TTL;
 	unsigned display_max_ttl = 0;
 	WinMTRTraceOptions session_options;
@@ -182,6 +189,8 @@ private:
 	void commitSchedulerSkipped(unsigned ttl, std::uint64_t expected_epoch) noexcept;
 	void commitCacheSkipped(unsigned ttl, std::uint64_t expected_epoch) noexcept;
 	void commitLateCompletion(unsigned ttl, std::uint64_t expected_epoch) noexcept;
+	void commitPostDestinationCompletion(unsigned ttl,
+		std::uint64_t expected_epoch) noexcept;
 	void commitReply(unsigned ttl, const SOCKADDR_INET& responder, unsigned round_trip_ms,
 		std::uint64_t cycle, std::uint64_t tick, std::uint64_t expected_session,
 		std::uint64_t expected_epoch, WinMTRProbeOutcome outcome,

WinMTRNet-Getters.cpp

@@ -46,12 +46,20 @@ WinMTRTraceSnapshot WinMTRNet::getTraceSnapshot() const
 	snapshot.session_id = session_id.load(std::memory_order_relaxed);
 	snapshot.data_epoch = data_epoch.load(std::memory_order_relaxed);
 	snapshot.revision = data_revision;
+	snapshot.started_at_unix_ms = session_started_at_unix_ms;
+	snapshot.ended_at_unix_ms = session_ended_at_unix_ms;
 	snapshot.target = target_name;
 	snapshot.target_address = last_remote_addr;
 	snapshot.address_family = last_remote_addr.si_family;
 	snapshot.start_ttl = session_start_ttl;
 	snapshot.display_max_ttl = display_max_ttl;
 	snapshot.tracing = tracing.load(std::memory_order_relaxed);
+	const auto duration_end = snapshot.tracing
+		? GetTickCount64()
+		: session_ended_tick;
+	if (session_started_tick != 0 && duration_end >= session_started_tick) {
+		snapshot.duration_ms = duration_end - session_started_tick;
+	}
 
 	if (display_max_ttl < session_start_ttl || display_max_ttl == 0) {
 		return snapshot;

WinMTRNet-Tracing.cpp

@@ -111,6 +111,12 @@ struct parsed_reply final {
 		std::chrono::steady_clock::now().time_since_epoch()).count();
 }
 
+[[nodiscard]] std::uint64_t unix_now_ms() noexcept
+{
+	return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(
+		std::chrono::system_clock::now().time_since_epoch()).count());
+}
+
 [[nodiscard]] WinMTRProbeOutcome classify_probe_outcome(DWORD status) noexcept
 {
 	switch (status) {
@@ -144,6 +150,13 @@ struct parsed_reply final {
 		&& outcome != WinMTRProbeOutcome::local_error;
 }
 
+[[nodiscard]] bool is_terminal_destination_outcome(
+	WinMTRProbeOutcome outcome) noexcept
+{
+	return outcome == WinMTRProbeOutcome::echo_reply
+		|| outcome == WinMTRProbeOutcome::destination_unreachable;
+}
+
 [[nodiscard]] std::size_t reply_buffer_size(ADDRESS_FAMILY family, std::size_t request_size) noexcept
 {
 	const auto reply_header = family == AF_INET
@@ -409,7 +422,7 @@ void CALLBACK probe_work_callback(PTP_CALLBACK_INSTANCE, void* context, PTP_WORK
 		if (is_usable_trace_reply(request->outcome)
 			&& isValidAddress(request->parsed.address)) {
 			request->completion_kind = winmtr::probe::CompletionKind::reply;
-			request->destination_reply = request->parsed.status == IP_SUCCESS
+			request->destination_reply = is_terminal_destination_outcome(request->outcome)
 				&& same_network_address(request->parsed.address, request->destination);
 		}
 		else if (request->probe.issued
@@ -515,8 +528,12 @@ WinMTRTraceResult WinMTRNet::DoTrace(std::stop_token stop_token, SOCKADDR_INET a
 	bool session_had_usable_reply = false;
 	bool stopping = false;
 	bool exploration_cycle = true;
+	bool initial_discovery = true;
 	unsigned highest_response_ttl = 0;
 	unsigned destination_ttl = 0;
+	unsigned stable_ceiling = initial_ceiling;
+	unsigned shrink_candidate = 0;
+	unsigned shrink_confirmations = 0;
 
 	const auto notify_changed = [this] {
 		if (options != nullptr) options->notifyTraceDataChanged();
@@ -540,15 +557,42 @@ WinMTRTraceResult WinMTRNet::DoTrace(std::stop_token stop_token, SOCKADDR_INET a
 					? std::max(mandatory_ttl, destination_ttl)
 					: std::min(trace_options.max_hops,
 						std::max(mandatory_ttl, tail_origin + trace_options.unknown_host_limit));
-				scheduler.set_last_ttl(normal_ceiling, monotonic_now());
+				if (initial_discovery) {
+					stable_ceiling = normal_ceiling;
+					initial_discovery = false;
+					shrink_candidate = 0;
+					shrink_confirmations = 0;
+				}
+				else if (normal_ceiling < stable_ceiling) {
+					if (shrink_candidate == normal_ceiling) {
+						++shrink_confirmations;
+					}
+					else {
+						shrink_candidate = normal_ceiling;
+						shrink_confirmations = 1;
+					}
+					if (shrink_confirmations >= WinMTRUtils::PATH_SHRINK_CONFIRMATIONS) {
+						stable_ceiling = normal_ceiling;
+						shrink_candidate = 0;
+						shrink_confirmations = 0;
+					}
+				}
+				else {
+					stable_ceiling = normal_ceiling;
+					shrink_candidate = 0;
+					shrink_confirmations = 0;
+				}
+				scheduler.set_last_ttl(stable_ceiling, monotonic_now());
 				exploration_cycle = false;
 			}
 			if (reported_cycles % WinMTRUtils::PATH_EXPLORATION_PERIOD == 0
-				&& scheduler.active_last_ttl() < trace_options.max_hops) {
+				&& stable_ceiling < trace_options.max_hops) {
 				exploration_cycle = true;
 				highest_response_ttl = 0;
 				destination_ttl = 0;
-				scheduler.set_last_ttl(trace_options.max_hops, monotonic_now());
+				const auto frontier_ceiling = std::min(trace_options.max_hops,
+					stable_ceiling + WinMTRUtils::PATH_EXPLORATION_FRONTIER_TTLS);
+				scheduler.set_last_ttl(frontier_ceiling, monotonic_now());
 			}
 		}
 	};
@@ -562,8 +606,12 @@ WinMTRTraceResult WinMTRNet::DoTrace(std::stop_token stop_token, SOCKADDR_INET a
 			session_reached_destination = false;
 			session_had_usable_reply = false;
 			exploration_cycle = true;
+			initial_discovery = true;
 			highest_response_ttl = 0;
 			destination_ttl = 0;
+			stable_ceiling = initial_ceiling;
+			shrink_candidate = 0;
+			shrink_confirmations = 0;
 			scheduler.restart(current_epoch, now);
 			scheduler.set_last_ttl(initial_ceiling, now);
 		}
@@ -573,6 +621,23 @@ WinMTRTraceResult WinMTRNet::DoTrace(std::stop_token stop_token, SOCKADDR_INET a
 			if (found == requests.end()) continue;
 			const auto disposition = scheduler.complete(request->token,
 				request->completion_kind, request->completed_at);
+			const auto accepted_after_destination = destination_ttl != 0
+				&& request->token.ttl > std::max(mandatory_ttl, destination_ttl)
+				&& (disposition == winmtr::probe::CompletionDisposition::accepted_reply
+					|| disposition == winmtr::probe::CompletionDisposition::accepted_timeout
+					|| disposition == winmtr::probe::CompletionDisposition::accepted_local_error
+					|| disposition
+						== winmtr::probe::CompletionDisposition::late_discarded_after_timeout);
+			if (accepted_after_destination) {
+				commitPostDestinationCompletion(request->token.ttl, request->token.epoch);
+				if (disposition
+					== winmtr::probe::CompletionDisposition::late_discarded_after_timeout) {
+					commitLateCompletion(request->token.ttl, request->token.epoch);
+				}
+				notify_changed();
+				requests.erase(found);
+				continue;
+			}
 			switch (disposition) {
 			case winmtr::probe::CompletionDisposition::accepted_reply: {
 				commitReply(request->token.ttl, request->parsed.address,
@@ -626,7 +691,13 @@ WinMTRTraceResult WinMTRNet::DoTrace(std::stop_token stop_token, SOCKADDR_INET a
 		}
 		if (!stopping) {
 			for (const auto& expired : scheduler.expire(now)) {
-				commitTimeout(expired.ttl, expired.epoch);
+				if (destination_ttl != 0
+					&& expired.ttl > std::max(mandatory_ttl, destination_ttl)) {
+					commitPostDestinationCompletion(expired.ttl, expired.epoch);
+				}
+				else {
+					commitTimeout(expired.ttl, expired.epoch);
+				}
 				notify_changed();
 			}
 
@@ -733,6 +804,10 @@ void WinMTRNet::beginSession(const SOCKADDR_INET& address, std::wstring target,
 	display_max_ttl = 0;
 	reply_sequence = 0;
 	completed_cycles = 0;
+	session_started_at_unix_ms = unix_now_ms();
+	session_ended_at_unix_ms = 0;
+	session_started_tick = GetTickCount64();
+	session_ended_tick = 0;
 	++data_revision;
 	for (unsigned index = 0; index < host.size(); ++index) {
 		host[index].reset(index + 1);
@@ -741,9 +816,12 @@ void WinMTRNet::beginSession(const SOCKADDR_INET& address, std::wstring target,
 
 void WinMTRNet::finishSession(std::uint64_t expected_session) noexcept
 {
-	if (session_id.load(std::memory_order_acquire) == expected_session) {
-		tracing.store(false, std::memory_order_release);
-	}
+	std::scoped_lock lock(ghMutex);
+	if (session_id.load(std::memory_order_relaxed) != expected_session) return;
+	session_ended_at_unix_ms = unix_now_ms();
+	session_ended_tick = GetTickCount64();
+	tracing.store(false, std::memory_order_release);
+	++data_revision;
 }
 
 void WinMTRNet::ResetHops() noexcept
@@ -876,6 +954,16 @@ void WinMTRNet::commitLateCompletion(unsigned ttl,
 	++data_revision;
 }
 
+void WinMTRNet::commitPostDestinationCompletion(unsigned ttl,
+	std::uint64_t expected_epoch) noexcept
+{
+	if (ttl == 0 || ttl > host.size()) return;
+	std::scoped_lock lock(ghMutex);
+	if (data_epoch.load(std::memory_order_relaxed) != expected_epoch) return;
+	host[ttl - 1].notePostDestinationCompletion();
+	++data_revision;
+}
+
 void WinMTRNet::commitReply(unsigned ttl, const SOCKADDR_INET& responder,
 	unsigned round_trip_ms, std::uint64_t cycle, std::uint64_t tick,
 	std::uint64_t expected_session, std::uint64_t expected_epoch,