Haraka 3.1.1 → 3.1.2

package/plugins/queue/quarantine.js

@@ -1,135 +1,133 @@
 // quarantine
 
-const fs   = require('node:fs');
-const path = require('node:path');
+const fs = require('node:fs')
+const path = require('node:path')
 
 exports.register = function () {
+    this.load_quarantine_ini()
 
-    this.load_quarantine_ini();
-
-    this.register_hook('queue',          'quarantine');
-    this.register_hook('queue_outbound', 'quarantine');
+    this.register_hook('queue', 'quarantine')
+    this.register_hook('queue_outbound', 'quarantine')
 }
 
 exports.hook_init_master = function (next, server) {
     this.init_quarantine_dir(() => {
-        this.clean_tmp_directory(next);
-    });
+        this.clean_tmp_directory(next)
+    })
 }
 
 exports.load_quarantine_ini = function () {
     this.cfg = this.config.get('quarantine.ini', () => {
-        this.load_quarantine_ini();
+        this.load_quarantine_ini()
     })
 }
 
-const zeroPad = exports.zeroPad = (n, digits) => {
-    n = n.toString();
+const zeroPad = (exports.zeroPad = (n, digits) => {
+    n = n.toString()
     while (n.length < digits) {
-        n = `0${n}`;
+        n = `0${n}`
     }
-    return n;
-}
+    return n
+})
 
 exports.clean_tmp_directory = function (next) {
-    const tmp_dir = path.join(this.get_base_dir(), 'tmp');
+    const tmp_dir = path.join(this.get_base_dir(), 'tmp')
 
     if (fs.existsSync(tmp_dir)) {
-        const dirent = fs.readdirSync(tmp_dir);
-        this.loginfo(`Removing temporary files from: ${tmp_dir}`);
+        const dirent = fs.readdirSync(tmp_dir)
+        this.loginfo(`Removing temporary files from: ${tmp_dir}`)
         for (const element of dirent) {
-            fs.unlinkSync(path.join(tmp_dir, element));
+            fs.unlinkSync(path.join(tmp_dir, element))
         }
     }
-    next();
+    next()
 }
 
