@bumail/smtp 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,12 +1,13 @@
 import {
   SmtpError2,
+  POSTMASTER,
   isHelloName,
   parsePath2,
   decodePlain2,
   decodeLoginStep2,
   LineSplitter,
   Outgoing
-} from "./chunks/index-3423jxf9.js";
+} from "./chunks/index-753q702a.js";
 // src/protocol/command.ts
 function parseCommand(line) {
   const space = line.indexOf(" ");
@@ -21,7 +22,8 @@ function parsePathCommand(argument, keyword) {
   const match = new RegExp(`^${keyword}:\\s*(<[^>]*>)(.*)$`, "i").exec(argument);
   if (!match)
     return;
-  const path = parsePath2(match[1], keyword === "FROM");
+  const text = match[1];
+  const path = keyword === "TO" && text.toLowerCase() === "<postmaster>" ? POSTMASTER : parsePath2(text, keyword === "FROM");
   if (!path)
     return;
   const parameters = {};
@@ -123,6 +125,40 @@ function formatReply(reply, enhanced = true) {
   }).join("");
 }
 var reply = (code, status, text) => status === undefined ? { code, text } : { code, status, text };
+// src/server/client-key.ts
+import { isIP } from "node:net";
+function groups(ip) {
+  const dotted = /(\d+)\.(\d+)\.(\d+)\.(\d+)$/.exec(ip);
+  let text = ip;
+  if (dotted !== null) {
+    const [a, b, c, d] = dotted.slice(1).map(Number);
+    text = `${ip.slice(0, dotted.index)}${(a << 8 | b).toString(16)}:${(c << 8 | d).toString(16)}`;
+  }
+  const [head = "", tail] = text.split("::");
+  const left = head === "" ? [] : head.split(":");
+  const right = tail === undefined || tail === "" ? [] : tail.split(":");
+  const all = tail === undefined ? left : [...left, ...Array(8 - left.length - right.length).fill("0"), ...right];
+  return all.map((group) => Number.parseInt(group, 16));
+}
+function ipv4Of(g) {
+  const [high = 0, low = 0] = g.slice(6);
+  return [high >> 8, high & 255, low >> 8, low & 255].join(".");
+}
+function clientKey(ip) {
+  if (typeof ip !== "string")
+    return;
+  const address = ip.replace(/^\[|\]$/g, "").replace(/%.*$/, "");
+  if (isIP(address) === 4)
+    return address;
+  if (isIP(address) !== 6)
+    return;
+  const g = groups(address.toLowerCase());
+  const prefix = g.slice(0, 6).join(":");
+  if (prefix === "0:0:0:0:0:65535" || prefix === "100:65435:0:0:0:0") {
+    return ipv4Of(g);
+  }
+  return `${g.slice(0, 4).map((group) => group.toString(16)).join(":")}::/64`;
+}
 // src/server/guard.ts
 var LOCAL_ERROR = reply(451, "4.3.0", "Local error in processing");
 var TIMED_OUT = Symbol("timed out");
