├── tests
    ├── config.nims
    ├── test_asn1.nim
    ├── test_sync.nim
    └── test_async.nim
├── examples
    ├── config.nims
    ├── dump_sync.nim
    ├── dump_async.nim
    └── listen_async.nim
├── config.nims
├── src
    ├── nimldap.nim
    └── nimldap
    │   ├── tinyasn1.nim
    │   ├── sync.nim
    │   ├── async.nim
    │   ├── shared.nim
    │   └── bindings.nim
├── .gitignore
├── README.md
├── nimldap.nimble
└── .github
    └── workflows
        └── test.yaml


/tests/config.nims:
--------------------------------------------------------------------------------
1 | switch("path", "$projectDir/../src")
2 | 


--------------------------------------------------------------------------------
/examples/config.nims:
--------------------------------------------------------------------------------
1 | switch("path", "$projectDir/../src")
2 | 


--------------------------------------------------------------------------------
/config.nims:
--------------------------------------------------------------------------------
1 | switch("gc", "orc")
2 | switch("define", "useMalloc")
3 | 


--------------------------------------------------------------------------------
/src/nimldap.nim:
--------------------------------------------------------------------------------
1 | import nimldap/sync
2 | import nimldap/async
3 | 
4 | export sync
5 | export async
6 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | tests/test_asn1
2 | tests/test_async
3 | tests/test_sync
4 | examples/dump_sync
5 | examples/dump_async
6 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | [![Tests](https://github.com/inv2004/nimldap/actions/workflows/test.yaml/badge.svg)](https://github.com/inv2004/nimldap/actions/workflows/test.yaml)
 2 | 
 3 | # nimldap
 4 | 
 5 | - [x] sync
 6 | - [x] async
 7 | - [x] custom controls
 8 | - [x] LDAP_PAGED_RESULT_OID_STRING control support. via ```pageSize``` parameter
 9 | - [x] LDAP_SERVER_NOTIFICATION_OID in async
10 | 
11 | ## Examples
12 | https://github.com/inv2004/nimldap/tree/main/examples
13 | 


--------------------------------------------------------------------------------
/nimldap.nimble:
--------------------------------------------------------------------------------
 1 | # Package
 2 | 
 3 | version       = "0.5.3"
 4 | author        = "inv2004"
 5 | description   = "LDAP client bindings"
 6 | license       = "MIT"
 7 | srcDir        = "src"
 8 | 
 9 | 
10 | # Dependencies
11 | 
12 | requires "nim >= 1.6.8"
13 | requires "stew"
14 | 
15 | task fulltest, "valgrind memleak":
16 |   for f in listFiles("tests"):
17 |     if f.endsWith ".nim":
18 |       exec "nim c --forceBuild --gc:orc -d:useMalloc " & f
19 |       exec "valgrind --error-exitcode=1 --leak-check=yes --errors-for-leak-kinds=definite " & f[0..^5]
20 | 


--------------------------------------------------------------------------------
/examples/dump_sync.nim:
--------------------------------------------------------------------------------
 1 | import nimldap
 2 | import strutils
 3 | import strformat
 4 | 
 5 | const host = "ldap://ldap.forumsys.com:389"
 6 | const login = "cn=read-only-admin,dc=example,dc=com"
 7 | const pass = "password"
 8 | 
 9 | let ld = newLdap host
10 | ld.saslBind login, pass
11 | echo ld.whoAmI()
12 | 
13 | for entry in ld.search("(objectclass=*)", ["+", "*"], LdapScope.Base, ""):
14 |   echo entry.dn()
15 |   for attr, vals in entry:
16 |     echo fmt"""  {attr} ({vals.len}): {(vals.values().join", ")}"""
17 | 
18 | for entry in ld.search "(objectclass=*)":
19 |   echo entry.dn()
20 |   for attr, vals in entry:
21 |     echo fmt"""  {attr} ({vals.len}): {(vals.values().join", ")}"""
22 | 


--------------------------------------------------------------------------------
/examples/dump_async.nim:
--------------------------------------------------------------------------------
 1 | import asyncdispatch
 2 | import strutils
 3 | import strformat
 4 | 
 5 | import nimldap
 6 | 
 7 | const host = "ldap://ldap.forumsys.com:389"
 8 | const login = "cn=read-only-admin,dc=example,dc=com"
 9 | const pass = "password"
10 | 
11 | proc main() {.async.} =
12 |   let ld = newLdapAsync host
13 |   await ld.saslBind(login, pass)
14 |   echo waitFor ld.whoAmI()
15 |   let s = ld.search "(objectclass=*)"
16 |   while true:
17 |     let entry = await s.next()
18 |     if entry.done:
19 |       break
20 |     echo entry.dn()
21 |     for attr in entry:
22 |       let vals = entry{attr}
23 |       echo fmt"""  {attr} ({vals.len}): {(vals.join", ")}"""
24 | 
25 | waitFor main()
26 | 


--------------------------------------------------------------------------------
/.github/workflows/test.yaml:
--------------------------------------------------------------------------------
 1 | name: "Tests"
 2 | 
 3 | on: [push]
 4 | 
 5 | jobs:
 6 |   test:
 7 |     timeout-minutes: 10
 8 |     strategy:
 9 |       matrix:
10 |         nim: [ 'stable' ]
11 |         os: [ 'ubuntu-20.04' ]
12 |     runs-on: ${{ matrix.os }}
13 |     steps:
14 |       - name: install ldap2 valgrind
15 |         run: sudo apt install libldap2-dev valgrind -y
16 |       - uses: actions/checkout@v2
17 |       # - uses: actions/cache@v2
18 |       #   with:
19 |       #     path: ~/.nimble
20 |       #     key: ${{ runner.os }}-nimble-${{ hashFiles('*.nimble') }}
21 |       - uses: jiro4989/setup-nim-action@v1
22 |         with:
23 |           nim-version: ${{ matrix.nim }}
24 |       - run: nim --version && nimble install -d -y && nimble fulltest -y
25 | 


--------------------------------------------------------------------------------
/tests/test_asn1.nim:
--------------------------------------------------------------------------------
 1 | import unittest
 2 | import strutils
 3 | 
 4 | import nimldap/tinyasn1
 5 | 
 6 | test "encode":
 7 |   check newAsnInt(33).toHex == "020121"
 8 |   check newAsnInt(333).toHex == "0202014D"
 9 |   check newAsnString("r".repeat 33).toHex == "0421" & "72".repeat 33
10 |   check newAsnString("r".repeat 333).toHex == "0482014D" & "72".repeat 333
11 |   check newAsnString("r".repeat 3333).toHex == "04820D05" & "72".repeat 3333
12 |   check newPagingValue(7, "").toHex == "30050201070400"
13 |   check newPagingValue(18, "").toHex == "30050201120400"
14 |   check newPagingValue(5000, "abc").toHex == "3009020213880403616263"
15 |   check newPagingValue(5000, "r".repeat 5000).toHex == "308213900202138804821388" & "72".repeat 5000
16 | 
17 | test "decode":
18 |   check newPagingValue(7, "").readPagingValues == (7, "")
19 |   check newPagingValue(18, "").readPagingValues == (18, "")
20 |   check newPagingValue(5000, "abc").readPagingValues == (5000, "abc")
21 |   check newPagingValue(5000, "r".repeat 5000).readPagingValues == (5000, "r".repeat 5000)
22 | 


--------------------------------------------------------------------------------
/examples/listen_async.nim:
--------------------------------------------------------------------------------
 1 | import asyncdispatch
 2 | import strutils
 3 | import xmlparser
 4 | import xmltree
 5 | import sequtils
 6 | 
 7 | import nimldap
 8 | 
 9 | # The server does not support LDAP_SERVER_NOTIFICATION_OID
10 | const host = "ldap://ldap.forumsys.com:389"
11 | const login = "read-only-admin@example.com"
12 | const pass = "password"
13 | 
14 | let ctrls = @[newCtrl Extension.LDAP_SERVER_NOTIFICATION_OID]
15 | 
16 | proc findChange(metas: seq[string]) =
17 |   let idx = metas
18 |     .mapIt(parseXml(it))
19 |     .mapIt(it.findAll("usnLocalChange")[0].innerText.parseInt())
20 |     .maxIndex()
21 | 
22 |   echo metas[idx]
23 | 
24 | proc main() {.async.} =
25 |   let ld = newLdapAsync host
26 |   await ld.saslBind(login, pass)
27 |   echo waitFor ld.whoAmI()
28 |   let s = ld.search("(objectclass=*)", attrs = @["+", "*",
29 |       "msDS-ReplAttributeMetaData"], ctrls = ctrls)
30 |   while true:
31 |     let entry = await s.next()
32 |     if entry.done:
33 |       break
34 |     echo entry.dn()
35 |     findChange entry{"msDS-ReplAttributeMetaData"}
36 | 
37 | waitFor main()
38 | 
39 | 


--------------------------------------------------------------------------------
/src/nimldap/tinyasn1.nim:
--------------------------------------------------------------------------------
 1 | import stew/endians2
 2 | import bitops
 3 | import streams
 4 | import bindings
 5 | 
 6 | proc beLen[T: static[int]](be: array[T, byte]): int =
 7 |   var len0 = 0
 8 |   for x in be:
 9 |     if x == 0:
10 |       inc len0
11 |     else:
12 |       break
13 |   be.len - len0
14 | 
15 | proc genLen(len: int): string =
16 |   if len < 0x80:
17 |     result.add len.char
18 |   else:
19 |     let bb = len.uint64.toBytesBE
20 |     let lenlen = bb.beLen
21 |     result.add char(0x80 or lenlen.byte)
22 |     for x in bb[^lenlen..^1]: result.add x.char
23 | 
24 | proc newAsnInt*(size: uint32): string =
25 |   result.add '\x02'
26 |   let be = size.toBytesBE
27 |   let len = be.beLen
28 |   result.add genLen(len)
29 |   for x in be[^len..^1]: result.add x.char
30 | 
31 | proc newAsnString*(s: string): string =
32 |   result.add '\x04'
33 |   result.add genLen(s.len)
34 |   result.add s
35 | 
36 | proc newPagingValue*(size: int, cookie: string): string =
37 |   result.add "\x30"
38 |   let i = newAsnInt(size.uint32)
39 |   let s = newAsnString(cookie)
40 |   result.add genLen((i.len + s.len))
41 |   result.add i
42 |   result.add s
43 | 
44 | proc getLen*(be: openArray[byte]): (int, int) =
45 |   if not be[1].testBit(7):
46 |     return (be[1].int, 1)
47 |   else:
48 |     let lenlen = int(be[1] and 0x7F)
49 |     for i in 2..<2+lenlen:
50 |       result[0] = 256*result[0] + be[i].int
51 |     result[1] = 1+lenlen
52 | 
53 | proc readLen(s: StringStream): int =
54 |   let len0 = s.readUint8
55 |   if len0.testBit(7):
56 |     let lenlen = int(len0 and 0x7F)
57 |     for _ in 0..<lenlen:
58 |       result = result * 256 + s.readUint8.int
59 |   else:
60 |     return len0.int
61 | 
62 | proc inSeq*(s: StringStream) =
63 |   doAssert s.readUint8 == 0x30
64 |   discard s.readLen()
65 | 
66 | proc readInt*(s: StringStream): int =
67 |   doAssert s.readUint8 == 0x02
68 |   let len = s.readLen()
69 |   for _ in 0..<len:
70 |     result = result * 256 + s.readUint8.int
71 | 
72 | proc readString*(s: StringStream): string =
73 |   doAssert s.readUint8 == 0x04
74 |   let len = s.readLen()
75 |   s.readStr(len)
76 | 
77 | proc readPagingValues*(s: string): (int, string) =
78 |   let s = newStringStream s
79 |   s.inSeq()
80 |   result[0] = s.readInt()
81 |   result[1] = s.readString()
82 | 
83 | proc readCook*(b: ptr CtrlInt): string =
84 |   let s = newStringStream $b.val
85 |   s.inSeq()
86 |   discard s.readInt()
87 |   s.readString()
88 | 
89 | 


--------------------------------------------------------------------------------
/tests/test_sync.nim:
--------------------------------------------------------------------------------
 1 | import unittest
 2 | import sequtils
 3 | 
 4 | import nimldap/sync
 5 | 
 6 | const host = "ldap://ldap.forumsys.com:389"
 7 | const login = "cn=read-only-admin,dc=example,dc=com"
 8 | const pass = "password"
 9 | 
10 | # template test(n, body) =
11 | #   block:
12 | #     body
13 | # template check(body) =
14 | #   doAssert body
15 | # template expect(ex, body) =
16 | #   try:
17 | #     body
18 | #     doAssert false
19 | #   except LdapException:
20 | #     discard
21 | 
22 | var ld: LdapRef
23 | 
24 | test "failedBind1":
25 |   expect LdapException:
26 |     let l = newLdap("ldap://error-389389.noway:389")
27 |     l.saslBind(login, pass)
28 | 
29 | test "failedBind2":
30 |   expect LdapException:
31 |     let l = newLdap(host)
32 |     l.saslBind("nouser", pass)
33 | 
34 | test "init":
35 |   ld = newLdap(host)
36 | 
37 | test "bind":
38 |   ld.saslBind(login, pass)
39 | 
40 | test "whoami":
41 |   check "dn:cn=read-only-admin,dc=example,dc=com" == ld.whoAmI()
42 | 
43 | test "count":
44 |   check 21 == ld.count("(objectclass=*)")
45 | 
46 | test "count_with_page":
47 |   check 21 == ld.count("(objectclass=*)", pageSize = 10)
48 | 
49 | test "iterator":
50 |   var eCount = 0
51 |   var aCount = 0
52 |   var aLenCount = 0
53 |   var vCount = 0
54 |   var vLenCount = 0
55 |   for e in ld.search("(objectclass=*)"):
56 |     inc eCount
57 |     for a, vs in e:
58 |       inc aCount
59 |       aLenCount.inc a.len
60 |       for v in vs:
61 |         inc vCount
62 |         vLenCount += len $v
63 |   check 21 == eCount
64 |   check 108 == aCount
65 |   check 613 == aLenCount
66 |   check 170 == vCount
67 |   check 2069 == vLenCount
68 | 
69 | test "search":
70 |   let res = toSeq(ld.search("(objectclass=*)"))
71 |   check "dc=example,dc=com" == res[0].dn()
72 |   check "cn=admin,dc=example,dc=com" == res[1].dn()
73 |   check "uid=newton,dc=example,dc=com" == res[2].dn()
74 |   check @["sn", "objectClass", "uid", "mail", "cn"] == res[
75 |       2].attrs()
76 |   check "newton@ldap.forumsys.com" == res[2]["mail"]
77 |   check @["inetOrgPerson", "organizationalPerson", "person", "top"] == res[2]{"objectClass"}
78 | 
79 | test "search_with_page":
80 |   let res = toSeq(ld.search("(objectclass=*)", pageSize = 10))
81 |   check "dc=example,dc=com" == res[0].dn()
82 |   check "cn=admin,dc=example,dc=com" == res[1].dn()
83 |   check "uid=newton,dc=example,dc=com" == res[2].dn()
84 |   check @["sn", "objectClass", "uid", "mail", "cn"] == res[
85 |       2].attrs()
86 |   check "newton@ldap.forumsys.com" == res[2]["mail"]
87 |   check @["inetOrgPerson", "organizationalPerson", "person", "top"] == res[2]{"objectClass"}
88 | 
89 | test "controls_fail":
90 |   expect LdapException:
91 |     discard toSeq ld.search("(objectclass=*)", ctrls = @[newCtrl(
92 |         "1.2.840.113556.1.4.801")])
93 | 
94 | test "unbind":
95 |   ld.unbind()
96 | 


--------------------------------------------------------------------------------
/tests/test_async.nim:
--------------------------------------------------------------------------------
 1 | import unittest
 2 | import std/asyncdispatch
 3 | 
 4 | import nimldap
 5 | 
 6 | const host = "ldap://ldap.forumsys.com:389"
 7 | const login = "cn=read-only-admin,dc=example,dc=com"
 8 | const pass = "password"
 9 | 
10 | # template test(n, body) =
11 | #   block:
12 | #     body
13 | # template check(body) =
14 | #   doAssert body
15 | 
16 | var ld: LdapAsyncRef
17 | 
18 | test "init":
19 |   ld = newLdapAsync(host)
20 | 
21 | test "bind":
22 |   waitFor ld.saslBind(login, pass)
23 | 
24 | test "whoami":
25 |   check "dn:cn=read-only-admin,dc=example,dc=com" == waitFor ld.whoAmI()
26 | 
27 | test "count":
28 |   check 21 == waitFor ld.count("(objectclass=*)")
29 | 
30 | test "count_with_page":
31 |   check 21 == waitFor ld.count("(objectclass=*)", pageSize = 10)
32 | 
33 | test "search":
34 |   var res = newSeq[EntryAsync]()
35 |   let s = ld.search("(objectclass=*)")
36 |   while true:
37 |     let e = waitFor s.next()
38 |     if e.done:
39 |       break
40 |     res.add e
41 |   check 21 == res.len
42 |   check "dc=example,dc=com" == res[0].dn()
43 |   check "cn=admin,dc=example,dc=com" == res[1].dn()
44 |   check "uid=newton,dc=example,dc=com" == res[2].dn()
45 |   check @["sn", "objectClass", "uid", "mail", "cn"] == res[
46 |       2].attrs()
47 |   check "newton@ldap.forumsys.com" == res[2]["mail"]
48 |   check @["inetOrgPerson", "organizationalPerson", "person", "top"] == res[2]{"objectClass"}
49 | 
50 | test "search_with_page":
51 |   var res = newSeq[EntryAsync]()
52 |   let s = ld.search("(objectclass=*)", pageSize = 10)
53 |   while true:
54 |     let e = waitFor s.next()
55 |     if e.done:
56 |       break
57 |     res.add e
58 |   check 21 == res.len
59 |   check "dc=example,dc=com" == res[0].dn()
60 |   check "cn=admin,dc=example,dc=com" == res[1].dn()
61 |   check "uid=newton,dc=example,dc=com" == res[2].dn()
62 |   check @["sn", "objectClass", "uid", "mail", "cn"] == res[
63 |       2].attrs()
64 |   check "newton@ldap.forumsys.com" == res[2]["mail"]
65 |   check @["inetOrgPerson", "organizationalPerson", "person", "top"] == res[2]{"objectClass"}
66 | 
67 | test "iterator":
68 |   var count = 0
69 |   let s = ld.search "(objectclass=*)"
70 |   while true:
71 |     let entry = waitFor s.next()
72 |     if entry.done:
73 |       break
74 |     for attr, vals in entry:
75 |       inc count
76 |   check 108 == count
77 | 
78 | test "iterator_ref":
79 |   var count = 0
80 | 
81 |   proc f() {.async.} =
82 |     let s = ld.search "(objectclass=*)"
83 |     while true:
84 |       let entry = await s.next()
85 |       if entry.done:
86 |         break
87 |       for attr, vals in entry:
88 |         for v in vals:
89 |           inc count
90 | 
91 |   waitFor f()
92 |   check 170 == count
93 | 
94 | # test "controls_fail": TEST FAILED
95 | #   expect LdapException:
96 | #     let s = ld.search("(objectclass=*)", ctrls = @[newCtrl("1.2.840.113556.1.4.801")])
97 | #     discard waitFor s.next()
98 | 


--------------------------------------------------------------------------------
/src/nimldap/sync.nim:
--------------------------------------------------------------------------------
  1 | import bindings
  2 | import shared
  3 | import tinyasn1
  4 | import sequtils
  5 | 
  6 | type SearchObj = object
  7 |   ld: LdapRef
  8 |   filter: string
  9 |   attrs: seq[string]
 10 |   scope: LdapScope
 11 |   base: string
 12 |   limit: int
 13 |   ctrls: seq[Ctrl]
 14 |   pageSize: int
 15 | 
 16 | export LdapRef, EntryAsync, dn, attrs, `$`, `[]`, `{}`, len,
 17 |     LdapException, unbind, items, pairs, attrs, values, pretty,
 18 |     sid, contains, getOrEmpty,
 19 |     LdapScope, newCtrl, newPagingCtrl, Extension
 20 | 
 21 | proc newLdap*(url: string): LdapRef =
 22 |   new(result)
 23 |   checkErr ldap_initialize(result.r, url.cstring)
 24 |   result.setOption(LDAP_OPT_PROTOCOL_VERSION, LdapVersion.V3)
 25 |   result.setOption(LDAP_OPT_NETWORK_TIMEOUT, defaultNetworkTimeout)
 26 | 
 27 | proc saslBind*(ld: LdapRef, login, pass: string, dc = rootDC) =
 28 |   let creds = newBer(pass)
 29 |   checkErr ldap_sasl_bind_s(ld.r, login.cstring, LDAP_SASL_SIMPLE, creds,
 30 |       nil, nil, nil)
 31 |   ld.base = if dc == rootDC: extractDC login else: dc
 32 | 
 33 | proc whoAmI*(ld: LdapRef): string =
 34 |   var auth: Ber
 35 |   checkErr ldap_whoami_s(ld.r, auth.r, nil, nil)
 36 |   $auth.r[]
 37 | 
 38 | # ldapControl := ldap.NewControlString("1.2.840.113556.1.4.801", true, fmt.Sprintf("%c%c%c%c%c", 48, 3, 2, 1, 7))
 39 | 
 40 | proc searchMsg*(self: SearchObj, pageCookie = "",
 41 |     voidAttrs: bool): LdapMessageRef =
 42 |   let base = if self.base == rootDC: self.ld.base else: self.base
 43 |   let attrsC = allocCStringArray(if voidAttrs: @[] else: self.attrs)
 44 |   defer: deallocCStringArray(attrsC)
 45 |   let ctrls = newCtrlsWithPage(self.ctrls, self.pageSize, pageCookie)
 46 |   let msg = LDAPMessageRef()
 47 | 
 48 |   checkErr ldap_search_ext_s(self.ld.r, base.cstring, self.scope.int,
 49 |       self.filter.cstring, attrsC, 0, ctrls.r, nil, nil, self.limit, msg)
 50 | 
 51 |   return msg
 52 | 
 53 | proc search*(ld: LdapRef, filter: string, attrs: openArray[string] = ["*"],
 54 |     scope = LdapScope.SubTree, base = rootDC, limit = 0, ctrls: openArray[
 55 |         Ctrl] = [], pageSize = 0): SearchObj =
 56 |   SearchObj(
 57 |     ld: ld,
 58 |     filter: filter,
 59 |     attrs: toSeq[attrs],
 60 |     scope: scope,
 61 |     base: base,
 62 |     limit: limit,
 63 |     ctrls: toSeq[ctrls],
 64 |     pageSize: if pageSize == 0: ld.pageSize else: pageSize
 65 |   )
 66 | 
 67 | proc count*(s: SearchObj): int =
 68 |   var cookie = ""
 69 |   while true:
 70 |     let msg = s.searchMsg(cookie, true)
 71 |     result += ldap_count_entries(s.ld.r, msg.r)
 72 |     cookie = cookieFromMsg(s.ld, s.pageSize, msg)
 73 |     if cookie == "":
 74 |       break
 75 | 
 76 | proc count*(ld: LdapRef, filter: string, scope = LdapScope.SubTree,
 77 |     base = rootDC, limit = 0, pageSize = 0): int =
 78 |   ld.search(filter, [], scope, base, limit, [], pageSize).count()
 79 | 
 80 | iterator items*(s: SearchObj): Entry =
 81 |   var cookie = ""
 82 |   let ld = s.ld
 83 |   while true:
 84 |     let msg = s.searchMsg(cookie, false)
 85 | 
 86 |     var entry = ldap_first_entry(ld.r, msg.r)
 87 |     while entry != nil:
 88 |       let e = Entry(entry: entry, msg: msg, ld: ld)
 89 |       yield e
 90 |       entry = ldap_next_entry(ld.r, entry)
 91 | 
 92 |     cookie = cookieFromMsg(ld, s.pageSize, msg)
 93 |     if cookie == "":
 94 |       break
 95 | 
 96 | iterator pairs*(s: SearchObj): (int, Entry) =
 97 |   var i = 0
 98 |   for e in s:
 99 |     yield (i, e)
100 |     inc i
101 | 
102 | when isMainModule:
103 |   const host = "ldap://ldap.forumsys.com:389"
104 |   const login = "cn=read-only-admin,dc=example,dc=com"
105 |   const pass = "password"
106 | 
107 |   let ld = newLdap(host)
108 |   ld.saslBind login, pass
109 |   echo ld.whoAmI
110 |   for e in ld.search("(objectclass=*)", pageSize = 5):
111 |     echo e.dn
112 | 


--------------------------------------------------------------------------------
/src/nimldap/async.nim:
--------------------------------------------------------------------------------
  1 | import bindings
  2 | import shared except Entry
  3 | 
  4 | export LdapAsyncRef, EntryAsync, dn, attrs, `$`, `[]`, `{}`, len,
  5 |     LdapException, unbind, items, pairs, attrs, values, pretty,
  6 |     sid, contains, getOrEmpty,
  7 |     LdapScope, newCtrl, newPagingCtrl, Extension
  8 | 
  9 | import std/strutils
 10 | import std/asyncdispatch
 11 | 
 12 | const defaultAsyncSleepMs = 10
 13 | 
 14 | # proc search*(ld: LdapASyncRef, filter: string, attrs: openArray[string] = ["*"],
 15 | #     scope = LdapScope.SubTree, base = rootDC,
 16 | #     limit = 0, ctrls: openArray[Ctrl] = [], pageSize = 0, pageCookie = ""): SearchRef =
 17 | 
 18 | 
 19 | type
 20 |   SearchObjRef = ref object
 21 |     ld: LdapAsyncRef
 22 |     msgId: int
 23 |     msg: LdapMessageRef
 24 |     filter: string
 25 |     attrs: seq[string]
 26 |     scope: LdapScope
 27 |     base: string
 28 |     limit: int
 29 |     ctrls: seq[Ctrl]
 30 |     pageSize: int
 31 | 
 32 | proc newLdapAsync*(url: string): LdapAsyncRef =
 33 |   new(result)
 34 |   checkErr ldap_initialize(result.r, url.cstring)
 35 |   result.setOption(LDAP_OPT_PROTOCOL_VERSION, LdapVersion.V3)
 36 |   result.setOption(LDAP_OPT_NETWORK_TIMEOUT, defaultNetworkTimeout)
 37 | 
 38 | proc waitResult(ld: LdapAsyncRef, msgId: int, waitForAll = false): Future[(
 39 |     LdapMessageRef, int)] {.async.} =
 40 |   let msg = LdapMessageRef()
 41 |   var t = Timeval(sec: 0, nano: 0)
 42 |   var err = 0
 43 |   while err == 0:
 44 |     err = ldap_result(ld.r, msgId, waitForAll.int, t.addr, msg)
 45 |     # echo err.toHex
 46 |     if err == 0:
 47 |       await sleepAsync defaultAsyncSleepMs
 48 |   return (msg, err)
 49 | 
 50 | proc saslBind*(ld: LdapAsyncRef, login, pass: string, dc = rootDC): Future[
 51 |     void] {.async.} =
 52 |   var msgId: int
 53 |   let creds = newBer(pass)
 54 |   checkErr ldap_sasl_bind(ld.r, login.cstring, LDAP_SASL_SIMPLE, creds, nil,
 55 |       nil, msgId)
 56 |   let (msg, _) = await waitResult(ld, msgId)
 57 |   checkErr ldap_parse_sasl_bind_result(ld.r, msg.r, nil, 0)
 58 |   ld.base = if dc == rootDC: extractDC login else: dc
 59 | 
 60 | proc whoAmI*(ld: LdapAsyncRef): Future[string] {.async.} =
 61 |   var msgId: int
 62 |   checkErr ldap_whoami(ld.r, nil, nil, msgId)
 63 |   let (msg, _) = await ld.waitResult(msgId)
 64 |   var auth: Ber
 65 |   checkErr ldap_parse_whoami(ld.r, msg.r, auth)
 66 |   return $auth.r[]
 67 | 
 68 | proc search*(ld: LdapASyncRef, filter: string, attrs: openArray[string] = ["*"],
 69 |     scope = LdapScope.SubTree, base = rootDC,
 70 |     limit = 0, ctrls: openArray[Ctrl] = [], pageSize = 0,
 71 |         pageCookie = ""): SearchObjRef =
 72 |   let base = if base == rootDC: ld.base else: base
 73 |   var msgId: int
 74 |   let attrsC = allocCStringArray(attrs)
 75 |   defer: deallocCStringArray(attrsC)
 76 |   let ctrlsLocal = newCtrlsWithPage(ctrls, pageSize, pageCookie)
 77 |   checkErr ldap_search_ext(ld.r, base.cstring, scope.int,
 78 |       filter, attrsC, 0, ctrlsLocal.r, nil, nil, limit, msgId)
 79 |   SearchObjRef(
 80 |     ld: ld,
 81 |     msgId: msgId,
 82 |     filter: filter,
 83 |     attrs: @attrs,
 84 |     scope: scope,
 85 |     base: base,
 86 |     limit: limit,
 87 |     ctrls: @ctrls,
 88 |     pageSize: if pageSize == 0: ld.pageSize else: pageSize
 89 |   )
 90 | 
 91 | proc next*(s: SearchObjRef): Future[EntryAsync] {.async.} =
 92 |   while true:
 93 |     let (msg, err) = await s.ld.waitResult(s.msgId)
 94 |     if err == 0x65:
 95 |       let cook = cookieFromMsg(s.ld, s.pageSize, msg)
 96 |       if cook != "":
 97 |         let nextSearch = s.ld.search(s.filter, s.attrs, LdapScope.SubTree,
 98 |             s.base, 0, s.ctrls, s.pageSize, cook)
 99 |         s.msgId = nextSearch.msgId
100 |       else:
101 |         return EntryAsync(done: true)
102 |     else:
103 |       let entry = ldap_first_entry(s.ld.r, msg.r)
104 |       return EntryAsync(entry: entry, ld: s.ld, msg: msg, done: false)
105 | 
106 | proc count*(ld: LdapAsyncRef, filter: string, scope = LdapScope.SubTree,
107 |     base = rootDC, limit = 0, pageSize = 0): Future[int] {.async.} =
108 |   var cookie = ""
109 |   while true:
110 |     let search = ld.search(filter, ["cn"], scope, base, limit, [], pageSize, cookie)
111 |     let (msg, _) = await ld.waitResult(search.msgId, waitForAll = true)
112 |     result += ldap_count_entries(ld.r, msg.r)
113 |     if pageSize > 0:
114 |       cookie = cookieFromMsg(ld, pageSize, msg)
115 |     if cookie == "":
116 |       break
117 | 


--------------------------------------------------------------------------------
/src/nimldap/shared.nim:
--------------------------------------------------------------------------------
  1 | import bindings
  2 | import tinyasn1
  3 | 
  4 | import strutils
  5 | import endians
  6 | import system/ansi_c
  7 | 
  8 | type
  9 |   Ldap* = object
 10 |     r*: ptr LdapInt
 11 |     base*: string
 12 |     pageSize*: int
 13 |   LdapRef* = ref Ldap
 14 | 
 15 |   LdapAsync* = object
 16 |     r*: ptr LdapInt
 17 |     base*: string
 18 |     pageSize*: int
 19 |   LdapAsyncRef* = ref LdapAsync
 20 | 
 21 |   Entry* = ref object
 22 |     entry*: EntryInt
 23 |     msg*: LdapMessageRef
 24 |     ld*: LdapRef
 25 | 
 26 |   EntryAsync* = ref object
 27 |     entry*: EntryInt
 28 |     msg*: LdapMessageRef
 29 |     ld*: LdapAsyncRef
 30 |     done*: bool
 31 | 
 32 |   Ctrl* = object
 33 |     oid*: string
 34 |     val*: string
 35 |     isCritical*: bool
 36 | 
 37 |   AnyEntry = Entry | EntryAsync
 38 | 
 39 |   LdapException* = object of ValueError
 40 |     errCode*: int
 41 | 
 42 | const defaultNetworkTimeout* = 2
 43 | const rootDC* = "/"
 44 | 
 45 | type
 46 |   Extension* = enum
 47 |     LDAP_SERVER_NOTIFICATION_OID = "1.2.840.113556.1.4.528"
 48 |     LDAP_PAGED_RESULT_OID_STRING = "1.2.840.113556.1.4.319"
 49 | 
 50 | proc `=destroy`(x: var Ldap) =
 51 |   if x.r != nil:
 52 |     discard ldap_unbind_ext_s(x.r, nil, nil)
 53 |   `=destroy`(x.base)
 54 | 
 55 | proc `=destroy`(x: var LdapAsync) =
 56 |   if x.r != nil:
 57 |     discard ldap_unbind_ext_s(x.r, nil, nil)
 58 |   `=destroy`(x.base)
 59 | 
 60 | proc newLdapException*(err: int, msg = ""): ref LdapException =
 61 |   new(result)
 62 |   result.errCode = err
 63 |   result.msg = msg & " with error code " & $err
 64 | 
 65 | template checkErr*(body: untyped): untyped =
 66 |   let err = body
 67 |   if err != 0:
 68 |     let str = $ldap_err2string(err)
 69 |     raise newLdapException(err, str)
 70 | 
 71 | proc setOption*(ld: LdapRef|LdapAsyncRef, opt: LdapOption, value: int) =
 72 |   var val = value.int
 73 |   checkErr ldap_set_option(ld.r, opt, val.addr)
 74 | 
 75 | proc setOption*(ld: LdapRef|LdapAsyncRef, opt: LdapOption, value: LdapVersion) =
 76 |   ld.setOption(opt, value.int)
 77 | 
 78 | proc extractDC*(login: string): string =
 79 |   let lcLogin = login.toLowerAscii
 80 |   if lcLogin.find"dc=" >= 0:
 81 |     for p in lcLogin.split ",":
 82 |       if p.startsWith "dc=":
 83 |         if result.len > 0: result.add ","
 84 |         result.add p
 85 |   else:
 86 |     let emailParts = lcLogin.split '@'
 87 |     let domain = emailParts[^1]
 88 |     for p in domain.split ".":
 89 |       if result.len > 0: result.add ","
 90 |       result.add "dc="&p
 91 | 
 92 | proc unbind*(ld: LdapRef|LdapAsyncRef) =
 93 |   checkErr ldap_unbind_ext_s(ld.r, nil, nil)
 94 |   ld.r = nil
 95 | 
 96 | proc dn*(e: AnyEntry): string =
 97 |   $ldap_get_dn(e.ld.r, e.entry)
 98 | 
 99 | proc `[]`*(e: AnyEntry, attr: string): string =
100 |   let vals = ldap_get_values_len(e.ld.r, e.entry, attr.cstring)
101 |   if vals.r == nil:
102 |     raise newException(KeyError, "key not found: " & attr)
103 |   var val = vals[result.len]
104 |   if val != nil:
105 |     result = $val[]
106 | 
107 | proc `{}`*(e: AnyEntry, attr: string): seq[string] =
108 |   let vals = ldap_get_values_len(e.ld.r, e.entry, attr.cstring)
109 |   if vals.r == nil:
110 |     raise newException(KeyError, "key not found: " & attr)
111 |   var val = vals[result.len]
112 |   while val != nil:
113 |     result.add $val[]
114 |     val = vals[result.len]
115 | 
116 | proc pretty*(e: AnyEntry): string =
117 |   result.add e.dn() & "\n"
118 |   for k, v in e:
119 |     var res = v.values()
120 |     for i, s in res:
121 |       var visible = true
122 |       for c in s:
123 |         if c notin {' '..'~'}:
124 |           visible = false
125 |           break
126 |       if not visible:
127 |         res[i] = "0x" & s.toHex()
128 |     result.add "  " & $k & ": " & res.join(" | ") & "\n"
129 | 
130 | iterator items*(e: AnyEntry): string =
131 |   var berElem: BerElement
132 |   var attr = ldap_first_attribute(e.ld.r, e.entry, berElem)
133 |   while attr.r != nil:
134 |     yield $attr
135 |     attr = ldap_next_attribute(e.ld.r, e.entry, berElem)
136 | 
137 | iterator pairs*(e: AnyEntry): (string, BerArrRef) =
138 |   var berElem: BerElement
139 |   var attr = ldap_first_attribute(e.ld.r, e.entry, berElem)
140 |   while attr.r != nil:
141 |     let vals = BerArrRef()
142 |     vals[] = ldap_get_values_len(e.ld.r, e.entry, attr.r)
143 |     yield ($attr, vals)
144 |     attr = ldap_next_attribute(e.ld.r, e.entry, berElem)
145 | 
146 | iterator items*(vals: BerArrRef): string =
147 |   var idx = 0
148 |   var val = vals[idx]
149 |   while val != nil:
150 |     yield $val[]
151 |     inc idx
152 |     val = vals[idx]
153 | 
154 | proc len*(vals: BerArrRef): int =
155 |   ldapCountValuesLen(nil, vals)
156 | 
157 | proc attrs*(e: AnyEntry): seq[string] =
158 |   var ber: BerElement
159 |   var attr = ldap_first_attribute(e.ld.r, e.entry, ber)
160 |   while attr.r != nil:
161 |     result.add $attr
162 |     attr = ldap_next_attribute(e.ld.r, e.entry, ber)
163 | 
164 | proc values*(vals: BerArrRef): seq[string] =
165 |   var val = vals[result.len]
166 |   while val != nil:
167 |     result.add $val[]
168 |     val = vals[result.len]
169 | 
170 | proc `$`*(vals: BerArrRef): string =
171 |   $values(vals)
172 | 
173 | proc contains*(e: AnyEntry, attr: string): bool =
174 |   attr in e.attrs()
175 | 
176 | proc getOrEmpty*(e: AnyEntry, attr: string): string =
177 |   if attr in e:
178 |     return e[attr]
179 | 
180 | proc newCtrl*(oid: string|Extension, val = "", isCritical = true): Ctrl =
181 |   Ctrl(oid: $oid, val: val, isCritical: isCritical)
182 | 
183 | proc newControls*(ctrls: openArray[Ctrl]): CtrlArr =
184 |   if ctrls.len == 0:
185 |     return
186 | 
187 |   result.r = cast[ptr UncheckedArray[ptr CtrlInt]](c_calloc(ctrls.len.csize_t+1,
188 |       sizeof(ptr CtrlInt).csize_t))
189 | 
190 |   for i, ctrl in ctrls:
191 |     let val = newBer(ctrl.val)
192 |     checkErr ldap_control_create(ctrl.oid.cstring, ctrl.isCritical.int, val, 1,
193 |         result.r[i])
194 | 
195 | proc newPagingCtrl*(size: int, cookie: string): Ctrl =
196 |   newCtrl(LDAP_PAGED_RESULT_OID_STRING, newPagingValue(size, cookie))
197 | 
198 | proc newCtrlsWithPage*(ctrls: openArray[Ctrl], pageSize: int,
199 |     cookie: string): CtrlArr =
200 |   if pageSize > 0:
201 |     newControls(@ctrls & newPagingCtrl(pageSize, cookie))
202 |   else:
203 |     newControls(ctrls)
204 | 
205 | proc cookieFromMsg*(ld: LdapRef|LdapAsyncRef, pageSize: int,
206 |     msg: LdapMessageRef): string =
207 |   if pageSize == 0:
208 |     return
209 |   var errcode = 0
210 |   var ctrls = CtrlArr()
211 |   checkErr ldap_parse_result(ld.r, msg.r, errcode, nil, nil, nil, ctrls.r, 0)
212 |   var i = 0
213 |   while ctrls.r[i] != nil:
214 |     if $LDAP_PAGED_RESULT_OID_STRING == $ctrls.r[i].oid:
215 |       return readCook(ctrls.r[0])
216 |     inc i
217 | 
218 | proc sid*(s: string): string =
219 |   if s.len < 2:
220 |     raise newException(ValueError, "cannot parse sid: too short")
221 |   let cnt = s[1].int
222 |   if s.len != 8 + 4*cnt:
223 |     raise newException(ValueError, "cannot parse sid: wrong len")
224 |   var ia: uint64
225 |   bigEndian64(ia.addr, s[0].unsafeAddr)
226 |   ia = ia and 0x0000FFFFFFFFFFFF'u64
227 |   result.add "S-" & $s[0].byte
228 |   result.add "-" & $ia
229 |   for x in 0..<cnt:
230 |     var n: uint32
231 |     littleEndian32(n.addr, s[8+x*4].unsafeAddr)
232 |     result.add "-" & $n
233 | 


--------------------------------------------------------------------------------
/src/nimldap/bindings.nim:
--------------------------------------------------------------------------------
  1 | const libLdap = "libldap.so"
  2 | const libLber = "liblber.so"
  3 | 
  4 | const LDAP_SASL_SIMPLE* = nil
  5 | 
  6 | type
  7 |   LdapVersion* = enum
  8 |     V3 = 3
  9 | 
 10 |   LdapOption* = enum
 11 |     LDAP_OPT_PROTOCOL_VERSION = 0x0011
 12 |     LDAP_OPT_NETWORK_TIMEOUT = 0x5005
 13 | 
 14 |   LdapScope* = enum
 15 |     Base = 0
 16 |     OneLevel = 1
 17 |     SubTree = 2
 18 | 
 19 |   LdapInt* = object
 20 | 
 21 |   LdapMessageInt* = object
 22 |   EntryInt* = ptr LdapMessageInt
 23 |   LdapMessage* = object
 24 |     r*: ptr LdapMessageInt
 25 |   LdapMessageRef* = ref LdapMessage
 26 | 
 27 |   BerInt* = object
 28 |     len*: uint32
 29 |     data*: cstring
 30 |   BerPtr* = ptr BerInt
 31 |   Ber* = object
 32 |     r*: BerPtr
 33 | 
 34 |   BerArr* = object
 35 |     r*: ptr UncheckedArray[BerPtr]
 36 |   BerArrRef* = ref BerArr
 37 | 
 38 |   BerElementInt* = object
 39 |   BerElement* = object
 40 |     r*: ptr BerElementInt
 41 | 
 42 |   Timeval* = object
 43 |     sec*, nano*: uint32
 44 | 
 45 |   LdapString* = object
 46 |     r*: cstring
 47 | 
 48 |   CtrlInt* = object
 49 |     oid*: cstring
 50 |     val*: BerInt
 51 |     isCritical*: char
 52 |   CtrlArr* = object
 53 |     r*: ptr UncheckedArray[ptr CtrlInt]
 54 |   CtrlArrRef* = ref object
 55 | 
 56 | proc `[]`*(x: BerArr|BerArrRef, i: int): ptr BerInt =
 57 |   x.r[i]
 58 | 
 59 | proc newBer*(s: string): ref BerInt =
 60 |   new(result)
 61 |   result.len = s.len.uint32
 62 |   result.data = s.cstring
 63 | 
 64 | func `$`*(ber: BerInt): string =
 65 |   if ber.len == 0:
 66 |     return ""
 67 |   result = newString(ber.len)
 68 |   copyMem(result[0].addr, ber.data, ber.len)
 69 | 
 70 | func `$`*(lstr: LdapString): string =
 71 |   $lstr.r
 72 | 
 73 | proc ldap_initialize*(ld: var ptr LdapInt, url: cstring): int {.cdecl,
 74 |     dynlib: libLdap, importc: "ldap_initialize".}
 75 | proc ldap_memfree*(p: cstring) {.cdecl, dynlib: libLdap,
 76 |     importc: "ldap_memfree".}
 77 | proc ldap_msgfree*(p: ptr LdapMessageInt) {.cdecl, dynlib: libLdap,
 78 |     importc: "ldap_msgfree".}
 79 | proc ldap_value_free_len*(p: pointer) {.cdecl, dynlib: libLdap,
 80 |     importc: "ldap_value_free_len".}
 81 | proc ldap_set_option*(ld: ptr LdapInt, opt: LdapOption, val: ptr int):
 82 |     int {.cdecl, dynlib: libLdap, importc: "ldap_set_option".}
 83 | proc ldap_sasl_bind_s*(ld: ptr LdapInt, dn: cstring, mechanism: cstring,
 84 |     credC: ref BerInt, s, c: typeof(nil), credS: ptr ref BerInt): int {.cdecl,
 85 |     dynlib: libLdap, importc: "ldap_sasl_bind_s".}
 86 | proc ldap_sasl_bind*(ld: ptr LdapInt, dn: cstring, mechanism: cstring,
 87 |     credC: ref BerInt, s, c: typeof(nil), msgId: var int): int {.cdecl,
 88 |     dynlib: libLdap, importc: "ldap_sasl_bind".}
 89 | proc ldap_parse_sasl_bind_result*(ld: ptr LdapInt, msg: EntryInt,
 90 |     servercredp: typeof(nil), freeit: int): int {.cdecl,
 91 | 
 92 | dynlib: libLdap, importc: "ldap_parse_sasl_bind_result".}
 93 | proc ldap_unbind_ext_s*(ld: ptr LdapInt, s, c: typeof(nil)): int {.cdecl,
 94 |     dynlib: libLdap, importc: "ldap_unbind_ext_s".}
 95 | proc ldap_whoami_s*(ld: ptr LdapInt, auth: var BerPtr, s, c: typeof(
 96 |     nil)): int {.cdecl, dynlib: libLdap, importc: "ldap_whoami_s".}
 97 | proc ldap_whoami*(ld: ptr LdapInt, s, c: typeof(
 98 |     nil), msgId: var int): int {.cdecl, dynlib: libLdap,
 99 |         importc: "ldap_whoami".}
100 | proc ldap_parse_whoami*(ld: ptr LdapInt, msg: EntryInt, auth: var Ber): int
101 |   {.cdecl, dynlib: libLdap, importc: "ldap_parse_whoami".}
102 | proc ldap_result*(ld: ptr LdapInt, msgId: int, all: int, timeout: ptr Timeval,
103 |     res: LdapMessageRef): int
104 |   {.cdecl, dynlib: libLdap, importc: "ldap_result".}
105 | proc ldap_search_ext_s*(ld: ptr LdapInt, base: cstring, scope: int,
106 |     filter: cstring, attrs: pointer, attrsOnly: int, s,
107 |         c: ptr UncheckedArray[ptr CtrlInt], timeout: typeof(nil),
108 |     sizeLimit: int, res: LdapMessageRef): int {.cdecl, dynlib: libLdap,
109 |         importc: "ldap_search_ext_s".}    # TODO: not sure about res: ref here
110 | proc ldap_search_ext*(ld: ptr LdapInt, base: cstring, scope: int,
111 |     filter: cstring, attrs: pointer, attrsOnly: int, s,
112 |         c: ptr UncheckedArray[ptr CtrlInt], timeout: typeof(nil),
113 |     sizeLimit: int, msgId: var int): int {.cdecl, dynlib: libLdap,
114 |         importc: "ldap_search_ext".}
115 | proc ldap_count_entries*(ld: ptr LdapInt, res: EntryInt): int {.cdecl,
116 |     dynlib: libLdap, importc: "ldap_count_entries".}
117 | proc ldap_first_entry*(ld: ptr LdapInt, res: EntryInt): EntryInt {.cdecl,
118 |     dynlib: libLdap, importc: "ldap_first_entry".}
119 | proc ldap_next_entry*(ld: ptr LdapInt, res: EntryInt): EntryInt {.cdecl,
120 |     dynlib: libLdap, importc: "ldap_next_entry".}
121 | proc ldap_get_dn*(ld: ptr LdapInt, res: ptr LdapMessageInt): LdapString {.cdecl,
122 |     dynlib: libLdap, importc: "ldap_get_dn".}
123 | proc ldap_msgtype*(ld: ptr LdapInt, res: ptr LdapMessageInt): int {.cdecl,
124 |     dynlib: libLdap, importc: "ldap_msgtype".}
125 | proc ldap_first_attribute*(ld: ptr LdapInt, entry: ptr LdapMessageInt,
126 |     ber: var BerElement): LdapString {.cdecl, dynlib: libLdap,
127 |     importc: "ldap_first_attribute".}
128 | proc ldap_next_attribute*(ld: ptr LdapInt, res: ptr LdapMessageInt,
129 |     ber: BerElement): LdapString {.cdecl, dynlib: libLdap,
130 |     importc: "ldap_next_attribute".}
131 | proc ldap_get_values_len*(ld: ptr LdapInt, res: ptr LdapMessageInt,
132 |     attrName: cstring): BerArr {.cdecl, dynlib: libLdap,
133 |     importc: "ldap_get_values_len".}
134 | # proc ldap_count_values_len(ld: ptr LDAPInt, val: pointer): int {.cdecl,
135 | #     dynlib: libName, importc: "ldap_count_values_len".}
136 | #     ^^^ BUGGY in openldap
137 | proc ldapCountValuesLen*(ld: ptr LdapInt, vals: BerArr|BerArrRef): int =
138 |   var val = vals.r[result]
139 |   while val != nil:
140 |     inc result
141 |     val = vals[result]
142 | 
143 | #  int ldap_parse_result( LDAP *ld, LDAPMessage *result,
144 | #       int *errcodep, char **matcheddnp, char **errmsgp,
145 | #       char ***referralsp, LDAPControl ***serverctrlsp,
146 | #       int freeit )
147 | proc ldap_parse_result*(ld: ptr LdapInt, msg: ptr LdapMessageInt, errcodep: var int,
148 |     matcheddnp, errmsgp, referralsp: typeof(nil), serverctrlsp: var ptr UncheckedArray[ptr CtrlInt],
149 |         freeit: int): int {.cdecl,
150 |     dynlib: libLdap, importc: "ldap_parse_result".}
151 | 
152 | # int ldap_control_create(const char *oid, int iscritical, struct berval *value, int dupval, LDAPControl **ctrlp);
153 | proc ldap_control_create*(oid: cstring, iscritical: int, berval: ref BerInt, dupval: int, ctrlp: var ptr CtrlInt): int
154 |     {.cdecl, dynlib: libLdap, importc: "ldap_control_create".}
155 | 
156 | proc ldap_controls_free*(ctrls: ptr UncheckedArray[ptr CtrlInt]) {.cdecl,
157 |     dynlib: libLdap, importc: "ldap_controls_free".}
158 | 
159 | # proc ldap_control_free*(ctrl: ptr CtrlInt) {.cdecl,
160 | #     dynlib: libLdap, importc: "ldap_control_free".}
161 | 
162 | # LDAPControl **ldap_controls_dup(LDAPControl **ctrls);
163 | proc ldap_controls_dup*(ctrls: ptr UncheckedArray[ptr CtrlInt]): ptr UncheckedArray[ptr CtrlInt] {.cdecl,
164 |     dynlib: libLdap, importc: "ldap_controls_dup".}
165 | 
166 | proc ldap_err2string*(error: int): cstring {.cdecl, dynlib: libLdap, importc: "ldap_err2string".}
167 | 
168 | proc ber_bvfree*(ber: BerPtr) {.cdecl, dynlib: libLber, importc: "ber_bvfree".}
169 | proc ber_free*(ber: BerElement, freebuf: int) {.cdecl, dynlib: libLber,
170 |     importc: "ber_free".}
171 | 
172 | proc `=destroy`(x: var LdapString) =
173 |   # echo "lets free ber: ", cast[int](x.r.addr)
174 |   ldap_memfree(x.r)
175 | 
176 | proc `=destroy`(x: var Ber) =
177 |   # echo "lets free ber: ", cast[int](x.r.addr)
178 |   ber_bvfree(x.r)
179 | 
180 | proc `=destroy`(x: var LdapMessage) =
181 |   # echo "lets free msg"
182 |   ldap_msgfree(x.r)
183 | 
184 | proc `=destroy`(x: var BerArr) =
185 |   # echo "lets free berArr: ", cast[int](x.r)
186 |   ldap_value_free_len(x.r)
187 | 
188 | proc `=destroy`(x: var BerElement) =
189 |   # echo "lets free berElement: ", cast[int](x.addr)
190 |   ber_free(x, 0)
191 | 
192 | proc `=destroy`(x: var CtrlArr) =
193 |   # echo "lets free CtrlArr"
194 |   ldap_controls_free(x.r) # checks null internally
195 | 


--------------------------------------------------------------------------------