Haraka 3.1.0 → 3.1.2

package/docs/Connection.md

@@ -1,67 +1,66 @@
-Connection Object
-=================
+# Connection Object
 
 For each connection to Haraka there is one connection object.
 
-API
----
+## API
 
-* connection.uuid
+- connection.uuid
 
 A unique UUID for this connection.
 
-* connection.remote - info about the host that is connecting to Haraka.
+- connection.remote - info about the host that is connecting to Haraka.
 
-    * ip   - remote IP address
-    * host - reverse DNS of the remote hosts IP
-    * is_private - true if the remote IP is from a private (loopback, RFC 1918, link local, etc.) IP address.
-    * is_local - true if the remote IP is localhost (loopback, link local)
+  - ip - remote IP address
+  - host - reverse DNS of the remote hosts IP
+  - is_private - true if the remote IP is from a private (loopback, RFC 1918, link local, etc.) IP address.
+  - is_local - true if the remote IP is localhost (loopback, link local)
 
-* connection.local - info about the host that is running Haraka
+- connection.local - info about the host that is running Haraka
 
-    * ip - the IP of the Haraka server, as reported by the OS
-    * port - the port number handling the connection.
-    * host - the rDNS host name of the local IP
+  - ip - the IP of the Haraka server, as reported by the OS
+  - port - the port number handling the connection.
+  - host - the rDNS host name of the local IP
 
-* connection.proxy - proxy properties set when a proxy is used (like haproxy)
-    * allowed - if the remote IP has proxy permission
-    * ip - when proxied, the proxy servers IP address
-    * type - currently null or 'haproxy'
+- connection.proxy - proxy properties set when a proxy is used (like haproxy)
 
-* connection.hello
-    * verb - Either 'EHLO' or 'HELO' whichever the remote end used
-    * host - The hostname given with HELO or EHLO
+  - allowed - if the remote IP has proxy permission
+  - ip - when proxied, the proxy servers IP address
+  - type - currently null or 'haproxy'
 
