node-ldapjs/lib/errors/index.js at master · ldapjs/node-ldapjs · GitHub

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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
'use strict'

const util = require('util')
const assert = require('assert-plus')

const LDAPResult = require('../messages').LDAPResult

/// --- Globals

const CODES = require('./codes')
const ERRORS = []

/// --- Error Base class

function LDAPError (message, dn, caller) {
  if (Error.captureStackTrace) { Error.captureStackTrace(this, caller || LDAPError) }

  this.lde_message = message
  this.lde_dn = dn
}
util.inherits(LDAPError, Error)
Object.defineProperties(LDAPError.prototype, {
  name: {
    get: function getName () { return 'LDAPError' },
    configurable: false
  },
  code: {
    get: function getCode () { return CODES.LDAP_OTHER },
    configurable: false
  },
  message: {
    get: function getMessage () {
      return this.lde_message || this.name
    },
    set: function setMessage (message) {
      this.lde_message = message
    },
    configurable: false
  },
  dn: {
    get: function getDN () {
      return (this.lde_dn ? this.lde_dn.toString() : '')
    },
    configurable: false
  }
})

/// --- Exported API

module.exports = {}
module.exports.LDAPError = LDAPError

// Some whacky games here to make sure all the codes are exported
Object.keys(CODES).forEach(function (code) {
  module.exports[code] = CODES[code]
  if (code === 'LDAP_SUCCESS') { return }

  let err = ''
  let msg = ''
  const pieces = code.split('_').slice(1)
  for (let i = 0; i < pieces.length; i++) {
    const lc = pieces[i].toLowerCase()
    const key = lc.charAt(0).toUpperCase() + lc.slice(1)
    err += key
    msg += key + ((i + 1) < pieces.length ? ' ' : '')
  }

  if (!/\w+Error$/.test(err)) { err += 'Error' }

  // At this point LDAP_OPERATIONS_ERROR is now OperationsError in $err
  // and 'Operations Error' in $msg
  module.exports[err] = function (message, dn, caller) {
    LDAPError.call(this, message, dn, caller || module.exports[err])
  }
  module.exports[err].constructor = module.exports[err]
  util.inherits(module.exports[err], LDAPError)
  Object.defineProperties(module.exports[err].prototype, {
    name: {
      get: function getName () { return err },
      configurable: false
    },
    code: {
      get: function getCode () { return CODES[code] },
      configurable: false
    }
  })

  ERRORS[CODES[code]] = {
    err,
    message: msg
  }
})

module.exports.getError = function (res) {
  assert.ok(res instanceof LDAPResult, 'res (LDAPResult) required')

  const errObj = ERRORS[res.status]
  const E = module.exports[errObj.err]
  return new E(res.errorMessage || errObj.message,
    res.matchedDN || null,
    module.exports.getError)
}

module.exports.getMessage = function (code) {
  assert.number(code, 'code (number) required')

  const errObj = ERRORS[code]
  return (errObj && errObj.message ? errObj.message : '')
}

/// --- Custom application errors

function ConnectionError (message) {
  LDAPError.call(this, message, null, ConnectionError)
}
util.inherits(ConnectionError, LDAPError)
module.exports.ConnectionError = ConnectionError
Object.defineProperties(ConnectionError.prototype, {
  name: {
    get: function () { return 'ConnectionError' },
    configurable: false
  }
})

function AbandonedError (message) {
  LDAPError.call(this, message, null, AbandonedError)
}
util.inherits(AbandonedError, LDAPError)
module.exports.AbandonedError = AbandonedError
Object.defineProperties(AbandonedError.prototype, {
  name: {
    get: function () { return 'AbandonedError' },
    configurable: false
  }
})

function TimeoutError (message) {
  LDAPError.call(this, message, null, TimeoutError)
}
util.inherits(TimeoutError, LDAPError)
module.exports.TimeoutError = TimeoutError
Object.defineProperties(TimeoutError.prototype, {
  name: {
    get: function () { return 'TimeoutError' },
    configurable: false
  }
})