0e31891 · hyperswarm-peer

Changed files (22) +140 -7

docs/PARITY-hyperswarm.md +35 -2

…	…	@@ -863,8 +863,41 @@ Reaching HOLEPUNCHING legitimately needs a relay, a live peer and a completed
863	863	handshake, so `DhtConnector::set_state_for_gate` exists and is named so it
864	864	cannot be mistaken for anything else. The alternative was an ungated abort path.
865	865
866		⏳ Still open from §11.1: our single 30s connect timeout against JS's staged
867		10s (open firewall) and 15s (relay). Separate change, separate gate.
	866	### 11.4 The relay stage gets JS's deadline (DONE), the open-firewall one does not
	867
	868	§11.1's table had three rows. The explicit error is §11.3. This is the relay
	869	row: hyperdht arms `c.relayTimeout = setTimeout(onabort, 15000)`
	870	(connect.js:812) when it starts talking to a relay, and we held every stage to
	871	the same 30-second wall clock. With `SWARM_MAX_PARALLEL = 3` that is one of
	872	three outbound slots spent on an unresponsive peer for twice as long as the
	873	reference, and a topic carrying stale records is exactly a supply of those.
	874
	875	`DHT_RELAY_TIMEOUT_MS = 15000` now applies to HANDSHAKING and HOLEPUNCHING,
	876	measured from `relay_since` — when the RELAY stage began, not when the attempt
	877	started, because JS's timer starts with the relay and a connection that spent
	878	twelve seconds in find_peer has not used any of its relay budget. Everything
	879	else keeps the 30s backstop, which is all the find_peer stage needs now that it
	880	is released when the query exhausts (§11.2).
	881
	882	fixed 20/20
	883	mutated 17/20 (one deadline for every stage again)
	884
	885	⚠ The open-firewall row is NOT implemented. JS's 10s `passiveConnectTimeout`
	886	(connect.js:244) applies when the remote's firewall is OPEN, and this connector
	887	does not track that state at the point the deadline would be armed. Inventing a
	888	mapping would be guessing at parity rather than achieving it, so the row stays
	889	open and stays honest.
	890
	891	⚠ Checked deliberately, not assumed: `STUCK_INITIATOR_MIN_MS` (3000) carries a
	892	comment that its dwell must sit "well under DHT_CONNECT_TIMEOUT_MS". It is still
	893	well under 15000. An odd constant in working code is usually a guard, and this
	894	one is.
	895
	896	⛔ The gate's first version failed against a working fix, for the third time in
	897	this repo's history. Earlier blocks in `test_relay_error_abort` deliberately
	898	leave connections ALIVE, and `tick()` advances every active one — so a bare
	899	failure counter attributed an older block's timeout to the new assertion. It
	900	counts failures for the attempt under test now.
868	901
869	902	## 12. Slice 8 — defect B, first half: the self-announce happened ONCE (FIXED)
870	903

src/dht_connector.cpp +20 -3

