All files / node-activedirectory/lib/services/internal/search service.search.onReferralChase.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
1x
1x
1x
1x
1x
1x
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1x
const limitpromises                     = require('limitpromises');
const Url                               = require('url');
const removeReferral                    = require('./service.search.removeReferral');
const pendingReferrals                  = require('./service.search.pendingReferrals');
const isAllowedReferral                 = require('../service.isAllowedReferral');
const createClient                      = require('../service.createClient');
 
    
    
/**
 * Occurs when a search reference / referral is received. Follows the referral chase if
 * enabled.
 * @param {Object} self The ActiveDirectory Object
 * @param {Object} ref The referral.
 * @param {Function} resolve Resolve the Search
 * @param {Function} reject Reject the search
 */
function onReferralChase(self, client, baseDN, ref, opts, controls, results, resolve, reject) {
    var index = 0;
    var referralUrl;
 
    
    // Loop over the referrals received.
    while (referralUrl = (ref.uris || [])[index++]) {
        if (isAllowedReferral(referralUrl)) {
           
            
            log.debug('Following LDAP referral chase at %s', referralUrl);
            var referralClient = createClient.call(self, referralUrl, opts);
            pendingReferrals.push(referralClient);
 
            var referral = Url.parse(referralUrl);
            var referralBaseDn = (referral.pathname || '/').substring(1);
 
            
            let refCliSearch = limitpromises(Input => {
                return new Promise((resolve, reject) => {
                    referralClient.search(referralBaseDn, getLdapOpts(opts), controls, (err, res) => {
                        
                        // If the referral chase / search failed, fail silently.
                        if (err) {
                            onReferralError(err);
                            return;
                        }
 
                        return resolve(res);
                    });
                })
            }, [true], self.opts.maxSearchesAtOnce || maxPromiseConfig.maxSearchesAtOnce, "searches", maxPromiseConfig.searchTimeoutAndReject)
            
            Promise.all(refCliSearch.map(r => {return r.result})).then(results => {
                let res = results[0];
                res.on('searchEntry', entry => {
                    onSearchEntry(entry, client, baseDN, self, opts, isDone, results, resolve, reject);
                });
                res.on('searchReference', ref => {
                    onReferralChase(self, client, baseDN, ref, opts, controls, results, resolve, reject); 
                });
                res.on('error', onReferralError);
                res.on('end', function (result) {
                    removeReferral(referralClient);
                });
            });
        }
    }
}
 
/**
* Occurs when a error is encountered with the referral client.
* @param {Object} err The error object or string.
* @param {}
*/
function onReferralError(err, referralBaseDn, opts, referralClient) {
    log.error(err, '[%s] An error occurred chasing the LDAP referral on %s (%j)',
        (err || {}).errno, referralBaseDn, opts);
    removeReferral(referralClient);
}
 
module.exports = onReferralChase;