@serve.zone/dcrouter 18.7.1 → 18.8.1

package/ts/dns/manager.dns.ts

@@ -6,6 +6,7 @@ import {
   DnsRecordDoc,
   EmailDomainDoc,
 } from '../db/documents/index.js';
+import { DcRouterDb } from '../db/classes.dcrouter-db.js';
 import type { IDcRouterOptions } from '../classes.dcrouter.js';
 import type { IDnsProviderClient, IProviderRecord } from './providers/interfaces.js';
 import { createDnsProvider } from './providers/factory.js';
@@ -42,6 +43,10 @@ export interface IDnsRuntimeRegistration {
   origin: TDnsRuntimeRegistrationOrigin;
 }
 
+interface IDnsRuntimeRegistrationState extends IDnsRuntimeRegistration {
+  registrations: plugins.smartdns.dnsServerMod.IDnsHandlerRegistration[];
+}
+
 export interface IDnsRecordDeleteResult {
   id: string;
   success: boolean;
@@ -80,21 +85,18 @@ export class DnsManager {
    * keyed by DomainDoc.id then by `name|type`.
    *
    * Teardown must remove exactly what registration added — no more, no less.
-   * smartdns' `unregisterHandler(pattern, types)` removes *every* handler for a
-   * pattern/type pair, including the nameserver glue handlers owned by
-   * DnsServerRuntime and the global wildcard A handler. Reconstructing "would I
-   * have registered this?" at delete time is therefore unsafe: any drift in the
-   * inputs (authority changed, ownership changed, a record row vanished) makes the
-   * reconstruction tear down another owner's handlers or miss its own. Recording
-   * the actual registrations, with their origin, removes that class of bug.
+   * Every key therefore retains all SmartDNS registration handles for the RRset;
+   * the coarse `unregisterHandler(pattern, types)` API is never used. Recording
+   * the actual registrations, with their origin, prevents deletion or authority
+   * reconciliation from removing another owner's identical handler.
    */
-  private runtimeRegistrations = new Map<string, Map<string, IDnsRuntimeRegistration>>();
+  private runtimeRegistrations = new Map<string, Map<string, IDnsRuntimeRegistrationState>>();
 
   /** Serializes managed-mail reconciliation with destructive domain/provider deletion. */
   private managedMailDnsMutationChain: Promise<void> = Promise.resolve();
   private acceptsManagedMailDnsMutations = true;
 
-  /** Supplies the effective authority set (bootstrap ∪ delegation-verified). */
+  /** Supplies the delegation-verified authority set. */
   private authorityZonesResolver?: () => string[];
 
   constructor(private options: IDcRouterOptions) {}
@@ -122,31 +124,60 @@ export class DnsManager {
     name: string,
     type: TDnsRecordType,
     origin: TDnsRuntimeRegistrationOrigin,
+    registration: plugins.smartdns.dnsServerMod.IDnsHandlerRegistration,
   ): void {
     let owned = this.runtimeRegistrations.get(domainId);
     if (!owned) {
-      owned = new Map<string, IDnsRuntimeRegistration>();
+      owned = new Map<string, IDnsRuntimeRegistrationState>();
       this.runtimeRegistrations.set(domainId, owned);
     }
-    owned.set(this.rrsetKey(name, type), { name: name.toLowerCase(), type, origin });
+    const key = this.rrsetKey(name, type);
+    const existing = owned.get(key);
+    if (existing) {
+      if (existing.origin !== origin) {
+        registration.unregister();
+        throw new Error(
+          `DnsManager: cannot mix ${existing.origin} and ${origin} runtime registrations for ${name} ${type}`,
+        );
+      }
+      existing.registrations.push(registration);
+      return;
+    }
+    owned.set(key, {
+      name: name.toLowerCase(),
+      type,
+      origin,
+      registrations: [registration],
+    });
   }
 
-  private untrackRuntimeRegistration(
+  private unregisterRuntimeRegistration(
     domainId: string,
     name: string,
     type: TDnsRecordType,
-  ): void {
+  ): number {
     const owned = this.runtimeRegistrations.get(domainId);
-    if (!owned) return;
+    if (!owned) return 0;
+    const registration = owned.get(this.rrsetKey(name, type));
+    if (!registration) return 0;
     owned.delete(this.rrsetKey(name, type));
     if (owned.size === 0) {
       this.runtimeRegistrations.delete(domainId);
     }
+    let removed = 0;
+    for (const handlerRegistration of registration.registrations) {
+      if (handlerRegistration.unregister()) removed++;
+    }
+    return removed;
   }
 
   /** Registrations currently owned by a domain. Exposed for teardown assertions. */
   public listRuntimeRegistrations(domainId: string): IDnsRuntimeRegistration[] {
-    return [...(this.runtimeRegistrations.get(domainId)?.values() || [])];
+    return [...(this.runtimeRegistrations.get(domainId)?.values() || [])].map((registration) => ({
+      name: registration.name,
+      type: registration.type,
+      origin: registration.origin,
+    }));
   }
 
   /**
@@ -163,19 +194,22 @@ export class DnsManager {
   private tearDownDomainRuntimeRegistrations(domainId: string): void {
     const owned = this.runtimeRegistrations.get(domainId);
     this.runtimeRegistrations.delete(domainId);
-    if (!owned || !this.dnsServer) {
+    if (!owned) {
       return;
     }
     const generatedZones: string[] = [];
+    let removedHandlers = 0;
     for (const registration of owned.values()) {
-      this.dnsServer.unregisterHandler(registration.name, [registration.type]);
+      for (const handlerRegistration of registration.registrations) {
+        if (handlerRegistration.unregister()) removedHandlers++;
+      }
       if (registration.origin === 'generated-default') {
         generatedZones.push(`${registration.name} ${registration.type}`);
       }
     }
     logger.log(
       'info',
-      `DnsManager: unregistered ${owned.size} runtime DNS handler key(s) for domain ${domainId}`
+      `DnsManager: unregistered ${removedHandlers} runtime DNS handler(s) across ${owned.size} key(s) for domain ${domainId}`
         + (generatedZones.length ? `, including generated default(s) ${generatedZones.join(', ')}` : ''),
       { zone: 'dns', domainId },
     );
@@ -194,8 +228,7 @@ export class DnsManager {
     this.acceptsManagedMailDnsMutations = false;
     await this.managedMailDnsMutationChain;
     this.providerClients.clear();
-    this.runtimeRegistrations.clear();
-    this.dnsServer = undefined;
+    this.detachDnsServer();
   }
 
   /**
@@ -204,8 +237,26 @@ export class DnsManager {
    * dcrouter-hosted domains loaded from the DB are registered with the server.
    */
   public async attachDnsServer(dnsServer: plugins.smartdns.dnsServerMod.DnsServer): Promise<void> {
+    if (this.dnsServer === dnsServer) return;
+    this.detachDnsServer();
     this.dnsServer = dnsServer;
-    await this.applyDcrouterDomainsToDnsServer();
+    try {
+      await this.applyDcrouterDomainsToDnsServer();
+    } catch (error) {
+      this.detachDnsServer(dnsServer);
+      throw error;
+    }
+  }
+
+  /** Remove manager-owned handlers from the current server before replacement or shutdown. */
+  public detachDnsServer(expectedServerArg?: plugins.smartdns.dnsServerMod.DnsServer): boolean {
+    if (expectedServerArg && this.dnsServer !== expectedServerArg) return false;
+    for (const domainId of [...this.runtimeRegistrations.keys()]) {
+      this.tearDownDomainRuntimeRegistrations(domainId);
+    }
+    this.runtimeRegistrations.clear();
+    this.dnsServer = undefined;
+    return true;
   }
 
   // ==========================================================================
@@ -254,10 +305,9 @@ export class DnsManager {
    * bootstrap `dnsScopes` zones, which could neither appear for a zone verified
    * after startup nor disappear for one whose authority was revoked.
    *
-   * Ownership is verified first. smartdns marks any answer a registered handler
-   * produces as authoritative (`aa`) regardless of `authoritativeZones`, so
-   * registering this handler for a zone we cannot prove we own makes dcrouter
-   * publicly claim authority over somebody else's domain.
+   * Ownership is verified first. SmartDNS suppresses default-authority handlers
+   * outside the live authority set, and a zone only enters that set after its
+   * delegation is proven, so registration and authority use the same evidence.
    */
   private async registerAuthoritativeZoneDefaults(
     domain: DomainDoc,
@@ -288,7 +338,7 @@ export class DnsManager {
       logger.log(
         'error',
         `DnsManager: refusing to serve authoritative apex NS records for ${zoneName} — ${ownership.detail}. `
-          + 'dcrouter answers with the aa flag for every handler it registers, so this zone stays unserved (REFUSED) until ownership is verified.',
+          + 'SmartDNS suppresses authoritative handlers outside the verified authority set, so this zone stays unserved (REFUSED) until ownership is verified.',
         { zone: 'dns', domainId: domain.id, ownershipReason: ownership.reason },
       );
       return;
@@ -302,7 +352,7 @@ export class DnsManager {
       return;
     }
     for (const nsDomain of nsDomains) {
-      this.dnsServer.registerHandler(zoneName, ['NS'], (question) => {
+      const registration = this.dnsServer.registerHandler(zoneName, ['NS'], (question) => {
         if (question.name.toLowerCase() === zoneName && question.type.toUpperCase() === 'NS') {
           return {
             name: question.name,
@@ -313,9 +363,15 @@ export class DnsManager {
           };
         }
         return null;
-      });
+      }, { owner: `dcrouter:dns-manager:${domain.id}` });
+      this.trackRuntimeRegistration(
+        domain.id,
+        zoneName,
+        'NS',
+        'generated-default',
+        registration,
+      );
     }
-    this.trackRuntimeRegistration(domain.id, zoneName, 'NS', 'generated-default');
     logger.log(
       'info',
       `DnsManager: serving default apex NS records for authoritative zone ${zoneName} `
@@ -389,8 +445,7 @@ export class DnsManager {
 
       if (!ownership.verified && hasGenerated) {
         // Authority lost: stop answering for it immediately.
-        this.untrackRuntimeRegistration(domain.id, zoneName, 'NS');
-        this.dnsServer.unregisterHandler(zoneName, ['NS']);
+        this.unregisterRuntimeRegistration(domain.id, zoneName, 'NS');
         unregistered.push(zoneName);
         continue;
       }
@@ -480,7 +535,7 @@ export class DnsManager {
    */
   private registerRecordWithDnsServer(rec: DnsRecordDoc): void {
     if (!this.dnsServer) return;
-    this.dnsServer.registerHandler(rec.name, [rec.type], (question) => {
+    const registration = this.dnsServer.registerHandler(rec.name, [rec.type], (question) => {
       if (question.name.toLowerCase() === rec.name.toLowerCase() && question.type.toUpperCase() === rec.type) {
         return {
           name: question.name,
@@ -491,10 +546,9 @@ export class DnsManager {
         };
       }
       return null;
-    });
-    // Tracked here rather than at each call site so the direct registration in
-    // migrateToDcrouter() is covered as well.
-    this.trackRuntimeRegistration(rec.domainId, rec.name, rec.type, 'persisted');
+    }, { owner: `dcrouter:dns-manager:${rec.domainId}` });
+    // Track beside registration so every call site retains the exact handle.
+    this.trackRuntimeRegistration(rec.domainId, rec.name, rec.type, 'persisted', registration);
   }
 
   private rrsetKey(name: string, type: TDnsRecordType): string {
@@ -514,8 +568,7 @@ export class DnsManager {
     type: TDnsRecordType,
   ): Promise<void> {
     if (!this.dnsServer) return;
-    this.dnsServer.unregisterHandler(name, [type]);
-    this.untrackRuntimeRegistration(domainId, name, type);
+    this.unregisterRuntimeRegistration(domainId, name, type);
     const records = await DnsRecordDoc.findByDomainId(domainId);
     for (const record of records) {
       if (record.name.toLowerCase() === name.toLowerCase() && record.type === type) {
@@ -1199,8 +1252,8 @@ export class DnsManager {
         return { success: false, message: 'Domain is already in the target configuration' };
       }
 
-      const records = await DnsRecordDoc.findByDomainId(domain.id);
       if (args.targetSource === 'provider') {
+        const records = await DnsRecordDoc.findByDomainId(domain.id);
         return await this.migrateToDnsProvider(
           domain,
           records,
@@ -1208,7 +1261,7 @@ export class DnsManager {
           args.deleteExistingProviderRecords ?? false,
         );
       }
-      return await this.migrateToDcrouter(domain, records);
+      return await this.migrateToDcrouter(domain.id);
     });
   }
 
@@ -1298,36 +1351,76 @@ export class DnsManager {
    * Migrate domain from provider-managed to dcrouter-hosted (authoritative).
    */
   private async migrateToDcrouter(
-    domain: DomainDoc,
-    records: DnsRecordDoc[],
+    domainId: string,
   ): Promise<{ success: boolean; recordsMigrated?: number; message?: string }> {
-    // Register each record with the embedded DnsServer
-    let migrated = 0;
-    for (const rec of records) {
-      try {
-        this.registerRecordWithDnsServer(rec);
-        // Update the record doc to local
-        rec.source = 'local' as TDnsRecordSource;
-        rec.providerRecordId = undefined;
-        await rec.save();
-        migrated++;
-      } catch (err: unknown) {
-        logger.log('warn', `Failed to register record ${rec.name} ${rec.type} with DnsServer: ${(err as Error).message}`);
-      }
+    const db = DcRouterDb.getInstance().getDb();
+    const session = db.startSession();
+    let migration: {
+      domain: DomainDoc;
+      records: DnsRecordDoc[];
+      ownership: TDomainOwnership;
+    } | undefined;
+    try {
+      migration = await session.withTransaction(async () => {
+        const domain = await DomainDoc.getInstance({ id: domainId }, { session });
+        if (!domain) {
+          throw new Error(`Domain ${domainId} disappeared during provider-to-dcrouter migration`);
+        }
+        const records = await DnsRecordDoc.getInstances({ domainId }, { session });
+        const ownership = await this.resolveOwnershipForPendingDcrouterZone(domain.name);
+        const now = Date.now();
+
+        for (const rec of records) {
+          rec.source = 'local' as TDnsRecordSource;
+          rec.providerRecordId = undefined;
+          rec.updatedAt = now;
+          await rec.save({ session });
+          await db.mongoDb.collection('DnsRecordDoc').updateOne(
+            { id: rec.id },
+            { $unset: { providerRecordId: '' } },
+            { session },
+          );
+          delete (rec as any).providerRecordId;
+        }
+
+        // Losing the provider link means the credentialed zone listing no
+        // longer proves ownership, so authority is re-derived rather than
+        // assumed.
+        domain.source = 'dcrouter';
+        domain.providerId = undefined;
+        domain.externalZoneId = undefined;
+        domain.nameservers = undefined;
+        domain.lastSyncedAt = undefined;
+        domain.updatedAt = now;
+        domain.authoritative = ownership.verified;
+        await domain.save({ session });
+        await db.mongoDb.collection('DomainDoc').updateOne(
+          { id: domain.id },
+          {
+            $unset: {
+              providerId: '',
+              externalZoneId: '',
+              nameservers: '',
+              lastSyncedAt: '',
+            },
+          },
+          { session },
+        );
+        delete (domain as any).providerId;
+        delete (domain as any).externalZoneId;
+        delete (domain as any).nameservers;
+        delete (domain as any).lastSyncedAt;
+
+        return { domain, records, ownership };
+      });
+    } finally {
+      await session.endSession();
     }
 
-    // Update domain metadata. Losing the provider link means the credentialed
-    // zone listing no longer proves ownership, so authority is re-derived rather
-    // than assumed.
-    domain.source = 'dcrouter';
-    domain.providerId = undefined;
-    domain.externalZoneId = undefined;
-    domain.nameservers = undefined;
-    domain.lastSyncedAt = undefined;
-    domain.updatedAt = Date.now();
-    const ownership = await this.resolveOwnershipForPendingDcrouterZone(domain.name);
-    domain.authoritative = ownership.verified;
-    await domain.save();
+    if (!migration) {
+      throw new Error(`Provider-to-dcrouter migration for ${domainId} committed without a result`);
+    }
+    const { domain, records, ownership } = migration;
     if (!ownership.verified) {
       logger.log(
         'error',
@@ -1335,10 +1428,26 @@ export class DnsManager {
         { zone: 'dns', domainId: domain.id, ownershipReason: ownership.reason },
       );
     }
-    await this.registerAuthoritativeZoneDefaults(domain);
 
-    logger.log('info', `Domain ${domain.name} migrated to dcrouter (${migrated} records)`);
-    return { success: true, recordsMigrated: migrated };
+    // Runtime state is rebuilt only after every durable row has committed. A
+    // failed transaction therefore leaves the provider-backed runtime untouched.
+    this.tearDownDomainRuntimeRegistrations(domain.id);
+    try {
+      const rrsets = new Set(records.map((recordArg) => (
+        this.rrsetKey(recordArg.name, recordArg.type)
+      )));
+      for (const rrset of rrsets) {
+        const [name, type] = rrset.split('|') as [string, TDnsRecordType];
+        await this.refreshLocalRrset(domain.id, name, type);
+      }
+      await this.registerAuthoritativeZoneDefaults(domain);
+    } catch (error) {
+      this.tearDownDomainRuntimeRegistrations(domain.id);
+      throw error;
+    }
+
+    logger.log('info', `Domain ${domain.name} migrated to dcrouter (${records.length} records)`);
+    return { success: true, recordsMigrated: records.length };
   }
 
   // ==========================================================================
@@ -1622,9 +1731,7 @@ export class DnsManager {
    * Unregister a record's handler from the embedded DnsServer.
    */
   public unregisterRecordFromDnsServer(rec: DnsRecordDoc): void {
-    this.untrackRuntimeRegistration(rec.domainId, rec.name, rec.type);
-    if (!this.dnsServer) return;
-    this.dnsServer.unregisterHandler(rec.name, [rec.type]);
+    this.unregisterRuntimeRegistration(rec.domainId, rec.name, rec.type);
   }
 
   // ==========================================================================

package/ts/email/classes.mail-dns-sync.ts

@@ -144,40 +144,6 @@ export function evaluateMailMxValues(
   return { valid: true, outcome: 'valid' };
 }
 
-function expandIpv6(address: string): string[] | undefined {
-  let normalized = address.toLowerCase();
-  if (normalized.includes('.')) {
-    const lastColon = normalized.lastIndexOf(':');
-    const ipv4 = normalized.slice(lastColon + 1).split('.').map(Number);
-    if (ipv4.length !== 4 || ipv4.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
-      return undefined;
-    }
-    normalized = `${normalized.slice(0, lastColon)}:${((ipv4[0] << 8) | ipv4[1]).toString(16)}:${((ipv4[2] << 8) | ipv4[3]).toString(16)}`;
-  }
-  const halves = normalized.split('::');
-  if (halves.length > 2) return undefined;
-  const left = halves[0] ? halves[0].split(':') : [];
-  const right = halves[1] ? halves[1].split(':') : [];
-  const missing = 8 - left.length - right.length;
-  if ((halves.length === 1 && missing !== 0) || missing < 0) return undefined;
-  const groups = [...left, ...Array.from({ length: missing }, () => '0'), ...right];
-  if (groups.length !== 8 || groups.some((group) => !/^[0-9a-f]{1,4}$/.test(group))) return undefined;
-  return groups.map((group) => group.padStart(4, '0'));
-}
-
-export function toReverseDnsName(address: string): string {
-  const family = plugins.smartnetwork.getIpVersion(address);
-  if (family === 4) {
-    return `${address.split('.').reverse().join('.')}.in-addr.arpa`;
-  }
-  if (family === 6) {
-    const groups = expandIpv6(address);
-    if (!groups) throw new Error(`Invalid IPv6 address: ${address}`);
-    return `${groups.join('').split('').reverse().join('.')}.ip6.arpa`;
-  }
-  throw new Error(`Invalid IP address: ${address}`);
-}
-
 export class SmartDnsMailVerifier implements IMailDnsVerifier {
   private client?: plugins.smartdns.dnsClientMod.Smartdns;
 
@@ -316,7 +282,15 @@ export class SmartDnsMailVerifier implements IMailDnsVerifier {
     if (identity.ipv6) checks.push({ family: 'AAAA', address: identity.ipv6 });
     try {
       for (const check of checks) {
-        const ptrQuery = await this.queryValues(toReverseDnsName(check.address), 'PTR');
+        const reverseDnsName = plugins.smartnetwork.toReverseDnsName(check.address);
+        if (!reverseDnsName) {
+          return {
+            valid: false,
+            outcome: 'invalid',
+            reason: `Invalid source-bound IP address: ${check.address}`,
+          };
+        }
+        const ptrQuery = await this.queryValues(reverseDnsName, 'PTR');
         if (ptrQuery.status === 'error') {
           return { valid: false, outcome: 'lookup-error', reason: `PTR lookup failed: ${ptrQuery.reason}` };
         }

package/ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/dcrouter',
-  version: '18.7.1',
+  version: '18.8.1',
   description: 'A multifaceted routing service handling mail and SMS delivery functions.'
 }