-function wants_quarantine (connection) {
+function wants_quarantine(connection) {
     const { notes, transaction } = connection ?? {}
 
-    if (notes.quarantine) return notes.quarantine;
+    if (notes.quarantine) return notes.quarantine
 
-    if (transaction.notes.quarantine) return transaction.notes.quarantine;
+    if (transaction.notes.quarantine) return transaction.notes.quarantine
 
-    return transaction.notes.get('queue.wants') === 'quarantine';
+    return transaction.notes.get('queue.wants') === 'quarantine'
 }
 
 exports.get_base_dir = function () {
-    if (this.cfg.main.quarantine_path) return this.cfg.main.quarantine_path;
-    return '/var/spool/haraka/quarantine';
+    if (this.cfg.main.quarantine_path) return this.cfg.main.quarantine_path
+    return '/var/spool/haraka/quarantine'
 }
 
 exports.init_quarantine_dir = function (done) {
-    const tmp_dir = path.join(this.get_base_dir(), 'tmp');
-    fs.promises.mkdir(tmp_dir, { recursive: true })
-        .then(made => this.loginfo(`created ${tmp_dir}`))
-        .catch(err => this.logerror(`Unable to create ${tmp_dir}`))
-        .finally(done);
+    const tmp_dir = path.join(this.get_base_dir(), 'tmp')
+    fs.promises
+        .mkdir(tmp_dir, { recursive: true })
+        .then((made) => this.loginfo(`created ${tmp_dir}`))
+        .catch((err) => this.logerror(`Unable to create ${tmp_dir}`))
+        .finally(done)
 }
 
 exports.quarantine = function (next, connection) {
-
-    const quarantine = wants_quarantine(connection);
-    this.logdebug(`quarantine: ${quarantine}`);
-    if (!quarantine) return next();
+    const quarantine = wants_quarantine(connection)
+    this.logdebug(`quarantine: ${quarantine}`)
+    if (!quarantine) return next()
 
     // Calculate date in YYYYMMDD format
-    const d = new Date();
-    const yyyymmdd = d.getFullYear() + zeroPad(d.getMonth()+1, 2)
-        + this.zeroPad(d.getDate(), 2);
+    const d = new Date()
+    const yyyymmdd = d.getFullYear() + zeroPad(d.getMonth() + 1, 2) + this.zeroPad(d.getDate(), 2)
 
-    let subdir = yyyymmdd;
+    let subdir = yyyymmdd
     // Allow either boolean or a sub-directory to be specified
 
     if (typeof quarantine !== 'boolean' && quarantine !== 1) {
-        subdir = path.join(quarantine, yyyymmdd);
+        subdir = path.join(quarantine, yyyymmdd)
     }
 
-    const txn = connection?.transaction;
-    if (!txn) return next();
+    const txn = connection?.transaction
+    if (!txn) return next()
 
-    const base_dir = this.get_base_dir();
-    const msg_dir  = path.join(base_dir, subdir);
-    const tmp_path = path.join(base_dir, 'tmp', txn.uuid);
-    const msg_path = path.join(msg_dir, txn.uuid);
+    const base_dir = this.get_base_dir()
+    const msg_dir = path.join(base_dir, subdir)
+    const tmp_path = path.join(base_dir, 'tmp', txn.uuid)
+    const msg_path = path.join(msg_dir, txn.uuid)
 
     // Create all the directories recursively if they do not exist.
     // Then write the file to a temporary directory first, once this is
     // successful we hardlink the file to the final destination and then
     // remove the temporary file to guarantee a complete file in the
     // final destination.
-    fs.promises.mkdir(msg_dir, { recursive: true })
-        .catch(err => {
-            connection.logerror(this, `Error creating directory: ${msg_dir}`);
-            next();
+    fs.promises
+        .mkdir(msg_dir, { recursive: true })
+        .catch((err) => {
+            connection.logerror(this, `Error creating directory: ${msg_dir}`)
+            next()
         })
-        .then(ok => {
-            const ws = fs.createWriteStream(tmp_path);
+        .then((ok) => {
+            const ws = fs.createWriteStream(tmp_path)
 
-            ws.on('error', err => {
-                connection.logerror(this, `Error writing quarantine file: ${err.message}`);
-                return next();
-            });
+            ws.on('error', (err) => {
+                connection.logerror(this, `Error writing quarantine file: ${err.message}`)
+                return next()
+            })
             ws.on('close', () => {
-                fs.link(tmp_path, msg_path, err => {
+                fs.link(tmp_path, msg_path, (err) => {
                     if (err) {
-                        connection.logerror(this, `Error writing quarantine file: ${err}`);
-                    }
-                    else {
+                        connection.logerror(this, `Error writing quarantine file: ${err}`)
+                    } else {
                         // Add a note to where we stored the message
-                        txn.notes.quarantined = msg_path;
-                        txn.results.add(this, { pass: msg_path, emit: true });
+                        txn.notes.quarantined = msg_path
+                        txn.results.add(this, { pass: msg_path, emit: true })
                         // Now delete the temporary file
-                        fs.unlink(tmp_path, () => {});
+                        fs.unlink(tmp_path, () => {})
                     }
                     // Using notes.quarantine_action to decide what to do after the message is quarantined.
                     // Format can be either action = [ code, msg ] or action = code
-                    const action = (connection.notes.quarantine_action || txn.notes.quarantine_action);
-                    if (!action) return next();
-                    if (Array.isArray(action)) return next(action[0], action[1]);
-                    return next(action);
-                });
-            });
-            txn.message_stream.pipe(ws, { line_endings: '\n' });
-        });
+                    const action = connection.notes.quarantine_action || txn.notes.quarantine_action
+                    if (!action) return next()
+                    if (Array.isArray(action)) return next(action[0], action[1])
+                    return next(action)
+                })
+            })
+            txn.message_stream.pipe(ws, { line_endings: '\n' })
+        })
 }

package/plugins/queue/rabbitmq.js

@@ -1,53 +1,50 @@
-const amqp = require('amqp');
-
-let rabbitqueue;
-let exchangeName;
-let queueName;
-let deliveryMode;
-let connExchange_;
-let connQueue_;
-let routing_;
+const amqp = require('amqp')
+
+let rabbitqueue
+let exchangeName
+let queueName
+let deliveryMode
+let connExchange_
+let connQueue_
+let routing_
 exports.exchangeMapping = {}
 
 //This method registers the hook and try to initialize the connection to rabbitmq server for later use.
 exports.register = function () {
-    this.logdebug("About to connect and initialize queue object");
-    this.init_rabbitmq_server();
-    this.logdebug(`Finished initiating : ${exports.exchangeMapping[exchangeName + queueName]}`);
+    this.logdebug('About to connect and initialize queue object')
+    this.init_rabbitmq_server()
+    this.logdebug(`Finished initiating : ${exports.exchangeMapping[exchangeName + queueName]}`)
 }
 
-
 //Actual magic of publishing message to rabbit when email comes happen here.
 exports.hook_queue = function (next, connection) {
-    if (!connection?.transaction) return next();
+    if (!connection?.transaction) return next()
 
     //Calling the get_data method and when it gets the data on callback, publish the message to queue with routing key.
-    connection.transaction.message_stream.get_data(buffere => {
+    connection.transaction.message_stream.get_data((buffere) => {
         const exchangeData = exports.exchangeMapping[exchangeName + queueName]
-        this.logdebug(`Sending the data: ${ queueName} Routing : ${exchangeData} exchange :${connExchange_}`);
+        this.logdebug(`Sending the data: ${queueName} Routing : ${exchangeData} exchange :${connExchange_}`)
         if (connExchange_ && routing_) {
             //This is publish function of rabbitmq amqp library, currently direct queue is configured and routing is fixed.
             //Needs to be changed.
-            connExchange_.publish(routing_, buffere,{deliveryMode}, error => {
+            connExchange_.publish(routing_, buffere, { deliveryMode }, (error) => {
                 if (error) {
                     //There was some error while sending the email to queue.
-                    this.logdebug("queueFailure: #{JSON.stringify(error)}");
-                    exports.init_rabbitmq_server();
-                    next();
-                }
-                else {
+                    this.logdebug('queueFailure: #{JSON.stringify(error)}')
+                    exports.init_rabbitmq_server()
+                    next()
+                } else {
                     //Queueing was successful, send ok as reply
-                    this.logdebug( "queueSuccess");
-                    next(OK,"Successfully Queued! in rabbitmq");
+                    this.logdebug('queueSuccess')
+                    next(OK, 'Successfully Queued! in rabbitmq')
                 }
-            });
-        }
-        else {
+            })
+        } else {
             //Seems like connExchange is not defined , lets create one for next call
-            exports.init_rabbitmq_server();
-            next();
+            exports.init_rabbitmq_server()
+            next()
         }
-    });
+    })
 }
 
 //This initializes the connection to rabbitmq server, It reads values from rabbitmq.ini file in config directory.
@@ -55,52 +52,48 @@ exports.init_rabbitmq_server = function () {
     // this is called during init of rabbitmq
 
     //Read the config file rabbitmq
-    const config     = this.config.get('rabbitmq.ini');
+    const config = this.config.get('rabbitmq.ini')
     //Just putting the defaults
-    const options = {};
-    let confirm = true;
-    let durable = true;
-    let autoDelete = false;
-    let exchangeType = 'direct';
+    const options = {}
+    let confirm = true
+    let durable = true
+    let autoDelete = false
+    let exchangeType = 'direct'
 
     //Getting the values from config file rabbitmq.ini
     if (config.rabbitmq) {
-        options.host = config.rabbitmq.server_ip || '127.0.0.1';
-        options.port = config.rabbitmq.server_port || '5672';
-        options.login = config.rabbitmq.user || 'guest';
-        options.password = config.rabbitmq.password || 'guest';
-        exchangeName = config.rabbitmq.exchangeName || 'emailMessages';
-        exchangeType = config.rabbitmq.exchangeType || 'direct';
-        confirm = config.rabbitmq.confirm === 'true'|| true;
-        durable = config.rabbitmq.durable === 'true'|| true;
-        autoDelete = config.rabbitmq.autoDelete === 'true' || false;
-        deliveryMode = config.rabbitmq.deliveryMode || 2;
-        queueName = config.rabbitmq.queueName || 'emails';
-    }
-    else {
+        options.host = config.rabbitmq.server_ip || '127.0.0.1'
+        options.port = config.rabbitmq.server_port || '5672'
+        options.login = config.rabbitmq.user || 'guest'
+        options.password = config.rabbitmq.password || 'guest'
+        exchangeName = config.rabbitmq.exchangeName || 'emailMessages'
+        exchangeType = config.rabbitmq.exchangeType || 'direct'
+        confirm = config.rabbitmq.confirm === 'true' || true
+        durable = config.rabbitmq.durable === 'true' || true
+        autoDelete = config.rabbitmq.autoDelete === 'true' || false
+        deliveryMode = config.rabbitmq.deliveryMode || 2
+        queueName = config.rabbitmq.queueName || 'emails'
+    } else {
         //If config file is not available , lets get the default values
-        queueName = 'emails';
-        exchangeName = 'emailMessages';
-        deliveryMode = 2;
-        durable = true;
+        queueName = 'emails'
+        exchangeName = 'emailMessages'
+        deliveryMode = 2
+        durable = true
     }
 
-
     //Create connection to the rabbitmq server
-    this.logdebug("About to Create connection with server");
-    rabbitqueue = amqp.createConnection(options);
-
+    this.logdebug('About to Create connection with server')
+    rabbitqueue = amqp.createConnection(options)
 
     //Declaring listerner on error on connection.
-    rabbitqueue.on('error', error => {
-        this.logerror(`There was some error on the connection : ${error}`);
-    });
+    rabbitqueue.on('error', (error) => {
+        this.logerror(`There was some error on the connection : ${error}`)
+    })
 
     //Declaring listerner on close on connection.
-    rabbitqueue.on('close', close => {
-        this.logdebug(` Connection  is being closed : ${close}`);
-    });
-
+    rabbitqueue.on('close', (close) => {
+        this.logdebug(` Connection  is being closed : ${close}`)
+    })
 
     /* Declaring the function to perform when connection is established and ready, function involves like:
      *    1. Creating or connecting to Exchange.
@@ -110,39 +103,39 @@ exports.init_rabbitmq_server = function () {
      */
 
     rabbitqueue.on('ready', () => {
-        this.logdebug("Connection is ready, will try making exchange");
+        this.logdebug('Connection is ready, will try making exchange')
         // Now connection is ready will try to open exchange with config data.
-        rabbitqueue.exchange(exchangeName, {  type: exchangeType,  confirm,  durable }, connExchange => {
-
-
-            this.logdebug(`connExchange with server ${connExchange} autoDelete : ${autoDelete}`);
+        rabbitqueue.exchange(exchangeName, { type: exchangeType, confirm, durable }, (connExchange) => {
+            this.logdebug(`connExchange with server ${connExchange} autoDelete : ${autoDelete}`)
 
             //Exchange is now open, will try to open queue.
-            return rabbitqueue.queue(queueName,{autoDelete, durable }, connQueue => {
-                this.logdebug(`connQueue with server ${connQueue}`);
+            return rabbitqueue.queue(queueName, { autoDelete, durable }, (connQueue) => {
+                this.logdebug(`connQueue with server ${connQueue}`)
 
                 //Creating the Routing key to bind the queue and exchange.
-                const routing = `${queueName}Routing`;
+                const routing = `${queueName}Routing`
 
                 // Will try to bing queue and exchange which was created above.
-                connQueue.bind(connExchange, routing);
-                const key = exchangeName + queueName;
+                connQueue.bind(connExchange, routing)
+                const key = exchangeName + queueName
 
                 //Save the variables for publising later.
                 if (!exports.exchangeMapping[key]) {
-                    exports.exchangeMapping[key] = [];
+                    exports.exchangeMapping[key] = []
                 }
-                connExchange_ = connExchange;
-                connQueue_ = connQueue;
-                routing_ = routing;
+                connExchange_ = connExchange
+                connQueue_ = connQueue
+                routing_ = routing
                 exports.exchangeMapping[key].push({
-                    exchange : connExchange_,
-                    queue : connQueue_,
-                    routing : routing_,
-                    queueName
-                });
-                this.logdebug(`exchange: ${exchangeName}, queue: ${queueName}  exchange : ${connExchange_} queue : ${connQueue_}` );
-            });
-        });
-    });
+                    exchange: connExchange_,
+                    queue: connQueue_,
+                    routing: routing_,
+                    queueName,
+                })
+                this.logdebug(
+                    `exchange: ${exchangeName}, queue: ${queueName}  exchange : ${connExchange_} queue : ${connQueue_}`,
+                )
+            })
+        })
+    })
 }