-* connection.notes
+- connection.hello
+
+  - verb - Either 'EHLO' or 'HELO' whichever the remote end used
+  - host - The hostname given with HELO or EHLO
+
+- connection.notes
 
 An object which persists during the lifetime of the connection. It is used to store connection-specific properties. See also, connection.results and [haraka-notes](https://github.com/haraka/haraka-notes).
 
-* connection.transaction
+- connection.transaction
 
 The current transaction object, valid after MAIL FROM, and destroyed at queue
 time, RSET time, or if MAIL FROM was rejected. See the Transaction Object
 documentation file.
 
-* connection.relaying
+- connection.relaying
 
 A boolean flag to say whether this connection is allowed to relay mails (i.e.
 deliver mails outbound). This is normally set by SMTP AUTH, or sometimes via
 an IP address check.
 
-* connection.current\_line
+- connection.current_line
 
 For low level use. Contains the current line sent from the remote end,
 verbatim as it was sent. Can be useful in certain botnet detection techniques.
 
-* connection.last\_response
+- connection.last_response
 
 Contains the last SMTP response sent to the client.
 
-* connection.remote\_closed
+- connection.remote_closed
 
-For low level use.  This value is set when the remote host drops the connection.
+For low level use. This value is set when the remote host drops the connection.
 
-* connection.results
+- connection.results
 
 Store results of processing in a structured format. See [haraka-results](https://github.com/haraka/haraka-results)
-

package/docs/CoreConfig.md

@@ -1,78 +1,77 @@
-Core Configuration Files
-========================
+# Core Configuration Files
 
 See [Logging](Logging.md).
 
 The Haraka core reads some configuration files to determine a few actions:
 
-* smtp.yaml or smtp.json
+- smtp.yaml or smtp.json
 
 If either of these files exist then they are loaded first.
 This file is designed to use the JSON/YAML file overrides documented in
 [haraka-config](https://github.com/haraka/haraka-config) to optionally provide the entire configuration in a single file.
 
-* plugins
+- plugins
 
 The list of plugins to load
 
-* smtp.ini
+- smtp.ini
 
   Keys:
 
-  * listen\_host, port - the host and port to listen on (default: ::0 and 25)
-  * listen - (default: [::0]:25) Comma separated IP:Port addresses to listen on
-  * inactivity\_time - how long to let clients idle in seconds (default: 300)
-  * nodes - specifies how many processes to fork. The string "cpus" will fork as many children as there are CPUs (default: 1, which enables cluster mode with a single process)
-  * user - optionally a user to drop privileges to. Can be a string or UID.
-  * group - optionally a group to drop privileges to. Can be a string or GID.
-  * ignore\_bad\_plugins - If a plugin fails to compile by default Haraka will stop at load time.
+  - listen_host, port - the host and port to listen on (default: ::0 and 25)
+  - listen - (default: [::0]:25) Comma separated IP:Port addresses to listen on
+  - inactivity_time - how long to let clients idle in seconds (default: 300)
+  - nodes - specifies how many processes to fork. The string "cpus" will fork as many children as there are CPUs (default: 1, which enables cluster mode with a single process)
+  - user - optionally a user to drop privileges to. Can be a string or UID.
+  - group - optionally a group to drop privileges to. Can be a string or GID.
+  - ignore_bad_plugins - If a plugin fails to compile by default Haraka will stop at load time.
     If, however, you wish to continue on without that plugin's facilities, then
     set this config option
-  * daemonize - enable this to cause Haraka to fork into the background on start-up (default: 0)
-  * daemon\_log\_file - (default: /var/log/haraka.log) where to redirect stdout/stderr when daemonized
-  * daemon\_pid\_file - (default: /var/run/haraka.pid) where to write a PID file to
-  * spool\_dir - (default: none) directory to create temporary spool files in
-  * spool\_after - (default: -1) if message exceeds this size in bytes, then spool the message to disk
+  - daemonize - enable this to cause Haraka to fork into the background on start-up (default: 0)
+  - daemon_log_file - (default: /var/log/haraka.log) where to redirect stdout/stderr when daemonized
+  - daemon_pid_file - (default: /var/run/haraka.pid) where to write a PID file to
+  - spool_dir - (default: none) directory to create temporary spool files in
+  - spool_after - (default: -1) if message exceeds this size in bytes, then spool the message to disk
     specify -1 to disable spooling completely or 0 to force all messages to be spooled to disk.
-  * graceful\_shutdown - (default: false) enable this to wait for sockets on shutdown instead of closing them quickly
-  * force_shutdown_timeout - (default: 30) number of seconds to wait for a graceful shutdown
+  - graceful_shutdown - (default: false) enable this to wait for sockets on shutdown instead of closing them quickly
+  - force_shutdown_timeout - (default: 30) number of seconds to wait for a graceful shutdown
 
-* me
+- me
 
   A name to use for this server. Used in received lines and elsewhere. Setup
   by default to be your hostname.
 
-* connection.ini
+- connection.ini
 
   See inline comments in connection.ini for the following settings:
 
-  * haproxy.hosts\_ipv4
-  * haproxy.hosts\_ipv6
-  * headers.\*
-  * max.bytes
-  * max.line\_length
-  * max.data\_line\_length
-  * max.mime\_parts
-  * message.greeting
-  * message.close
-  * smtputf8
-  * strict\_rfc1869
-  * uuid.deny\_chars
-  * uuid.banner\_bytes
-
-* plugin\_timeout
+  - haproxy.hosts_ipv4
+  - haproxy.hosts_ipv6
+  - headers.\*
+  - max.bytes
+  - max.line_length
+  - max.data_line_length
+  - max.mime_parts
+  - message.greeting
+  - message.close
+  - smtputf8
+  - strict_rfc1869
+  - uuid.deny_chars
+  - uuid.banner_bytes
+
+- plugin_timeout
 
   Seconds to allow a plugin to run before the next hook is called automatically
   default: 30
 
   Note also that each plugin can have a `config/<plugin_name>.timeout`
-  file specifying a per-plugin timeout.  In this file you can set a timeout of 0 to mean that this plugin's hooks never time out.  Use this with care.
+  file specifying a per-plugin timeout. In this file you can set a timeout of 0 to mean that this plugin's hooks never time out. Use this with care.
 
   If the plugin is in a sub-directory of plugins, then you must create this file
   in the equivalent path e.g. the queue/smtp_forward would need a timeout file in `config/queue/smtp_forward.timeout`
 
-* outbound.ini
+- outbound.ini
 
-* outbound.bounce\_message
+- outbound.bounce_message
 
   The bounce message if delivery of the message fails. The default is normally fine. Bounce messages contain a number of template replacement values which are best discovered by looking at the source code.

package/docs/CustomReturnCodes.md

@@ -1,4 +1,3 @@
 # Custom Return Codes
 
 This content has moved to [haraka-dsn](https://github.com/haraka/haraka-dsn).
-

package/docs/HAProxy.md

@@ -37,7 +37,7 @@ When using `option smtpchk` you will see CONNRESET errors reported in the Haraka
 
 ```
         option tcp-check
-        tcp-check expect rstring ^220\ 
+        tcp-check expect rstring ^220\
         tcp-check send QUIT\r\n
-        tcp-check expect rstring ^221\ 
+        tcp-check expect rstring ^221\
 ```

package/docs/Header.md

@@ -1 +1 @@
-moved to [Header](https://github.com/haraka/email-message#header)
+moved to [Header](https://github.com/haraka/email-message#header)

package/docs/Logging.md

@@ -2,15 +2,14 @@
 
 Haraka has built-in logging (see API docs below) and support for log plugins.
 
-* log.ini
+- log.ini
 
 Contains settings for log level, timestamps, and format. See the example log.ini file for examples.
 
-* loglevel
+- loglevel
 
 The loglevel file provides a finger-friendly way to change the loglevel on the CLI. Use it like so: `echo DEBUG > config/loglevel`. When the level in log.ini is set and the loglevel file is present, the loglevel file wins. During runtime, whichever was edited most recently wins.
 
-
 ## Logging API
 
 Logging conventions within Haraka
@@ -61,7 +60,12 @@ Here's an example of a log line generated with `logfmt`:
 And the same line formatted as JSON:
 
 ```json
-{"level":"PROTOCOL","uuid":"9FF7F70E-5D57-435A-AAD9-EA069B6159D9.1","source":"core","message":"S: 354 go ahead, make my day"}
+{
+  "level": "PROTOCOL",
+  "uuid": "9FF7F70E-5D57-435A-AAD9-EA069B6159D9.1",
+  "source": "core",
+  "message": "S: 354 go ahead, make my day"
+}
 ```
 
 Any objects passed to the log methods will also have their properties included in the log line. For example, using `logfmt`:
@@ -71,5 +75,25 @@ Any objects passed to the log methods will also have their properties included i
 And using JSON:
 
 ```json
-{"level":"NOTICE","uuid":"9FF7F70E-5D57-435A-AAD9-EA069B6159D9.1","source":"core","message":"disconnect","ip":"127.0.0.1","rdns":"Unknown","helo":"3h2dnz8a0if","relay":"N","early":"N","esmtp":"N","tls":"N","pipe":"N","errors":0,"txns":1,"rcpts":"1/0/0","msgs":"1/0/0","bytes":222,"lr":"","time":0.052}
+{
+  "level": "NOTICE",
+  "uuid": "9FF7F70E-5D57-435A-AAD9-EA069B6159D9.1",
+  "source": "core",
+  "message": "disconnect",
+  "ip": "127.0.0.1",
+  "rdns": "Unknown",
+  "helo": "3h2dnz8a0if",
+  "relay": "N",
+  "early": "N",
+  "esmtp": "N",
+  "tls": "N",
+  "pipe": "N",
+  "errors": 0,
+  "txns": 1,
+  "rcpts": "1/0/0",
+  "msgs": "1/0/0",
+  "bytes": 222,
+  "lr": "",
+  "time": 0.052
+}
 ```

package/docs/Outbound.md

@@ -12,15 +12,15 @@ To flush the outbound queue (for temporary failed mails) hit the Haraka master p
 
 ### outbound.ini
 
-* `disabled`
+- `disabled`
 
 Default: false. Allows one to temporarily disable outbound delivery, while still receiving and queuing emails. This can be changed while Haraka is running.
 
-* `concurrency_max`
+- `concurrency_max`
 
 Default: 100. Specifies the maximum concurrent connections to make. Note that if using cluster (multiple CPUs) this will be multiplied by the number of CPUs that you have.
 
-* `enable_tls`
+- `enable_tls`
 
 Default: true. Switch to false to disable TLS for outbound mail.
 
@@ -33,27 +33,39 @@ Within `tls.ini` you can specify global options for the values `ciphers`, `minVe
 ciphers=!DES
 ```
 
-* `always_split`
+- `always_split`
 
 Default: false. By default, Haraka groups message recipients by domain so that messages with multiple recipients at the same domain get sent in a single SMTP session. When `always_split` is enabled, each recipient gets a queue entry and delivery in its own SMTP session. This carries a performance penalty but enables more flexibility in mail delivery and bounce handling.
 
-* `received_header`
+- `received_header`
 
-Default: "Haraka outbound". If this text is any string except *disabled*, the string is attached as a `Received` header to all outbound mail just before it is queued.
+Default: "Haraka outbound". If this text is any string except _disabled_, the string is attached as a `Received` header to all outbound mail just before it is queued.
 
-* `connect_timeout`
+- `connect_timeout`
 
 Timeout for connecting to remote servers. Default: 30s
 
-* `local_mx_ok`
+- `local_mx_ok`
 
 Default: false. By default, outbound to a local IP is disabled, to avoid creating mail loops. Set this to true if you want to allow outbound to local IPs. This could be useful if you want to deliver mail to private IPs or localhost on another port.
 
-* `temp_fail_intervals`
+- `temp_fail_intervals`
 
 Set this to specify the delay intervals to use between trying to re-send an email that has a temporary failure condition. The setting is a comma separated list of time spans and multipliers. The time span is a number followed by `s`, `m`, `h`, or `d` to represent seconds, minutes, hours, and days, respectively. The multiplier is an asterisk followed by an integer representing the number of times to repeat the interval. For example, the entry `1m, 5m*2, 1h*3` results in an array of delay times of `[60,300,300,3600,3600,3600]` in seconds. The email will be bounced when the array runs out of intervals (the 7th failure in this case). Set this to `none` to bounce the email on the first temporary failure.
 
-### outbound.bounce\_message
+* `inet_prefer`
+
+Default: default. Selects the preferred address family (IP version) to deliver messages.
+
+| Value              | Description |
+|------------------------|-------------|
+| `default` | Prefer IPv6 when IPv4 and IPv6 IPs exist at the same MX priority |
+| `v4`    | Try IPv4 addresses first, then IPv6 |
+| `v6`    | Try IPv6 addresses first, then IPv4 |
+
+Note: Delivery attempts follow MX priority order. Socket-based deliveries ignore this setting.
+
+### outbound.bounce_message
 
 See "Bounce Messages" below for details.
 
@@ -65,33 +77,33 @@ You likely won't ever need to call methods on this object, so they are left undo
 
 The attributes of an `hmail` object that may be of use are:
 
-* path - the full path to the queue file
-* filename - the filename within the queue dir
-* num_failures - the number of times this mail has been temp failed
-* notes - notes you can store on a hmail object (similar to `transaction.notes`) to allow you to pass information between outbound hooks
-* todo - see below
+- path - the full path to the queue file
+- filename - the filename within the queue dir
+- num_failures - the number of times this mail has been temp failed
+- notes - notes you can store on a hmail object (similar to `transaction.notes`) to allow you to pass information between outbound hooks
+- todo - see below
 
 ## The ToDo Object
 
 The `todo` object contains information about how to deliver this mail. Keys you may be interested in are:
 
-* rcpt_to - an Array of `Address`<sup>[1](#fn1)</sup> objects - the rfc.2821 recipients of this mail
-* mail_from - an Address<sup>[1](#fn1)</sup> object - the rfc.2821 sender of this mail
-* domain - the domain this mail is going to (see `always_split` above)
-* notes - the original transaction.notes for this mail, also contains the following useful keys:
-  * outbound_ip - the IP address to bind to (do not set manually, use the `get_mx` hook)
-  * outbound_helo - the EHLO domain to use (again, do not set manually)
-* queue_time - the epoch milliseconds time when this mail was queued
-* uuid - the original transaction.uuid
-* force_tls - if true, this mail will be sent over TLS or defer
+- rcpt_to - an Array of `Address`<sup>[1](#fn1)</sup> objects - the rfc.2821 recipients of this mail
+- mail_from - an Address<sup>[1](#fn1)</sup> object - the rfc.2821 sender of this mail
+- domain - the domain this mail is going to (see `always_split` above)
+- notes - the original transaction.notes for this mail, also contains the following useful keys:
+  - outbound_ip - the IP address to bind to (do not set manually, use the `get_mx` hook)
+  - outbound_helo - the EHLO domain to use (again, do not set manually)
+- queue_time - the epoch milliseconds time when this mail was queued
+- uuid - the original transaction.uuid
+- force_tls - if true, this mail will be sent over TLS or defer
 
 ## Outbound Mail Hooks
 
-### The queue\_outbound hook
+### The queue_outbound hook
 
 The first hook that is called prior to queueing an outbound mail is the `queue_outbound` hook. Only if all these hooks return `CONT` (or if there are no hooks) will the mail be queued for outbound delivery. A return of `OK` will indicate that the mail has been queued in some custom manner for outbound delivery. Any of the `DENY` return codes will cause the message to be appropriately rejected.
 
-### The send\_email hook
+### The send_email hook
 
 Parameters: `next, hmail`
 
@@ -99,7 +111,7 @@ Called just as the email is about to be sent.
 
 Respond with `next(DELAY, delay_seconds)` to defer sending the email at this time.
 
-### The get\_mx hook
+### The get_mx hook
 
 Parameters: `next, hmail, domain`
 
@@ -121,11 +133,11 @@ If you want to change the delay, then call `next(DENYSOFT, delay_in_seconds)`. U
 
 Parameters: `next, hmail, error`
 
-If the mail completely bounces then the `bounce` hook is called. This is *not* called if the mail is issued a temporary failure (a 4xx error code). The hook parameter is the error message received from the remote end as an `Error` object. The object may also have the following properties:
+If the mail completely bounces then the `bounce` hook is called. This is _not_ called if the mail is issued a temporary failure (a 4xx error code). The hook parameter is the error message received from the remote end as an `Error` object. The object may also have the following properties:
 
-* mx - the MX object that caused the bounce
-* deferred_rcpt - the deferred recipients that eventually bounced
-* bounced_rcpt - the bounced recipients
+- mx - the MX object that caused the bounce
+- deferred_rcpt - the deferred recipients that eventually bounced
+- bounced_rcpt - the bounced recipients
 
 If you do not wish to have a bounce message sent to the originating sender of the email then you can return `OK` from this hook to stop it from sending a bounce message.
 
@@ -137,20 +149,20 @@ Params is a list of: `[host, ip, response, delay, port, mode, ok_recips, secured
 
 When mails are successfully delivered to the remote end then the `delivered` hook is called. The return codes from this hook have no effect, so it is only useful for logging the fact that a successful delivery occurred.
 
-* `host` - Hostname of the MX that the message was delivered to,
-* `ip` - IP address of the host that the message was delivered to,
-* `response` - Variable contains the SMTP response text returned by the host that received the message and will typically contain the remote queue ID and
-* `delay` - Time taken between the queue file being created and the message being delivered.
-* `port` - Port number that the message was delivered to.
-* `mode` - Shows whether SMTP or LMTP was used to deliver the mail.
-* `ok_recips` - an `Address`<sup>[1](#fn1)</sup> array containing all of the recipients that were successfully delivered to.
-* `secured` - A boolean denoting if the connection used TLS or not.
+- `host` - Hostname of the MX that the message was delivered to,
+- `ip` - IP address of the host that the message was delivered to,
+- `response` - Variable contains the SMTP response text returned by the host that received the message and will typically contain the remote queue ID and
+- `delay` - Time taken between the queue file being created and the message being delivered.
+- `port` - Port number that the message was delivered to.
+- `mode` - Shows whether SMTP or LMTP was used to deliver the mail.
+- `ok_recips` - an `Address`<sup>[1](#fn1)</sup> array containing all of the recipients that were successfully delivered to.
+- `secured` - A boolean denoting if the connection used TLS or not.
 
 ## Outbound IP address
 
 Normally the OS will decide which IP address will be used for outbound connections using the IP routing table.
 
-There are instances where you may want to separate outbound traffic on different IP addresses based on sender, domain or some other identifier. To do this, the IP address that you want to use *must* be bound to an interface (or alias) on the local system.
+There are instances where you may want to separate outbound traffic on different IP addresses based on sender, domain or some other identifier. To do this, the IP address that you want to use _must_ be bound to an interface (or alias) on the local system.
 
 As described above, the outbound IP can be set using the `bind` parameter and also the outbound helo for the IP can be set using the `bind_ehlo` parameter returned by the `get_mx` hook.
 
@@ -166,14 +178,14 @@ The contents of the bounce message are configured by a file called `config/outbo
 
 Optional: Possibility to add HTML code (with optional image) to the bounce message is possible by adding the files `config/outbound.bounce_message_html`. An image can be attached to the mail by using `config/outbound.bounce_message_image`.
 
-* pid - the current process id
-* date - the current date when the bounce occurred
-* me - the contents of `config/me`
-* from - the originating sender of the message
-* msgid - a uuid for the mail
-* to - the end recipient of the message, or the first recipient if it was to
-multiple people
-* reason - the text from the remote server indicating why it bounced
+- pid - the current process id
+- date - the current date when the bounce occurred
+- me - the contents of `config/me`
+- from - the originating sender of the message
+- msgid - a uuid for the mail
+- to - the end recipient of the message, or the first recipient if it was to
+  multiple people
+- reason - the text from the remote server indicating why it bounced
 
 Following the bounce message itself will be a copy of the entire original message.
 
@@ -184,31 +196,35 @@ Sometimes it is necessary to generate a new mail from within a plugin.
 To do that, you can use the `outbound` module directly:
 
 ```js
-const outbound = require('./outbound');
+const outbound = require('./outbound')
 
-const to = 'user@example.com';
-const from = 'sender@example.com';
+const to = 'user@example.com'
+const from = 'sender@example.com'
 
 const contents = [
-    "From: " + from,
-    "To: " + to,
-    "MIME-Version: 1.0",
-    "Content-type: text/plain; charset=us-ascii",
-    "Subject: Some subject here",
-    "",
-    "Some email body here",
-    ""].join("\n");
+  'From: ' + from,
+  'To: ' + to,
+  'MIME-Version: 1.0',
+  'Content-type: text/plain; charset=us-ascii',
+  'Subject: Some subject here',
+  '',
+  'Some email body here',
+  '',
+].join('\n')
 
 const outnext = (code, msg) => {
-    switch (code) {
-        case DENY:  this.logerror("Sending mail failed: " + msg);
-                    break;
-        case OK:    this.loginfo("mail sent");
-                    next();
-                    break;
-        default:    this.logerror("Unrecognized return code from sending email: " + msg);
-                    next();
-    }
+  switch (code) {
+    case DENY:
+      this.logerror('Sending mail failed: ' + msg)
+      break
+    case OK:
+      this.loginfo('mail sent')
+      next()
+      break
+    default:
+      this.logerror('Unrecognized return code from sending email: ' + msg)
+      next()
+  }
 }
 
 outbound.send_email(from, to, contents, outnext)
@@ -219,28 +235,27 @@ The callback on `send_email()` is passed `OK` if the mail is successfully queued
 The callback parameter may be omitted if you don't need to handle errors should queueing to disk fail e.g:
 
 ```js
-outbound.send_email(from, to, contents);
+outbound.send_email(from, to, contents)
 ```
 
 Various options can be passed to `outbound.send_email` like so:
 
 ```js
-outbound.send_email(from, to, contents, outnext, options);
+outbound.send_email(from, to, contents, outnext, options)
 ```
 
 Where `options` is a Object that may contain the following keys:
 
-| Key/Value              | Description |
-|------------------------|-------------|
-| `dot_stuffed: true`    | Use this if you are passing your content dot-stuffed (a dot at the start of a line is doubled, like it is in SMTP conversation, see [RFC 2821][url-rfc2821].|
-| `notes: { key: value}` | In case you need notes in the new transaction that `send_email()` creates. |
+| Key/Value              | Description                                                                                                                                                                                                                                                           |
+| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `dot_stuffed: true`    | Use this if you are passing your content dot-stuffed (a dot at the start of a line is doubled, like it is in SMTP conversation, see [RFC 2821][url-rfc2821].                                                                                                          |
+| `notes: { key: value}` | In case you need notes in the new transaction that `send_email()` creates.                                                                                                                                                                                            |
 | `remove_msgid: true`   | Remove any Message-Id header found in the message. If you are reading a message in from the filesystem and you want to ensure that a generated Message-Id header is used in preference over the original. This is useful if you are releasing mail from a quarantine. |
-| `remove_date: true`    | Remove any Date header found in the message. If you are reading a message in from the filesystem and you want to ensure that a generated Date header is used in preference over the original. This is useful if you are releasing mail from a quarantine. |
-| `origin: Object`       | Adds object as argument to logger.log calls inside outbound.send_email. Useful for tracking which Plugin/Connection/HMailItem object generated email. |
-
+| `remove_date: true`    | Remove any Date header found in the message. If you are reading a message in from the filesystem and you want to ensure that a generated Date header is used in preference over the original. This is useful if you are releasing mail from a quarantine.             |
+| `origin: Object`       | Adds object as argument to logger.log calls inside outbound.send_email. Useful for tracking which Plugin/Connection/HMailItem object generated email.                                                                                                                 |
 
 ```js
-outbound.send_email(from, to, contents, outnext, { notes: transaction.notes });
+outbound.send_email(from, to, contents, outnext, { notes: transaction.notes })
 ```
 
 <a name="fn1">1</a>: `Address` objects are [address-rfc2821](https://github.com/haraka/node-address-rfc2821) objects.