import dns from 'node:dns'; import net from 'node:net'; import tls from 'node:tls'; import { performance } from 'node:perf_hooks'; const elapsed = start => Math.max(0, Math.round(performance.now() - start)); const code = error => /^[A-Z0-9_]{1,80}$/.test(error?.code ?? '') ? error.code : 'NETWORK_CHECK_FAILED'; const cancelled = signal => Object.assign(new Error('连接诊断已停止。'), { code: signal.reason?.code ?? 'DIAGNOSTIC_CANCELLED' }); export async function probeNetwork(target, profile, { signal, update, lookup = dns.lookup, ca, stageTimeoutMs = profile.connectTimeoutMs, maxAddresses = 32 } = {}) { const started = performance.now(), stages = { dns: { status: 'running', startedAt: new Date().toISOString() } }; const trials = ['auto', 'ipv4', 'ipv6'].map(mode => ({ mode, status: 'pending', stage: 'dns', attempts: [] })); let updateError; const publish = () => { try { update?.(structuredClone({ stages, trials, elapsedMs: elapsed(started) })); } catch (error) { updateError ??= error; } }; const lookupStart = performance.now(); let addresses; publish(); try { addresses = await new Promise((resolve, reject) => { let done = false; const finish = (error, value) => { if (done) return; done = true; signal?.removeEventListener('abort', abort); error ? reject(error) : resolve(value); }; const abort = () => finish(cancelled(signal)); if (signal?.aborted) { abort(); return; } signal?.addEventListener('abort', abort, { once: true }); const family = net.isIP(target.host); if (family) { finish(null, [{ address: target.host, family }]); return; } try { lookup(target.host, { all: true, verbatim: true }, (error, rows) => finish(error, rows)); } catch (error) { finish(error); } }); addresses = addresses.filter(row => [4, 6].includes(row.family) && net.isIP(row.address) === row.family).slice(0, maxAddresses); if (!addresses.length) throw Object.assign(new Error('没有可用地址。'), { code: 'DNS_NO_ADDRESSES' }); stages.dns = { ...stages.dns, status: 'passed', elapsedMs: elapsed(lookupStart), addresses }; } catch (error) { stages.dns = { ...stages.dns, status: signal?.aborted ? 'cancelled' : 'failed', elapsedMs: elapsed(lookupStart), code: code(error) }; for (const trial of trials) { trial.status = signal?.aborted ? 'cancelled' : 'skipped'; trial.code = 'DNS_NOT_COMPLETED'; } publish(); return { stages, trials, elapsedMs: elapsed(started) }; } publish(); if (updateError) throw updateError; await Promise.all(trials.map(trial => new Promise(resolve => { const candidates = trial.mode === 'auto' ? addresses : addresses.filter(row => row.family === (trial.mode === 'ipv4' ? 4 : 6)); if (!candidates.length) { trial.status = 'skipped'; trial.code = 'ADDRESS_FAMILY_UNAVAILABLE'; publish(); resolve(); return; } const began = performance.now(); let tcp, secure, timer, finished = false, tcpConnected = false, tlsStarted; const finish = (status, error) => { if (finished) return; finished = true; clearTimeout(timer); signal?.removeEventListener('abort', abort); if (trial.stage === 'tcp') trial.tcpMs = elapsed(began); else if (tlsStarted !== undefined) trial.tlsMs = elapsed(tlsStarted); trial.status = status; trial.elapsedMs = elapsed(began); if (error) trial.code = code(error); const sockets = [...new Set([secure, tcp].filter(Boolean))]; for (const socket of sockets) socket.destroy(); // A final state means owned sockets have actually closed, including cancellation. Promise.all(sockets.map(socket => socket.closed ? null : new Promise(done => socket.once('close', done)))) .then(() => { publish(); resolve(); }); }; const abort = () => finish('cancelled', cancelled(signal)); if (signal?.aborted) { abort(); return; } signal?.addEventListener('abort', abort, { once: true }); trial.status = 'running'; trial.stage = 'tcp'; publish(); if (stageTimeoutMs > 0) timer = setTimeout(() => finish('failed', { code: trial.stage === 'tcp' ? 'TCP_CONNECT_TIMEOUT' : 'TLS_HANDSHAKE_TIMEOUT' }), stageTimeoutMs); const frozenLookup = (_host, options, callback) => options.all ? callback(null, candidates) : callback(null, candidates[0].address, candidates[0].family); try { tcp = net.createConnection({ host: target.host, port: target.port, lookup: frozenLookup, autoSelectFamily: profile.autoSelectFamily, autoSelectFamilyAttemptTimeout: profile.familyAttemptTimeoutMs }); tcp.on('error', error => finish('failed', error)); tcp.on('connectionAttempt', (address, port, family) => { if (trial.attempts.length < maxAddresses) trial.attempts.push({ address, port, family }); }); tcp.on('connectionAttemptFailed', (address, _port, _family, error) => { const attempt = trial.attempts.findLast(row => row.address === address); if (attempt) attempt.code = code(error); }); tcp.once('connect', () => { if (finished) return; tcpConnected = true; trial.tcpMs = elapsed(began); trial.address = tcp.remoteAddress; trial.family = tcp.remoteFamily; if (target.scheme === 'http:') { trial.tls = 'not_applicable'; finish('passed'); return; } trial.stage = 'tls'; tlsStarted = performance.now(); publish(); try { secure = tls.connect({ socket: tcp, host: target.host, servername: net.isIP(target.host) ? undefined : target.host, rejectUnauthorized: true, ...(ca ? { ca } : {}) }); secure.on('error', error => finish('failed', error)); secure.once('secureConnect', () => { trial.certificateAuthorized = secure.authorized === true; trial.tlsProtocol = secure.getProtocol(); trial.certificateFingerprint256 = secure.getPeerCertificate().fingerprint256; finish(secure.authorized ? 'passed' : 'failed', secure.authorized ? null : { code: 'TLS_CERTIFICATE_REJECTED' }); }); } catch (error) { finish('failed', error); } }); tcp.once('close', () => { if (!finished) finish('failed', { code: tcpConnected ? 'TLS_CONNECTION_CLOSED' : 'TCP_CONNECTION_CLOSED' }); }); } catch (error) { finish('failed', error); } }))); if (updateError) throw updateError; return { stages, trials, elapsedMs: elapsed(started) }; }