package/plugins/queue/rabbitmq_amqplib.js

@@ -1,75 +1,96 @@
 // queue/rabbitmq_amqplib
 
-const amqp = require("amqplib/callback_api");
+const amqp = require('amqplib/callback_api')
 
-let channel;
-let queue;
-let deliveryMode;
+let channel
+let queue
+let deliveryMode
+let priority
 
 exports.register = function () {
-    this.init_amqp_connection();
+    this.init_amqp_connection()
 }
 
 exports.rabbitmq_queue = function (next, connection) {
-    if (!connection?.transaction) return next();
+    if (!connection?.transaction) return next()
 
-    connection.transaction.message_stream.get_data(str => {
-        if (channel?.sendToQueue(queue, str, {deliveryMode})) {
-            return next(OK);
+    connection.transaction.message_stream.get_data((str) => {
+        const sendOptions = { deliveryMode }
+        if (priority != null) {
+            sendOptions.priority = priority
         }
-        else {
-            this.logerror("Failed to queue to rabbitmq");
-            return next();
+        if (channel?.sendToQueue(queue, str, sendOptions)) {
+            return next(OK)
+        } else {
+            this.logerror('Failed to queue to rabbitmq')
+            return next()
         }
-    });
+    })
 }
 
 exports.init_amqp_connection = function () {
-    const cfg = this.config.get("rabbitmq.ini").rabbitmq;
+    const cfg = this.config.get('rabbitmq.ini').rabbitmq
 
-    const protocol = cfg.protocol || "amqp";
-    const host = cfg.host || "127.0.0.1";
-    const port = cfg.port || "5672";
-    const vhost = cfg.vhost || "";
-    const user = cfg.user || "guest";
-    const password = cfg.password || "guest";
-    const exchangeName = cfg.exchangeName || "emailMessages";
-    const exchangeType = cfg.exchangeType || "direct";
-    const queueName = cfg.queueName || "emails";
-    const durable = cfg.durable === "true" || true;
+    const protocol = cfg.protocol || 'amqp'
+    const host = cfg.host || '127.0.0.1'
+    const port = cfg.port || '5672'
+    const vhost = cfg.vhost || ''
+    const user = cfg.user || 'guest'
+    const password = cfg.password || 'guest'
+    const exchangeName = cfg.exchangeName || 'emailMessages'
+    const exchangeType = cfg.exchangeType || 'direct'
+    const queueName = cfg.queueName || 'emails'
+    const durable = cfg.durable === 'true' || true
     // var confirm = cfg.confirm === "true" || true;
-    const autoDelete = cfg.autoDelete === "true" || false;
-    deliveryMode = cfg.deliveryMode || 2;
+    const autoDelete = cfg.autoDelete === 'true' || false
+    deliveryMode = cfg.deliveryMode || 2
+    priority = cfg.priority
 
-    amqp.connect(`${protocol}://${encodeURIComponent(user)}:${encodeURIComponent(password)}@${host}:${port}${vhost}`, (err, conn) => {
-        if (err) {
-            this.logerror(`Connection to rabbitmq failed: ${err}`);
-            return;
-        }
-        // TODO: if !confirm conn.createChannel...
-        conn.createConfirmChannel((err2, ch) => {
-            if (err2) {
-                this.logerror(`Error creating rabbitmq channel: ${err2}`);
-                return conn.close();
+    amqp.connect(
+        `${protocol}://${encodeURIComponent(user)}:${encodeURIComponent(password)}@${host}:${port}${vhost}`,
+        (err, conn) => {
+            if (err) {
+                this.logerror(`Connection to rabbitmq failed: ${err}`)
+                return
             }
-            ch.assertExchange(exchangeName, exchangeType, {durable}, (err3, ok) => {
-                if (err3) {
-                    this.logerror(`Error asserting rabbitmq exchange: ${err3}`);
-                    return conn.close();
+            // TODO: if !confirm conn.createChannel...
+            conn.createConfirmChannel((err2, ch) => {
+                if (err2) {
+                    this.logerror(`Error creating rabbitmq channel: ${err2}`)
+                    return conn.close()
                 }
-                ch.assertQueue(queueName,
-                    {durable, autoDelete, arguments: this.config.get("rabbitmq.ini").queue_args},
-                    (err4, ok2) => {
-                        if (err4) {
-                            this.logerror(`Error asserting rabbitmq queue: ${err4}`);
-                            return conn.close();
+                ch.assertExchange(
+                    exchangeName,
+                    exchangeType,
+                    {
+                        durable,
+                        arguments: this.config.get('rabbitmq.ini').exchange_args,
+                    },
+                    (err3, ok) => {
+                        if (err3) {
+                            this.logerror(`Error asserting rabbitmq exchange: ${err3}`)
+                            return conn.close()
                         }
-                        queue = ok2.queue;
-                        channel = ch;
-                        this.register_hook('queue', 'rabbitmq_queue');
-                    }
-                );
-            });
-        });
-    });
+                        ch.assertQueue(
+                            queueName,
+                            {
+                                durable,
+                                autoDelete,
+                                arguments: this.config.get('rabbitmq.ini').queue_args,
+                            },
+                            (err4, ok2) => {
+                                if (err4) {
+                                    this.logerror(`Error asserting rabbitmq queue: ${err4}`)
+                                    return conn.close()
+                                }
+                                queue = ok2.queue
+                                channel = ch
+                                this.register_hook('queue', 'rabbitmq_queue')
+                            },
+                        )
+                    },
+                )
+            })
+        },
+    )
 }

package/plugins/queue/smtp_bridge.js

@@ -2,37 +2,37 @@
 // Overrides the MX and sets the same AUTH user and password
 
 exports.register = function () {
-    this.load_flat_ini();
+    this.load_flat_ini()
 }
 
 exports.load_flat_ini = function () {
     this.cfg = this.config.get('smtp_bridge.ini', () => {
-        this.load_flat_ini();
-    });
+        this.load_flat_ini()
+    })
 }
 
 exports.hook_data_post = (next, connection) => {
-    const txn = connection?.transaction;
-    if (!txn) return next();
+    const txn = connection?.transaction
+    if (!txn) return next()
 
     // Copy auth notes to transaction notes so they're available in hmail.todo.notes
-    txn.notes.auth_user = connection.notes.auth_user;
-    txn.notes.auth_passwd = connection.notes.auth_passwd;
-    return next();
+    txn.notes.auth_user = connection.notes.auth_user
+    txn.notes.auth_passwd = connection.notes.auth_passwd
+    return next()
 }
 
 exports.hook_get_mx = function (next, hmail, domain) {
-    let priority = 10;
+    let priority = 10
     if (this.cfg.main.priority) {
-        priority = this.cfg.main.priority;
+        priority = this.cfg.main.priority
     }
-    let authType = null;
+    let authType = null
     if (this.cfg.main.auth_type) {
-        authType = this.cfg.main.auth_type;
+        authType = this.cfg.main.auth_type
     }
-    let port = null;
+    let port = null
     if (this.cfg.main.port) {
-        port = this.cfg.main.port;
+        port = this.cfg.main.port
     }
     return next(OK, {
         priority,
@@ -40,6 +40,6 @@ exports.hook_get_mx = function (next, hmail, domain) {
         port,
         auth_type: authType,
         auth_user: hmail.todo.notes.auth_user,
-        auth_pass: hmail.todo.notes.auth_passwd
-    });
+        auth_pass: hmail.todo.notes.auth_passwd,
+    })
 }