haraka/haraka-plugin-ldap

'use strict';

const util = require('util');
const Address = require('address-rfc2821').Address;
const constants = require('haraka-constants');

exports._get_alias = function (address, callback, connection) {
    const pool = connection.server.notes.ldappool;
    if (!pool) {
        return onError('LDAP Pool not found!');
    }
    function onError(err) {
        connection.logerror(`Could not resolve ${address} as alias`);
        connection.logdebug(`${util.inspect(err)}`);
        callback(err, false);
    }
    const search = (err, client) => {
        if (err) return onError(err);

        const config = this._get_search_conf_alias(address, connection);
        connection.logdebug(`Checking address for alias: ${util.inspect(config)}`);
        try {
            client.search(config.basedn, config, (search_error, res) => {
                if (search_error) {
                    onError(search_error);
                }
                let alias = [];
                res.on('searchEntry', (entry) => {
                    alias = alias.concat(entry.object[config.attributes[0]]);
                });
                res.on('error', onError);
                res.on('end', () => {
                    if (pool.config.aliases.attribute_is_dn) {
                        this._resolve_dn_to_alias(alias, callback, connection);
                    } else {
                        callback(null, alias);
                    }
                });
            });
        } catch (e) {
            onError(e);
        }
    };
    pool.get(search);
};

exports._get_search_conf_alias = (address, connection) => {
    const pool = connection.server.notes.ldappool;
    let filter =
    pool.config.aliases.searchfilter ||
    '(&(objectclass=*)(mail=%a)(mailForwardAddress=*))';
    filter = filter.replace(/%a/g, address);
    return {
        basedn: pool.config.aliases.basedn || pool.config.basedn,
        filter,
        scope: pool.config.aliases.scope || pool.config.scope,
        attributes: [pool.config.aliases.attribute || 'mailForwardingAddress'],
    };
};

exports._resolve_dn_to_alias = (dn, callback, connection) => {
    const pool = connection.server.notes.ldappool;
    if (!pool) {
        return onError('LDAP Pool not found!');
    }
    function onError(err) {
        connection.logerror(
            `Could not get address for DN ${util.inspect(dn)}: ${util.inspect(err)}`,
        );
        callback(err);
    }
    const config = {
        scope: 'base',
        attributes: [pool.config.aliases.subattribute || 'mailLocalAddress'],
    };

    pool.get((err, client) => {
        if (err) return onError(err);
        connection.logdebug(
            `Resolving DN ${util.inspect(dn)} to alias: ${util.inspect(config)}`,
        );

        const promises = [];
        for (const d of dn) {
            promises.push(
                new Promise((resolve) => {
                    const entries = [];

                    client.search(d, config, (search_error, res) => {
                        if (search_error) onError(search_error, d);

                        res.on('searchEntry', (entry) => {
                            const arr_addr = entry.object[config.attributes[0]];
                            entries.push(Array.isArray(arr_addr) ? arr_addr[0] : arr_addr);
                        });

                        res.on('error', (e) => {
                            connection.logwarn(`Could not retrieve DN ${util.inspect(d)}`);
                            connection.logdebug(`${util.inspect(e)}`);
                            resolve([]);
                        });

                        res.on('end', (r) => {
                            resolve(entries);
                        });
                    });
                }),
            );
        }

        Promise.all(promises)
            .then((res) => {
                callback(null, res.flat());
            })
            .catch((e) => {
                connection.logerror(`AllResolvedErr: ${e}`);
            });
    });
};

exports.aliases = function (next, connection, params) {
    if (!params || !params[0] || !params[0].address) {
        connection.logerror(
            `Ignoring invalid call. Given params: ${util.inspect(params)}`,
        );
        return next();
    }
    const rcpt = params[0].address();
    this._get_alias(
        rcpt,
        (err, result) => {
            if (err) {
                connection.logerror(
                    `Could not use LDAP to resolve aliases: ${err.message}`,
                );
                return next(constants.denysoft);
            }
            if (result.length === 0) {
                connection.logdebug(
                    `No aliases results found for rcpt: ${util.inspect(rcpt)}`,
                );
                return next();
            }
            connection.logdebug(
                this,
                `Aliasing ${util.inspect(rcpt)} to ${util.inspect(result)}`,
            );
            connection.transaction.rcpt_to.pop();
            for (const element of result) {
                const toAddress = new Address(`<${element}>`);
                connection.transaction.rcpt_to.push(toAddress);
            }
            next();
        },
        connection,
    );
};