…	…	@@ -69,6 +69,7 @@ void DhtConnector::init(HyperDht dht, udx_socket_t socket, uv_loop_t *loop) {
69	69	// Initiate handshake through the relay node.
70	70	conn->handshake_id = _dht->connect(conn->remote_public_key, conn->relay_address);
71	71	conn->state = DHT_CONN_HANDSHAKING;
	72	if (conn->relay_since == 0) conn->relay_since = _now_ms;
72	73	conn->last_activity = 0; // Reset timeout.
73	74	break;
74	75	}
…	…	@@ -186,6 +187,7 @@ void DhtConnector::init(HyperDht dht, udx_socket_t socket, uv_loop_t *loop) {
186	187	// on_handshake_complete which provides the client_address
187	188	// (from relay's peerAddress). This avoids premature holepunch failure.
188	189	conn->state = DHT_CONN_HANDSHAKING;
	190	if (conn->relay_since == 0) conn->relay_since = _now_ms;
189	191	};
190	192	}
191	193
…	…	@@ -247,11 +249,17 @@ void DhtConnector::_tick_connection(DhtConnection *conn, uint64_t now_ms) {
247	249	if (conn->started_at == 0) conn->started_at = now_ms;
248	250	if (conn->last_activity == 0) conn->last_activity = now_ms;
249	251
250		// Timeout check.
	252	// Timeout check. The relay stage has JS's shorter deadline; everything else
	253	// keeps the 30s backstop, which is all the find_peer stage needs now that it
	254	// is released when the query exhausts (§11.2).
	255	const bool in_relay = (conn->state == DHT_CONN_HANDSHAKING \|\|
	256	conn->state == DHT_CONN_HOLEPUNCHING);
	257	const bool relay_expired = in_relay && conn->relay_since != 0 &&
	258	now_ms - conn->relay_since > DHT_RELAY_TIMEOUT_MS;
251	259	if (conn->state != DHT_CONN_CONNECTED &&
252		now_ms - conn->started_at > DHT_CONNECT_TIMEOUT_MS) {
	260	(relay_expired \|\| now_ms - conn->started_at > DHT_CONNECT_TIMEOUT_MS)) {
253	261	conn->state = DHT_CONN_FAILED;
254		conn->error = "connection timeout";
	262	conn->error = relay_expired ? "relay timeout" : "connection timeout";
255	263	_stats.timeouts++;
256	264	// Release random punch slot if applicable.
257	265	HolepunchStage pstage = conn->puncher.stage();
…	…	@@ -357,6 +365,7 @@ void DhtConnector::_on_handshake_complete(DhtConnection *conn, const DhtHandshak
357	365
358	366	void DhtConnector::_start_holepunch(DhtConnection *conn) {
359	367	conn->state = DHT_CONN_HOLEPUNCHING;
	368	if (conn->relay_since == 0) conn->relay_since = _now_ms;
360	369	conn->holepunch_round = 0;
361	370	conn->punch_socket = nullptr;
362	371
…	…	@@ -601,6 +610,13 @@ bool DhtConnector::set_state_for_gate(uint32_t conn_id, DhtConnectionState state
601	610	DhtConnection *conn = _find_connection(conn_id);
602	611	if (!conn) return false;
603	612	conn->state = state;
	613	// Entering a relay stage starts its clock, exactly as the real transitions
	614	// do — otherwise a gate could put a connection in HOLEPUNCHING and then
	615	// assert about a deadline that was never armed.
	616	if ((state == DHT_CONN_HANDSHAKING \|\| state == DHT_CONN_HOLEPUNCHING) &&
	617	conn->relay_since == 0) {
	618	conn->relay_since = _now_ms;
	619	}
604	620	return true;
605	621	}
606	622
…	…	@@ -873,6 +889,7 @@ DhtConnection DhtConnector::_alloc_connection(bool initiator, const uint8_t re
873	889	conn->id = ++_conn_id_counter;
874	890	conn->state = DHT_CONN_IDLE;
875	891	conn->active = true;
	892	conn->relay_since = 0;
876	893	conn->is_initiator = initiator;
877	894	memcpy(conn->remote_public_key, remote_pk, 32);
878	895	memset(&conn->relay_address, 0, sizeof(conn->relay_address));

src/dht_connector.h +22 -0

…	…	@@ -100,12 +100,34 @@ struct DhtConnection {
100	100	// Non-null if connection was established via birthday attack.
101	101	udx_socket_t *punch_socket;
102	102
	103	// When the RELAY stage began — handshake or holepunch coordination through a
	104	// DHT node. 0 until it does. See DHT_RELAY_TIMEOUT_MS.
	105	uint64_t relay_since;
	106
103	107	// Error info.
104	108	const char *error;
105	109	};
106	110
107	111	static constexpr int DHT_MAX_CONNECTIONS = 16;
108	112	static constexpr uint64_t DHT_CONNECT_TIMEOUT_MS = 30000; // 30 seconds.
	113	// ⛔ THE RELAY STAGE GETS JS'S DEADLINE, NOT THE BACKSTOP.
	114	//
	115	// hyperdht arms `c.relayTimeout = setTimeout(onabort, 15000)` (connect.js:812)
	116	// when it starts talking to a relay, and abandons the attempt there. Ours held
	117	// every stage to the same 30s wall clock, so a peer that answered the DHT and
	118	// then went quiet occupied one of SWARM_MAX_PARALLEL = 3 outbound slots for
	119	// twice as long as the reference — and a topic carrying stale announce records
	120	// is exactly a supply of those.
	121	//
	122	// Measured from when the RELAY stage began, not from when the attempt started:
	123	// JS's timer starts with the relay, and a connection that spent twelve seconds
	124	// in find_peer has not used any of its relay budget.
	125	//
	126	// ⚠ The OTHER row of PARITY §11.1's table — JS's 10s passiveConnectTimeout for
	127	// a peer whose firewall is OPEN — is NOT implemented here. It needs a firewall
	128	// state this connector does not track at that point, and inventing a mapping
	129	// for it would be guessing at parity rather than achieving it.
	130	static constexpr uint64_t DHT_RELAY_TIMEOUT_MS = 15000; // JS connect.js:812.
109	131	static constexpr uint64_t DHT_KEEPALIVE_INTERVAL_MS = 10000; // 10 seconds.
110	132	static constexpr uint64_t DHT_KEEPALIVE_TIMEOUT_MS = 30000; // 30 seconds.
111	133	static constexpr uint64_t RANDOM_PUNCH_COOLDOWN_MS = 20000; // 20 seconds between random punches.

test/test_bootstrap_ownership +0 -0