@@ -326,7 +362,7 @@ async function rcpt(connection, argument) {
   if (state.transaction.to.length >= settings.maxRecipients) {
     return connection.send(reply(452, "4.5.3", "Too many recipients"));
   }
-  if (state.user === undefined) {
+  if (state.user === undefined && path.postmaster !== true) {
     const local = await connection.check("localDomains", () => settings.isLocal(path.domain));
     if (local.failed)
       return connection.send(LOCAL_ERROR);
@@ -952,77 +988,6 @@ class Connection {
   }
 }
 
-// src/server/settings.ts
-var MAX_TIMER_SECONDS = Math.floor(2147483647 / 1000);
-var invalid = (message) => new SmtpError2("INVALID_OPTION", `createSmtpServer(): ${message}`);
-function positive(name, value, fallback) {
-  if (value === undefined)
-    return fallback;
-  if (!Number.isSafeInteger(value) || value < 1) {
-    throw invalid(`${name} must be a positive integer, not ${value}`);
-  }
-  return value;
-}
-function timer(name, value, fallback) {
-  const seconds = positive(name, value, fallback);
-  if (seconds > MAX_TIMER_SECONDS) {
-    throw invalid(`${name} must be at most ${MAX_TIMER_SECONDS} seconds, not ${seconds}`);
-  }
-  return seconds;
-}
-function nonNegative(name, value, fallback) {
-  if (value === undefined)
-    return fallback;
-  if (!Number.isFinite(value) || value < 0) {
-    throw invalid(`${name} must be a number of seconds, 0 or more, not ${value}`);
-  }
-  return value;
-}
-function localLookup(local) {
-  if (typeof local === "function")
-    return local;
-  if (Array.isArray(local) && local.every((domain) => typeof domain === "string")) {
-    const domains = new Set(local.map((domain) => domain.toLowerCase()));
-    return (domain) => domains.has(domain);
-  }
-  throw invalid("localDomains must be an array of domains or a function");
-}
-function settingsOf(options) {
-  if (typeof options.hostname !== "string" || !/^[A-Za-z0-9.-]+$/.test(options.hostname)) {
-    throw invalid(`"${options.hostname}" is not a host name`);
-  }
-  if (typeof options.onData !== "function") {
-    throw invalid("onData must be a function: it is where messages go");
-  }
-  if (options.implicitTls && !options.tls) {
-    throw invalid("implicitTls needs tls: { key, cert }");
-  }
-  if (options.mode === "submission" && !options.authenticate) {
-    throw invalid("submission takes mail only from authenticated users, so it needs authenticate");
-  }
-  if (options.authenticate && !options.tls) {
-    throw invalid("authenticate needs tls: { key, cert }, since AUTH is offered only once encrypted");
-  }
-  const isLocal = localLookup(options.localDomains);
-  const timeout = positive("timeout", options.timeout, 300);
-  const greetingDelay = nonNegative("greetingDelay", options.greetingDelay, 0);
-  if (greetingDelay >= timeout) {
-    throw invalid(`greetingDelay (${greetingDelay} s) must be shorter than timeout (${timeout} s), or every client times out before the greeting`);
-  }
-  return {
-    options,
-    mode: options.mode ?? "mx",
-    maxMessageSize: positive("maxMessageSize", options.maxMessageSize, 25 * 1024 * 1024),
-    maxRecipients: positive("maxRecipients", options.maxRecipients, 100),
-    maxConnections: positive("maxConnections", options.maxConnections, 1000),
-    maxErrors: positive("maxErrors", options.maxErrors, 10),
-    timeout,
-    hookTimeout: timer("hookTimeout", options.hookTimeout, 60),
-    greetingDelay,
-    isLocal: (domain) => isLocal(domain.toLowerCase())
-  };
-}
-
 // src/server/transport.ts
 var CLOSE_GRACE_MS = 5000;
 var LINGER_QUIET_MS = 20;
@@ -1158,27 +1123,29 @@ class SocketTransport {
   }
 }
 
-// src/server/server.ts
+// src/server/listener.ts
 function handlers(settings) {
   const idle = reply(421, "4.4.2", `${settings.options.hostname} Idle too long, closing`);
   return {
     data(socket, chunk) {
-      if (socket.data.upgraded)
+      if (!socket.data || socket.data.upgraded)
         return;
       socket.data.transport?.received();
       socket.timeout(settings.timeout);
       socket.data.connection?.receive(chunk);
     },
     drain(socket) {
-      if (!socket.data.upgraded)
+      if (socket.data && !socket.data.upgraded)
         socket.data.transport?.drain();
     },
     error(socket) {
-      socket.data.connection?.close();
+      socket.data?.connection?.close();
     },
     timeout(socket) {
-      if (socket.data.upgraded)
+      if (!socket.data || socket.data.upgraded)
         return;
+      if (socket.data.handshaking)
+        return socket.terminate();
       const { connection, transport } = socket.data;
       if (connection?.closed)
         transport?.abort();
@@ -1187,7 +1154,13 @@ function handlers(settings) {
     }
   };
 }
-function transportOf(socket, settings, secure) {
+function turnAway(socket, secure, line) {
+  const refused = new SocketTransport(socket, secure, () => {});
+  socket.data.transport = refused;
+  refused.write(line);
+  refused.end();
+}
+function transportOf(socket, settings, secure, slots) {
   const transport = new SocketTransport(socket, secure, () => {
     const tls = settings.options.tls;
     const connection = socket.data.connection;
@@ -1200,6 +1173,7 @@ function transportOf(socket, settings, secure) {
       socket: {
         ...handlers(settings),
         close: (s) => {
+          slots.release(connection);
           s.data.transport?.closed();
           connection.close();
         }
@@ -1213,14 +1187,171 @@ function transportOf(socket, settings, secure) {
   socket.data.transport = transport;
   return transport;
 }
+function listenerHandlers(settings, slots, handshaking, secure) {
+  return {
+    open(socket) {
+      socket.data = { upgraded: false, handshaking: secure };
+      socket.timeout(secure ? settings.handshakeTimeout : settings.timeout);
+      const begin = (start) => {
+        if (!secure)
+          return start();
+        handshaking.add(socket);
+        socket.data.start = start;
+      };
+      if (slots.size >= settings.maxConnections) {
+        return begin(() => turnAway(socket, secure, `421 4.3.2 ${settings.options.hostname} Too many connections, try later\r
+`));
+      }
+      const key = clientKey(socket.remoteAddress);
+      if (slots.of(key) >= settings.maxConnectionsPerClient) {
+        return begin(() => turnAway(socket, secure, `421 4.7.0 ${settings.options.hostname} Too many connections from your address, try later\r
+`));
+      }
+      const connection = new Connection(settings, transportOf(socket, settings, secure, slots));
+      slots.take(connection, key);
+      socket.data.connection = connection;
+      begin(() => void connection.open());
+    },
+    handshake(socket, success) {
+      const state = socket.data;
+      if (!state?.handshaking)
+        return;
+      handshaking.delete(socket);
+      if (!success)
+        return;
+      state.handshaking = false;
+      socket.timeout(settings.timeout);
+      const start = state.start;
+      delete state.start;
+      start?.();
+    },
+    close(socket) {
+      handshaking.delete(socket);
+      const connection = socket.data?.connection;
+      if (connection)
+        slots.release(connection);
+      socket.data?.transport?.closed();
+      connection?.close();
+    }
+  };
+}
+
+// src/server/settings.ts
+var MAX_TIMER_SECONDS = Math.floor(2147483647 / 1000);
+var invalid = (message) => new SmtpError2("INVALID_OPTION", `createSmtpServer(): ${message}`);
+function positive(name, value, fallback) {
+  if (value === undefined)
+    return fallback;
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw invalid(`${name} must be a positive integer, not ${value}`);
+  }
+  return value;
+}
+function timer(name, value, fallback) {
+  const seconds = positive(name, value, fallback);
+  if (seconds > MAX_TIMER_SECONDS) {
+    throw invalid(`${name} must be at most ${MAX_TIMER_SECONDS} seconds, not ${seconds}`);
+  }
+  return seconds;
+}
+function nonNegative(name, value, fallback) {
+  if (value === undefined)
+    return fallback;
+  if (!Number.isFinite(value) || value < 0) {
+    throw invalid(`${name} must be a number of seconds, 0 or more, not ${value}`);
+  }
+  return value;
+}
+function localLookup(local) {
+  if (typeof local === "function")
+    return local;
+  if (Array.isArray(local) && local.every((domain) => typeof domain === "string")) {
+    const domains = new Set(local.map((domain) => domain.toLowerCase()));
+    return (domain) => domains.has(domain);
+  }
+  throw invalid("localDomains must be an array of domains or a function");
+}
+function settingsOf(options) {
+  if (typeof options.hostname !== "string" || !/^[A-Za-z0-9.-]+$/.test(options.hostname)) {
+    throw invalid(`"${options.hostname}" is not a host name`);
+  }
+  if (typeof options.onData !== "function") {
+    throw invalid("onData must be a function: it is where messages go");
+  }
+  if (options.implicitTls && !options.tls) {
+    throw invalid("implicitTls needs tls: { key, cert }");
+  }
+  if (options.mode === "submission" && !options.authenticate) {
+    throw invalid("submission takes mail only from authenticated users, so it needs authenticate");
+  }
+  if (options.authenticate && !options.tls) {
+    throw invalid("authenticate needs tls: { key, cert }, since AUTH is offered only once encrypted");
+  }
+  const isLocal = localLookup(options.localDomains);
+  const timeout = positive("timeout", options.timeout, 300);
+  const greetingDelay = nonNegative("greetingDelay", options.greetingDelay, 0);
+  if (greetingDelay >= timeout) {
+    throw invalid(`greetingDelay (${greetingDelay} s) must be shorter than timeout (${timeout} s), or every client times out before the greeting`);
+  }
+  return {
+    options,
+    mode: options.mode ?? "mx",
+    maxMessageSize: positive("maxMessageSize", options.maxMessageSize, 25 * 1024 * 1024),
+    maxRecipients: positive("maxRecipients", options.maxRecipients, 100),
+    maxConnections: positive("maxConnections", options.maxConnections, 1000),
+    maxConnectionsPerClient: positive("maxConnectionsPerClient", options.maxConnectionsPerClient, 10),
+    maxErrors: positive("maxErrors", options.maxErrors, 10),
+    timeout,
+    hookTimeout: timer("hookTimeout", options.hookTimeout, 60),
+    handshakeTimeout: positive("handshakeTimeout", options.handshakeTimeout, 10),
+    greetingDelay,
+    isLocal: (domain) => isLocal(domain.toLowerCase())
+  };
+}
+
+// src/server/slots.ts
+class Slots {
+  #open = new Map;
+  #perClient = new Map;
+  get size() {
+    return this.#open.size;
+  }
+  of(key) {
+    return key === undefined ? 0 : this.#perClient.get(key) ?? 0;
+  }
+  take(connection, key) {
+    this.#open.set(connection, key);
+    if (key !== undefined)
+      this.#perClient.set(key, this.of(key) + 1);
+  }
+  release(connection) {
+    if (!this.#open.has(connection))
+      return;
+    const key = this.#open.get(connection);
+    this.#open.delete(connection);
+    if (key === undefined)
+      return;
+    const left = this.of(key) - 1;
+    if (left > 0)
+      this.#perClient.set(key, left);
+    else
+      this.#perClient.delete(key);
+  }
+  connections() {
+    return [...this.#open.keys()];
+  }
+}
+
+// src/server/server.ts
 function createSmtpServer(options) {
   const settings = settingsOf(options);
   let listener;
-  const open = new Set;
+  const slots = new Slots;
+  const handshaking = new Set;
   const secure = options.implicitTls === true;
   return {
     get connections() {
-      return open.size;
+      return slots.size;
     },
     async listen({ port, hostname = "0.0.0.0" }) {
       if (listener) {
@@ -1232,29 +1363,7 @@ function createSmtpServer(options) {
         ...secure && options.tls ? { tls: { key: options.tls.key, cert: options.tls.cert } } : {},
         socket: {
           ...handlers(settings),
-          open(socket) {
-            socket.data = { upgraded: false };
-            socket.timeout(settings.timeout);
-            if (open.size >= settings.maxConnections) {
-              const refused = new SocketTransport(socket, secure, () => {});
-              socket.data.transport = refused;
-              refused.write(`421 4.3.2 ${options.hostname} Too many connections, try later\r
-`);
-              refused.end();
-              return;
-            }
-            const connection = new Connection(settings, transportOf(socket, settings, secure));
-            open.add(connection);
-            socket.data.connection = connection;
-            connection.open();
-          },
-          close(socket) {
-            const connection = socket.data.connection;
-            if (connection)
-              open.delete(connection);
-            socket.data.transport?.closed();
-            socket.data.connection?.close();
-          }
+          ...listenerHandlers(settings, slots, handshaking, secure)
         }
       });
       return { port: listener.port, hostname: listener.hostname };
@@ -1264,14 +1373,23 @@ function createSmtpServer(options) {
       listener = undefined;
       if (!closeConnections)
         return;
-      for (const connection of [...open])
-        connection.close();
+      const stuck = new Set;
+      for (const socket of [...handshaking]) {
+        stuck.add(socket.data?.connection);
+        handshaking.delete(socket);
+        socket.terminate();
+      }
+      for (const connection of slots.connections()) {
+        if (!stuck.has(connection))
+          connection.close();
+      }
     }
   };
 }
 export {
   DataReader,
   SmtpError2 as SmtpError,
+  clientKey,
   createSmtpServer,
   decodeLoginStep2 as decodeLoginStep,
   decodePlain2 as decodePlain,
@@ -1282,5 +1400,5 @@ export {
   reply
 };
 
-//# debugId=04EE37708209636464756E2164756E21
+//# debugId=388406E838895A3964756E2164756E21
 //# sourceMappingURL=index.js.map