Current section
5 Versions
Jump to
Current section
5 Versions
Compare versions
7
files changed
+406
additions
-141
deletions
| @@ -0,0 +1,3 @@ | |
| 1 | + [ |
| 2 | + inputs: ["mix.exs", "{config,lib,test}/**/*.{ex,exs}"] |
| 3 | + ] |
| @@ -5,7 +5,8 @@ | |
| 5 5 | {<<"files">>, |
| 6 6 | [<<"lib">>,<<"lib/elixir_ldap.ex">>,<<"lib/elixir_ldap_collation.ex">>, |
| 7 7 | <<"lib/elixir_ldap_entry.ex">>,<<"lib/elixir_ldap_search.ex">>, |
| 8 | - <<"lib/elixir_ldap_search_result.ex">>,<<"mix.exs">>,<<"README.md">>]}. |
| 8 | + <<"lib/elixir_ldap_search_result.ex">>,<<".formatter.exs">>,<<"mix.exs">>, |
| 9 | + <<"README.md">>]}. |
| 9 10 | {<<"licenses">>,[<<"MIT">>]}. |
| 10 11 | {<<"links">>,[{<<"GitHub">>,<<"https://github.com/kobatako/elixir_ldap">>}]}. |
| 11 12 | {<<"maintainers">>,[<<"kobatako">>]}. |
| @@ -16,4 +17,4 @@ | |
| 16 17 | {<<"optional">>,false}, |
| 17 18 | {<<"repository">>,<<"hexpm">>}, |
| 18 19 | {<<"requirement">>,<<">= 0.0.0">>}]]}. |
| 19 | - {<<"version">>,<<"0.3.0">>}. |
| 20 | + {<<"version">>,<<"0.4.0">>}. |
| @@ -62,14 +62,18 @@ defmodule ElixirLdap do | |
| 62 62 | base: "dc=home,dc=local" |
| 63 63 | """ |
| 64 64 | def open(host) do |
| 65 | - options = Application.get_env(:elixir_ldap, :settings) |
| 65 | + options = |
| 66 | + Application.get_env(:elixir_ldap, :settings) |
| 66 67 | |> Keyword.take([:port, :ssl, :timeout]) |
| 68 | + |
| 67 69 | open(host, options) |
| 68 70 | end |
| 69 71 | |
| 70 72 | def open() do |
| 71 | - {:ok, host} = Application.get_env(:elixir_ldap, :settings) |
| 73 | + {:ok, host} = |
| 74 | + Application.get_env(:elixir_ldap, :settings) |
| 72 75 | |> Keyword.fetch(:host) |
| 76 | + |
| 73 77 | open(host) |
| 74 78 | end |
| 75 79 | |
| @@ -81,33 +85,48 @@ defmodule ElixirLdap do | |
| 81 85 | ElixirLdap.connect("127.0.0.1", [port: port, ssl: ssl, timeout: timeout]) |
| 82 86 | |
| 83 87 | """ |
| 84 | - def connect(host, [port: port, ssl: ssl, timeout: timeout], [user_dn: user_dn, password: password]) do |
| 85 | - case open([to_charlist(host)], [port: port, ssl: ssl, timeout: timeout]) do |
| 88 | + def connect( |
| 89 | + host, |
| 90 | + [port: port, ssl: ssl, timeout: timeout], |
| 91 | + user_dn: user_dn, |
| 92 | + password: password |
| 93 | + ) do |
| 94 | + case open([to_charlist(host)], port: port, ssl: ssl, timeout: timeout) do |
| 86 95 | {:ok, handle} -> simple_bind(handle, user_dn, password) |
| 87 96 | error -> error |
| 88 97 | end |
| 89 98 | end |
| 90 | - def connect(host, [user_dn: user_dn, password: password]) do |
| 91 | - options = Application.get_env(:elixir_ldap, :settings) |
| 99 | + |
| 100 | + def connect(host, user_dn: user_dn, password: password) do |
| 101 | + options = |
| 102 | + Application.get_env(:elixir_ldap, :settings) |
| 92 103 | |> Keyword.take([:port, :ssl, :timeout]) |
| 104 | + |
| 93 105 | case open(host, options) do |
| 94 106 | {:ok, handle} -> simple_bind(handle, user_dn, password) |
| 95 107 | error -> error |
| 96 108 | end |
| 97 109 | end |
| 98 | - def connect(host, [port: port, ssl: ssl, timeout: timeout]) do |
| 99 | - [user_dn: user_dn, password: password] = Application.get_env(:elixir_ldap, :settings) |
| 110 | + |
| 111 | + def connect(host, port: port, ssl: ssl, timeout: timeout) do |
| 112 | + [user_dn: user_dn, password: password] = |
| 113 | + Application.get_env(:elixir_ldap, :settings) |
| 100 114 | |> Keyword.take([:user_dn, :password]) |
| 101 | - case open(host, [port: port, ssl: ssl, timeout: timeout]) do |
| 115 | + |
| 116 | + case open(host, port: port, ssl: ssl, timeout: timeout) do |
| 102 117 | {:ok, handle} -> simple_bind(handle, user_dn, password) |
| 103 118 | error -> error |
| 104 119 | end |
| 105 120 | end |
| 121 | + |
| 106 122 | def connect(host) do |
| 107 | - options = Application.get_env(:elixir_ldap, :settings) |
| 123 | + options = |
| 124 | + Application.get_env(:elixir_ldap, :settings) |
| 108 125 | |> Keyword.take([:port, :ssl, :timeout]) |
| 126 | + |
| 109 127 | connect(host, options) |
| 110 128 | end |
| 129 | + |
| 111 130 | def connect() do |
| 112 131 | settings = Application.get_env(:elixir_ldap, :settings) |
| 113 132 | {:ok, host} = Keyword.fetch(settings, :host) |
| @@ -140,7 +159,7 @@ defmodule ElixirLdap do | |
| 140 159 | end |
| 141 160 | |
| 142 161 | defp to_listchar_atom_key(dn_list) do |
| 143 | - Enum.map_join(dn_list, ",", fn({key, value}) -> to_string(key) <> "=" <> value end) |
| 162 | + Enum.map_join(dn_list, ",", fn {key, value} -> to_string(key) <> "=" <> value end) |
| 144 163 | end |
| 145 164 | |
| 146 165 | @doc """ |
| @@ -196,12 +215,15 @@ defmodule ElixirLdap do | |
| 196 215 | defp mod_options_params({type, value}) when is_list(value) do |
| 197 216 | mod_options_params({:replace, type, value}) |
| 198 217 | end |
| 218 | + |
| 199 219 | defp mod_options_params({:add, type, value}) when is_list(value) do |
| 200 220 | :eldap.mod_add(to_charlist(type), value) |
| 201 221 | end |
| 222 | + |
| 202 223 | defp mod_options_params({:replace, type, value}) when is_list(value) do |
| 203 224 | :eldap.mod_replace(to_charlist(type), value) |
| 204 225 | end |
| 226 | + |
| 205 227 | defp mod_options_params({:delete, type, value}) when is_list(value) do |
| 206 228 | :eldap.mod_delete(to_charlist(type), value) |
| 207 229 | end |
| @@ -235,14 +257,27 @@ defmodule ElixirLdap do | |
| 235 257 | def modify_password(handle, dn, password) when is_list(dn) do |
| 236 258 | modify_password(handle, to_listchar_atom_key(dn), to_charlist(password)) |
| 237 259 | end |
| 260 | + |
| 238 261 | def modify_password(handle, dn, password) do |
| 239 262 | :eldap.modify_password(handle, to_charlist(dn), to_charlist(password)) |
| 240 263 | end |
| 264 | + |
| 241 265 | def modify_password(handle, dn, new_password, old_password) when is_list(dn) do |
| 242 | - modify_password(handle, to_listchar_atom_key(dn), to_charlist(new_password), to_charlist(old_password)) |
| 266 | + modify_password( |
| 267 | + handle, |
| 268 | + to_listchar_atom_key(dn), |
| 269 | + to_charlist(new_password), |
| 270 | + to_charlist(old_password) |
| 271 | + ) |
| 243 272 | end |
| 273 | + |
| 244 274 | def modify_password(handle, dn, new_password, old_password) do |
| 245 | - :eldap.modify_password(handle, to_charlist(dn), to_charlist(new_password), to_charlist(old_password)) |
| 275 | + :eldap.modify_password( |
| 276 | + handle, |
| 277 | + to_charlist(dn), |
| 278 | + to_charlist(new_password), |
| 279 | + to_charlist(old_password) |
| 280 | + ) |
| 246 281 | end |
| 247 282 | |
| 248 283 | @doc """ |
| @@ -254,7 +289,13 @@ defmodule ElixirLdap do | |
| 254 289 | |
| 255 290 | """ |
| 256 291 | def modify_dn(handle, dn, new_rdn, delete_old_rdn, new_sup_dn) when is_list(dn) do |
| 257 | - modify_dn(handle, to_listchar_atom_key(dn), to_charlist(new_rdn), delete_old_rdn, to_charlist(new_sup_dn)) |
| 292 | + modify_dn( |
| 293 | + handle, |
| 294 | + to_listchar_atom_key(dn), |
| 295 | + to_charlist(new_rdn), |
| 296 | + delete_old_rdn, |
| 297 | + to_charlist(new_sup_dn) |
| 298 | + ) |
| 258 299 | end |
| 259 300 | |
| 260 301 | @doc """ |
| @@ -266,7 +307,13 @@ defmodule ElixirLdap do | |
| 266 307 | |
| 267 308 | """ |
| 268 309 | def modify_dn(handle, dn, new_rdn, delete_old_rdn, new_sup_dn) do |
| 269 | - :eldap.modify_dn(handle, to_charlist(dn), to_charlist(new_rdn), delete_old_rdn, to_charlist(new_sup_dn)) |
| 310 | + :eldap.modify_dn( |
| 311 | + handle, |
| 312 | + to_charlist(dn), |
| 313 | + to_charlist(new_rdn), |
| 314 | + delete_old_rdn, |
| 315 | + to_charlist(new_sup_dn) |
| 316 | + ) |
| 270 317 | end |
| 271 318 | |
| 272 319 | @doc """ |
| @@ -319,11 +366,10 @@ defmodule ElixirLdap do | |
| 319 366 | |
| 320 367 | """ |
| 321 368 | def convert_object_name(object) do |
| 322 | - Map.merge(object, |
| 323 | - %{ |
| 324 | - object_names: Regex.split(~r/,/, to_string(object.object_name)) |
| 369 | + Map.merge(object, %{ |
| 370 | + object_names: |
| 371 | + Regex.split(~r/,/, to_string(object.object_name)) |
| 325 372 | |> Enum.map(&Regex.named_captures(~r/(?<name>.*)=(?<value>.*)/, &1)) |
| 326 | - } |
| 327 | - ) |
| 373 | + }) |
| 328 374 | end |
| 329 375 | end |
| @@ -14,6 +14,7 @@ defmodule ElixirLdap.Entry do | |
| 14 14 | end |
| 15 15 | |
| 16 16 | def from_record(eldap_tnry) |
| 17 | + |
| 17 18 | def from_record({:eldap_entry, unquote_splicing(vals)}) do |
| 18 19 | %ElixirLdap.Entry{unquote_splicing(pairs)} |
| 19 20 | end |
| @@ -6,11 +6,11 @@ defmodule ElixirLdap.Search do | |
| 6 6 | collation_define |
| 7 7 | |
| 8 8 | defp is_collation_rule?(collation_rule) do |
| 9 | - Enum.any?(ElixirLdap.Collation.collation_rules, fn(rule) -> rule == collation_rule end) |
| 9 | + Enum.any?(ElixirLdap.Collation.collation_rules(), fn rule -> rule == collation_rule end) |
| 10 10 | end |
| 11 11 | |
| 12 12 | defp to_listchar_atom_key(dn_list) do |
| 13 | - Enum.map_join(dn_list, ",", fn({key, value}) -> to_string(key) <> "=" <> value end) |
| 13 | + Enum.map_join(dn_list, ",", fn {key, value} -> to_string(key) <> "=" <> value end) |
| 14 14 | end |
| 15 15 | |
| 16 16 | defp search_scope(scope) when is_atom(scope) do |
| @@ -18,9 +18,11 @@ defmodule ElixirLdap.Search do | |
| 18 18 | # Search baseobject only. |
| 19 19 | :base_object -> |
| 20 20 | :eldap.baseObject() |
| 21 | + |
| 21 22 | # Search the specified level only, i.e. do not recurse |
| 22 23 | :single_level -> |
| 23 24 | :eldap.singleLevel() |
| 25 | + |
| 24 26 | # Search the entire subtree. |
| 25 27 | :whole_subtree -> |
| 26 28 | :eldap.wholeSubtree() |
| @@ -36,13 +38,16 @@ defmodule ElixirLdap.Search do | |
| 36 38 | # Do not refer to alias entries |
| 37 39 | :never_deref_aliases -> |
| 38 40 | :eldap.neverDerefAliases() |
| 41 | + |
| 39 42 | # If the base DN of the search is an alias entry, it refers to it, ignoring the alias entry under it |
| 40 43 | :deref_in_searching -> |
| 41 44 | :eldap.derefInSearching() |
| 45 | + |
| 42 46 | # If the base DN of the search is an alias entry no search is performed. |
| 43 47 | # If the base DN is not an alias entry, a search is performed, and furthermore, an alias entry under the base DN is referred to |
| 44 48 | :deref_finding_baes_obj -> |
| 45 49 | :eldap.derefFindingBaseObj() |
| 50 | + |
| 46 51 | # Always refer to alias entries |
| 47 52 | :deref_always -> |
| 48 53 | :eldap.derefAlways() |
| @@ -63,8 +68,10 @@ defmodule ElixirLdap.Search do | |
| 63 68 | |
| 64 69 | """ |
| 65 70 | def search_base_all(handle) do |
| 66 | - base = Application.get_env(:elixir_ldap, :settings) |
| 71 | + base = |
| 72 | + Application.get_env(:elixir_ldap, :settings) |
| 67 73 | |> Keyword.get(:base) |
| 74 | + |
| 68 75 | search_base_all(handle, base) |
| 69 76 | end |
| 70 77 | |
| @@ -82,10 +89,23 @@ defmodule ElixirLdap.Search do | |
| 82 89 | if is_tuple(List.first(base)) do |
| 83 90 | search_base_all(handle, to_listchar_atom_key(base)) |
| 84 91 | else |
| 85 | - search_base(handle, base, [filter: :present, type: "objectClass"]) |
| 92 | + search_base(handle, base, filter: :present, type: "objectClass") |
| 86 93 | end |
| 87 94 | end |
| 88 95 | |
| 96 | + @doc """ |
| 97 | + Search base dn all entry. |
| 98 | + Use the base DN of the argument. |
| 99 | + |
| 100 | + ## Example |
| 101 | + |
| 102 | + ElixirLdap.Search.search_base_all(handle, 'ou=Server,dc=corporation,dc=home,dc=local') |
| 103 | + |
| 104 | + """ |
| 105 | + def search_base_all(handle, base) do |
| 106 | + search_base(handle, base, filter: :present, type: "objectClass") |
| 107 | + end |
| 108 | + |
| 89 109 | @doc """ |
| 90 110 | search base dn all entry. |
| 91 111 | DN is argument base search and deref aliase is argument. |
| @@ -102,21 +122,8 @@ defmodule ElixirLdap.Search do | |
| 102 122 | * deref_always - Always refer to alias entries |
| 103 123 | |
| 104 124 | """ |
| 105 | - def search_base_all(handle, base, def) when is_atom(def) do |
| 106 | - search_base(handle, base, [filter: :present, type: "objectClass"], def) |
| 107 | - end |
| 108 | - |
| 109 | - @doc """ |
| 110 | - Search base dn all entry. |
| 111 | - Use the base DN of the argument. |
| 112 | - |
| 113 | - ## Example |
| 114 | - |
| 115 | - ElixirLdap.Search.search_base_all(handle, 'ou=Server,dc=corporation,dc=home,dc=local') |
| 116 | - |
| 117 | - """ |
| 118 | - def search_base_all(handle, base) do |
| 119 | - search_base(handle, base, [filter: :present, type: "objectClass"]) |
| 125 | + def search_base_all(handle, base, defer) when is_atom(defer) do |
| 126 | + search_base(handle, base, [filter: :present, type: "objectClass"], defer) |
| 120 127 | end |
| 121 128 | |
| 122 129 | @doc """ |
| @@ -129,8 +136,10 @@ defmodule ElixirLdap.Search do | |
| 129 136 | |
| 130 137 | """ |
| 131 138 | def search_single_level_all(handle) do |
| 132 | - base = Application.get_env(:elixir_ldap, :settings) |
| 139 | + base = |
| 140 | + Application.get_env(:elixir_ldap, :settings) |
| 133 141 | |> Keyword.get(:base) |
| 142 | + |
| 134 143 | search_single_level_all(handle, base) |
| 135 144 | end |
| 136 145 | |
| @@ -148,7 +157,7 @@ defmodule ElixirLdap.Search do | |
| 148 157 | if is_tuple(List.first(base)) do |
| 149 158 | search_single_level_all(handle, to_listchar_atom_key(base)) |
| 150 159 | else |
| 151 | - search_single_level(handle, base, [filter: :present, type: "objectClass"]) |
| 160 | + search_single_level(handle, base, filter: :present, type: "objectClass") |
| 152 161 | end |
| 153 162 | end |
| 154 163 | |
| @@ -162,13 +171,12 @@ defmodule ElixirLdap.Search do | |
| 162 171 | |
| 163 172 | """ |
| 164 173 | def search_single_level_all(handle, base) do |
| 165 | - search_single_level(handle, base, [filter: :present, type: "objectClass"]) |
| 174 | + search_single_level(handle, base, filter: :present, type: "objectClass") |
| 166 175 | end |
| 167 176 | |
| 168 177 | @doc """ |
| 169 178 | Search single level all entry. |
| 170 | - Use the base DN of argument. |
| 171 | - deref aliases is argument |
| 179 | + Use the base DN of argument.deref aliases is argument |
| 172 180 | |
| 173 181 | ## Example |
| 174 182 | |
| @@ -182,29 +190,34 @@ defmodule ElixirLdap.Search do | |
| 182 190 | * deref_always - Always refer to alias entries |
| 183 191 | |
| 184 192 | """ |
| 185 | - def search_single_level_all(handle, base, def) when is_atom(def) do |
| 186 | - search_single_level(handle, base, [filter: :present, type: "objectClass"], def) |
| 193 | + def search_single_level_all(handle, base, defer) when is_atom(defer) do |
| 194 | + search_single_level(handle, base, [filter: :present, type: "objectClass"], defer) |
| 187 195 | end |
| 188 196 | |
| 189 197 | @doc """ |
| 190 198 | """ |
| 191 199 | def search_subtree_all(handle) do |
| 192 | - base = Application.get_env(:elixir_ldap, :settings) |
| 200 | + base = |
| 201 | + Application.get_env(:elixir_ldap, :settings) |
| 193 202 | |> Keyword.get(:base) |
| 203 | + |
| 194 204 | search_subtree_all(handle, base) |
| 195 205 | end |
| 206 | + |
| 196 207 | def search_subtree_all(handle, base) when is_list(base) do |
| 197 208 | if is_tuple(List.first(base)) do |
| 198 209 | search_subtree_all(handle, to_listchar_atom_key(base)) |
| 199 210 | else |
| 200 | - search_subtree(handle, base, [filter: :present, type: "objectClass"]) |
| 211 | + search_subtree(handle, base, filter: :present, type: "objectClass") |
| 201 212 | end |
| 202 213 | end |
| 214 | + |
| 203 215 | def search_subtree_all(handle, base) do |
| 204 | - search_subtree(handle, base, [filter: :present, type: "objectClass"]) |
| 216 | + search_subtree(handle, base, filter: :present, type: "objectClass") |
| 205 217 | end |
| 206 | - def search_subtree_all(handle, base, def) do |
| 207 | - search_subtree(handle, base, [filter: :present, type: "objectClass"], def) |
| 218 | + |
| 219 | + def search_subtree_all(handle, base, defer) do |
| 220 | + search_subtree(handle, base, [filter: :present, type: "objectClass"], defer) |
| 208 221 | end |
| 209 222 | |
| 210 223 | @doc """ |
| @@ -220,8 +233,10 @@ defmodule ElixirLdap.Search do | |
| 220 233 | |
| 221 234 | """ |
| 222 235 | def search_base(handle, options) do |
| 223 | - base = Application.get_env(:elixir_ldap, :settings) |
| 236 | + base = |
| 237 | + Application.get_env(:elixir_ldap, :settings) |
| 224 238 | |> Keyword.get(:base) |
| 239 | + |
| 225 240 | search_base(handle, base, options) |
| 226 241 | end |
| 227 242 | |
| @@ -247,10 +262,12 @@ defmodule ElixirLdap.Search do | |
| 247 262 | * deref_always - Always refer to alias entries |
| 248 263 | |
| 249 264 | """ |
| 250 | - def search_base(handle, base, [filter: :equal, field: field, name: name], def) do |
| 251 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 265 | + def search_base(handle, base, [filter: :equal, field: field, name: name], defer) do |
| 266 | + search_timeout = |
| 267 | + Application.get_env(:elixir_ldap, :settings) |
| 252 268 | |> Keyword.get(:search_time) || 0 |
| 253 | - search(handle, base, :base_object, equality_match(field, name), def, false, search_timeout) |
| 269 | + |
| 270 | + search(handle, base, :base_object, equality_match(field, name), defer, false, search_timeout) |
| 254 271 | end |
| 255 272 | |
| 256 273 | @doc """ |
| @@ -270,10 +287,12 @@ defmodule ElixirLdap.Search do | |
| 270 287 | * deref_always - Always refer to alias entries |
| 271 288 | |
| 272 289 | """ |
| 273 | - def search_base(handle, base, [filter: :present, type: type], def) do |
| 274 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 290 | + def search_base(handle, base, [filter: :present, type: type], defer) do |
| 291 | + search_timeout = |
| 292 | + Application.get_env(:elixir_ldap, :settings) |
| 275 293 | |> Keyword.get(:search_time) || 0 |
| 276 | - search(handle, base, :base_object, present(type), def, false, search_timeout) |
| 294 | + |
| 295 | + search(handle, base, :base_object, present(type), defer, false, search_timeout) |
| 277 296 | end |
| 278 297 | |
| 279 298 | @doc """ |
| @@ -293,10 +312,20 @@ defmodule ElixirLdap.Search do | |
| 293 312 | * deref_always - Always refer to alias entries |
| 294 313 | |
| 295 314 | """ |
| 296 | - def search_base(handle, base, [filter: :greater, type: type, value: value], def) do |
| 297 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 315 | + def search_base(handle, base, [filter: :greater, type: type, value: value], defer) do |
| 316 | + search_timeout = |
| 317 | + Application.get_env(:elixir_ldap, :settings) |
| 298 318 | |> Keyword.get(:search_time) || 0 |
| 299 | - search(handle, base, :base_object, greater_or_equal(type, value), def, false, search_timeout) |
| 319 | + |
| 320 | + search( |
| 321 | + handle, |
| 322 | + base, |
| 323 | + :base_object, |
| 324 | + greater_or_equal(type, value), |
| 325 | + defer, |
| 326 | + false, |
| 327 | + search_timeout |
| 328 | + ) |
| 300 329 | end |
| 301 330 | |
| 302 331 | @doc """ |
| @@ -316,10 +345,12 @@ defmodule ElixirLdap.Search do | |
| 316 345 | * deref_always - Always refer to alias entries |
| 317 346 | |
| 318 347 | """ |
| 319 | - def search_base(handle, base, [filter: :less, type: type, value: value], def) do |
| 320 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 348 | + def search_base(handle, base, [filter: :less, type: type, value: value], defer) do |
| 349 | + search_timeout = |
| 350 | + Application.get_env(:elixir_ldap, :settings) |
| 321 351 | |> Keyword.get(:search_time) || 0 |
| 322 | - search(handle, base, :base_object, less_or_equal(type, value), def, false, search_timeout) |
| 352 | + |
| 353 | + search(handle, base, :base_object, less_or_equal(type, value), defer, false, search_timeout) |
| 323 354 | end |
| 324 355 | |
| 325 356 | @doc """ |
| @@ -338,22 +369,41 @@ defmodule ElixirLdap.Search do | |
| 338 369 | * deref_always - Always refer to alias entries |
| 339 370 | |
| 340 371 | """ |
| 341 | - def search_base(handle, base, [filter: :approx, type: type, value: value], def) do |
| 342 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 372 | + def search_base(handle, base, [filter: :approx, type: type, value: value], defer) do |
| 373 | + search_timeout = |
| 374 | + Application.get_env(:elixir_ldap, :settings) |
| 343 375 | |> Keyword.get(:search_time) || 0 |
| 344 | - search(handle, base, :base_object, approx_match(type, value), def, false, search_timeout) |
| 376 | + |
| 377 | + search(handle, base, :base_object, approx_match(type, value), defer, false, search_timeout) |
| 345 378 | end |
| 346 379 | |
| 347 | - def search_base(handle, base, [filter: :extensible, value: value, type: type, rule: rule, dn_attributes: dn_attribute], def) do |
| 348 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 380 | + def search_base( |
| 381 | + handle, |
| 382 | + base, |
| 383 | + [filter: :extensible, value: value, type: type, rule: rule, dn_attributes: dn_attribute], |
| 384 | + defer |
| 385 | + ) do |
| 386 | + search_timeout = |
| 387 | + Application.get_env(:elixir_ldap, :settings) |
| 349 388 | |> Keyword.get(:search_time) || 0 |
| 350 | - search(handle, base, :base_object, extensible_match(value, type, rule, dn_attribute), def, false, search_timeout) |
| 389 | + |
| 390 | + search( |
| 391 | + handle, |
| 392 | + base, |
| 393 | + :base_object, |
| 394 | + extensible_match(value, type, rule, dn_attribute), |
| 395 | + defer, |
| 396 | + false, |
| 397 | + search_timeout |
| 398 | + ) |
| 351 399 | end |
| 352 400 | |
| 353 | - def search_base(handle, base, [filter: :strings, type: type, value: value], def) do |
| 354 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 401 | + def search_base(handle, base, [filter: :strings, type: type, value: value], defer) do |
| 402 | + search_timeout = |
| 403 | + Application.get_env(:elixir_ldap, :settings) |
| 355 404 | |> Keyword.get(:search_time) || 0 |
| 356 | - search(handle, base, :base_object, substrings(type, value), def, false, search_timeout) |
| 405 | + |
| 406 | + search(handle, base, :base_object, substrings(type, value), defer, false, search_timeout) |
| 357 407 | end |
| 358 408 | |
| 359 409 | @doc """ |
| @@ -370,8 +420,10 @@ defmodule ElixirLdap.Search do | |
| 370 420 | |
| 371 421 | """ |
| 372 422 | def search_single_level(handle, options) when is_list(options) do |
| 373 | - base = Application.get_env(:elixir_ldap, :settings) |
| 423 | + base = |
| 424 | + Application.get_env(:elixir_ldap, :settings) |
| 374 425 | |> Keyword.get(:base) |
| 426 | + |
| 375 427 | search_single_level(handle, base, options) |
| 376 428 | end |
| 377 429 | |
| @@ -396,10 +448,12 @@ defmodule ElixirLdap.Search do | |
| 396 448 | * deref_always - Always refer to alias entries |
| 397 449 | |
| 398 450 | """ |
| 399 | - def search_single_level(handle, base, [filter: :equal, field: field, name: name], def) do |
| 400 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 451 | + def search_single_level(handle, base, [filter: :equal, field: field, name: name], defer) do |
| 452 | + search_timeout = |
| 453 | + Application.get_env(:elixir_ldap, :settings) |
| 401 454 | |> Keyword.get(:search_time) || 0 |
| 402 | - search(handle, base, :single_level, equality_match(field, name), def, false, search_timeout) |
| 455 | + |
| 456 | + search(handle, base, :single_level, equality_match(field, name), defer, false, search_timeout) |
| 403 457 | end |
| 404 458 | |
| 405 459 | @doc """ |
| @@ -419,10 +473,12 @@ defmodule ElixirLdap.Search do | |
| 419 473 | * deref_always - Always refer to alias entries |
| 420 474 | |
| 421 475 | """ |
| 422 | - def search_single_level(handle, base, [filter: :present, type: type], def) do |
| 423 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 476 | + def search_single_level(handle, base, [filter: :present, type: type], defer) do |
| 477 | + search_timeout = |
| 478 | + Application.get_env(:elixir_ldap, :settings) |
| 424 479 | |> Keyword.get(:search_time) || 0 |
| 425 | - search(handle, base, :single_level, present(type), def, false, search_timeout) |
| 480 | + |
| 481 | + search(handle, base, :single_level, present(type), defer, false, search_timeout) |
| 426 482 | end |
| 427 483 | |
| 428 484 | @doc """ |
| @@ -442,12 +498,21 @@ defmodule ElixirLdap.Search do | |
| 442 498 | * deref_always - Always refer to alias entries |
| 443 499 | |
| 444 500 | """ |
| 445 | - def search_single_level(handle, base, [filter: :greater, type: type, value: value], def) do |
| 446 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 501 | + def search_single_level(handle, base, [filter: :greater, type: type, value: value], defer) do |
| 502 | + search_timeout = |
| 503 | + Application.get_env(:elixir_ldap, :settings) |
| 447 504 | |> Keyword.get(:search_time) || 0 |
| 448 | - search(handle, base, :single_level, greater_or_equal(type, value), def, false, search_timeout) |
| 449 | - end |
| 450 505 | |
| 506 | + search( |
| 507 | + handle, |
| 508 | + base, |
| 509 | + :single_level, |
| 510 | + greater_or_equal(type, value), |
| 511 | + defer, |
| 512 | + false, |
| 513 | + search_timeout |
| 514 | + ) |
| 515 | + end |
| 451 516 | |
| 452 517 | @doc """ |
| 453 518 | search single level entry. |
| @@ -466,10 +531,12 @@ defmodule ElixirLdap.Search do | |
| 466 531 | * deref_always - Always refer to alias entries |
| 467 532 | |
| 468 533 | """ |
| 469 | - def search_single_level(handle, base, [filter: :less, type: type, value: value], def) do |
| 470 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 534 | + def search_single_level(handle, base, [filter: :less, type: type, value: value], defer) do |
| 535 | + search_timeout = |
| 536 | + Application.get_env(:elixir_ldap, :settings) |
| 471 537 | |> Keyword.get(:search_time) || 0 |
| 472 | - search(handle, base, :single_level, less_or_equal(type, value), def, false, search_timeout) |
| 538 | + |
| 539 | + search(handle, base, :single_level, less_or_equal(type, value), defer, false, search_timeout) |
| 473 540 | end |
| 474 541 | |
| 475 542 | @doc """ |
| @@ -488,22 +555,41 @@ defmodule ElixirLdap.Search do | |
| 488 555 | * deref_always - Always refer to alias entries |
| 489 556 | |
| 490 557 | """ |
| 491 | - def search_single_level(handle, base, [filter: :approx, type: type, value: value], def) do |
| 492 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 558 | + def search_single_level(handle, base, [filter: :approx, type: type, value: value], defer) do |
| 559 | + search_timeout = |
| 560 | + Application.get_env(:elixir_ldap, :settings) |
| 493 561 | |> Keyword.get(:search_time) || 0 |
| 494 | - search(handle, base, :single_level, approx_match(type, value), def, false, search_timeout) |
| 562 | + |
| 563 | + search(handle, base, :single_level, approx_match(type, value), defer, false, search_timeout) |
| 495 564 | end |
| 496 565 | |
| 497 | - def search_single_level(handle, base, [filter: :extensible, value: value, type: type, rule: rule, dn_attributes: dn_attribute], def) do |
| 498 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 566 | + def search_single_level( |
| 567 | + handle, |
| 568 | + base, |
| 569 | + [filter: :extensible, value: value, type: type, rule: rule, dn_attributes: dn_attribute], |
| 570 | + defer |
| 571 | + ) do |
| 572 | + search_timeout = |
| 573 | + Application.get_env(:elixir_ldap, :settings) |
| 499 574 | |> Keyword.get(:search_time) || 0 |
| 500 | - search(handle, base, :single_level, extensible_match(value, type, rule, dn_attribute), def, false, search_timeout) |
| 575 | + |
| 576 | + search( |
| 577 | + handle, |
| 578 | + base, |
| 579 | + :single_level, |
| 580 | + extensible_match(value, type, rule, dn_attribute), |
| 581 | + defer, |
| 582 | + false, |
| 583 | + search_timeout |
| 584 | + ) |
| 501 585 | end |
| 502 586 | |
| 503 | - def search_single_level(handle, base, [filter: :strings, type: type, value: value], def) do |
| 504 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 587 | + def search_single_level(handle, base, [filter: :strings, type: type, value: value], defer) do |
| 588 | + search_timeout = |
| 589 | + Application.get_env(:elixir_ldap, :settings) |
| 505 590 | |> Keyword.get(:search_time) || 0 |
| 506 | - search(handle, base, :single_level, substrings(type, value), def, false, search_timeout) |
| 591 | + |
| 592 | + search(handle, base, :single_level, substrings(type, value), defer, false, search_timeout) |
| 507 593 | end |
| 508 594 | |
| 509 595 | @doc """ |
| @@ -518,14 +604,24 @@ defmodule ElixirLdap.Search do | |
| 518 604 | ElixirLdap.Search.search_subtree(handle, [filter: :less, type: 'age', value: "22"]) |
| 519 605 | |
| 520 606 | """ |
| 521 | - def search_subtree(handle, options) do |
| 522 | - base = Application.get_env(:elixir_ldap, :settings) |
| 607 | + def search_subtree(handle, filter) do |
| 608 | + base = |
| 609 | + Application.get_env(:elixir_ldap, :settings) |
| 523 610 | |> Keyword.get(:base) |
| 524 | - search_subtree(handle, base, options) |
| 611 | + |
| 612 | + search_subtree(handle, base, filter) |
| 525 613 | end |
| 526 614 | |
| 527 | - def search_subtree(handle, base, options) do |
| 528 | - search_subtree(handle, base, options, :deref_always) |
| 615 | + def search_subtree(handle, filter, defer) when is_atom(defer) do |
| 616 | + base = |
| 617 | + Application.get_env(:elixir_ldap, :settings) |
| 618 | + |> Keyword.get(:base) |
| 619 | + |
| 620 | + search_subtree(handle, base, filter, defer) |
| 621 | + end |
| 622 | + |
| 623 | + def search_subtree(handle, base, filter) do |
| 624 | + search_subtree(handle, base, filter, :deref_always) |
| 529 625 | end |
| 530 626 | |
| 531 627 | @doc """ |
| @@ -545,10 +641,20 @@ defmodule ElixirLdap.Search do | |
| 545 641 | * deref_always - Always refer to alias entries |
| 546 642 | |
| 547 643 | """ |
| 548 | - def search_subtree(handle, base, [filter: :equal, field: field, name: name], def) do |
| 549 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 644 | + def search_subtree(handle, base, [filter: :equal, field: field, name: name], defer) do |
| 645 | + search_timeout = |
| 646 | + Application.get_env(:elixir_ldap, :settings) |
| 550 647 | |> Keyword.get(:search_time) || 0 |
| 551 | - search(handle, base, :whole_subtree, equality_match(field, name), def, false, search_timeout) |
| 648 | + |
| 649 | + search( |
| 650 | + handle, |
| 651 | + base, |
| 652 | + :whole_subtree, |
| 653 | + equality_match(field, name), |
| 654 | + defer, |
| 655 | + false, |
| 656 | + search_timeout |
| 657 | + ) |
| 552 658 | end |
| 553 659 | |
| 554 660 | @doc """ |
| @@ -568,10 +674,12 @@ defmodule ElixirLdap.Search do | |
| 568 674 | * deref_always - Always refer to alias entries |
| 569 675 | |
| 570 676 | """ |
| 571 | - def search_subtree(handle, base, [filter: :present, type: type], def) do |
| 572 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 677 | + def search_subtree(handle, base, [filter: :present, type: type], defer) do |
| 678 | + search_timeout = |
| 679 | + Application.get_env(:elixir_ldap, :settings) |
| 573 680 | |> Keyword.get(:search_time) || 0 |
| 574 | - search(handle, base, :whole_subtree, present(type), def, false, search_timeout) |
| 681 | + |
| 682 | + search(handle, base, :whole_subtree, present(type), defer, false, search_timeout) |
| 575 683 | end |
| 576 684 | |
| 577 685 | @doc """ |
| @@ -591,10 +699,20 @@ defmodule ElixirLdap.Search do | |
| 591 699 | * deref_always - Always refer to alias entries |
| 592 700 | |
| 593 701 | """ |
| 594 | - def search_subtree(handle, base, [filter: :greater, type: type, value: value], def) do |
| 595 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 702 | + def search_subtree(handle, base, [filter: :greater, type: type, value: value], defer) do |
| 703 | + search_timeout = |
| 704 | + Application.get_env(:elixir_ldap, :settings) |
| 596 705 | |> Keyword.get(:search_time) || 0 |
| 597 | - search(handle, base, :whole_subtree, greater_or_equal(type, value), def, false, search_timeout) |
| 706 | + |
| 707 | + search( |
| 708 | + handle, |
| 709 | + base, |
| 710 | + :whole_subtree, |
| 711 | + greater_or_equal(type, value), |
| 712 | + defer, |
| 713 | + false, |
| 714 | + search_timeout |
| 715 | + ) |
| 598 716 | end |
| 599 717 | |
| 600 718 | @doc """ |
| @@ -614,28 +732,53 @@ defmodule ElixirLdap.Search do | |
| 614 732 | * deref_always - Always refer to alias entries |
| 615 733 | |
| 616 734 | """ |
| 617 | - def search_subtree(handle, base, [filter: :less, type: type, value: value], def) do |
| 618 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 735 | + def search_subtree(handle, base, [filter: :less, type: type, value: value], defer) do |
| 736 | + search_timeout = |
| 737 | + Application.get_env(:elixir_ldap, :settings) |
| 619 738 | |> Keyword.get(:search_time) || 0 |
| 620 | - search(handle, base, :whole_subtree, less_or_equal(type, value), def, false, search_timeout) |
| 739 | + |
| 740 | + search(handle, base, :whole_subtree, less_or_equal(type, value), defer, false, search_timeout) |
| 621 741 | end |
| 622 742 | |
| 623 | - def search_subtree(handle, base, [filter: :approx, type: type, value: value], def) do |
| 624 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 743 | + def search_subtree(handle, base, [filter: :approx, type: type, value: value], defer) do |
| 744 | + search_timeout = |
| 745 | + Application.get_env(:elixir_ldap, :settings) |
| 625 746 | |> Keyword.get(:search_time) || 0 |
| 626 | - search(handle, base, :whole_subtree, approx_match(type, value), def, false, search_timeout) |
| 747 | + |
| 748 | + search(handle, base, :whole_subtree, approx_match(type, value), defer, false, search_timeout) |
| 627 749 | end |
| 628 750 | |
| 629 | - def search_subtree(handle, base, [filter: :extensible, value: value, type: type, rule: rule, dn_attributes: dn_attribute], def) do |
| 630 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 751 | + def search_subtree( |
| 752 | + handle, |
| 753 | + base, |
| 754 | + [filter: :extensible, value: value, type: type, rule: rule, dn_attributes: dn_attribute], |
| 755 | + defer |
| 756 | + ) do |
| 757 | + search_timeout = |
| 758 | + Application.get_env(:elixir_ldap, :settings) |
| 631 759 | |> Keyword.get(:search_time) || 0 |
| 632 | - search(handle, base, :whole_subtree, extensible_match(value, type, rule, dn_attribute), def, false, search_timeout) |
| 760 | + |
| 761 | + search( |
| 762 | + handle, |
| 763 | + base, |
| 764 | + :whole_subtree, |
| 765 | + extensible_match(value, type, rule, dn_attribute), |
| 766 | + defer, |
| 767 | + false, |
| 768 | + search_timeout |
| 769 | + ) |
| 633 770 | end |
| 634 771 | |
| 635 | - def search_subtree(handle, base, [filter: :strings, type: type, value: value], def) do |
| 636 | - search_timeout = Application.get_env(:elixir_ldap, :settings) |
| 772 | + def search_subtree(handle, base, [filter: :strings, type: type, value: value], defer) do |
| 773 | + search_timeout = |
| 774 | + Application.get_env(:elixir_ldap, :settings) |
| 637 775 | |> Keyword.get(:search_time) || 0 |
| 638 | - search(handle, base, :whole_subtree, substrings(type, value), def, false, search_timeout) |
| 776 | + |
| 777 | + search(handle, base, :whole_subtree, substrings(type, value), defer, false, search_timeout) |
| 778 | + end |
| 779 | + |
| 780 | + def search_subtree(handle, base, filters, defer) when is_tuple(filters) do |
| 781 | + search(handle, base, :whole_subtree, filters, defer, false) |
| 639 782 | end |
| 640 783 | |
| 641 784 | @doc """ |
| @@ -687,35 +830,62 @@ defmodule ElixirLdap.Search do | |
| 687 830 | end |
| 688 831 | |
| 689 832 | @doc """ |
| 833 | + search filter approx_match |
| 834 | + |
| 690 835 | """ |
| 691 836 | def approx_match(type, value) do |
| 692 837 | :eldap.approxMatch(to_charlist(type), to_charlist(value)) |
| 693 838 | end |
| 694 839 | |
| 695 840 | @doc """ |
| 841 | + search filter extensible_match |
| 842 | + |
| 696 843 | """ |
| 697 844 | def extensible_match(match_value, type, matching_rule, dn_attributes \\ false) do |
| 698 845 | if !is_collation_rule?(matching_rule) do |
| 699 846 | raise "not collation rule : " <> matching_rule |
| 700 847 | end |
| 701 | - :eldap.extensibleMatch(to_charlist(match_value), [type: type, matchingRule: matching_rule, dnAttributes: dn_attributes]) |
| 848 | + |
| 849 | + :eldap.extensibleMatch( |
| 850 | + to_charlist(match_value), |
| 851 | + type: type, |
| 852 | + matchingRule: matching_rule, |
| 853 | + dnAttributes: dn_attributes |
| 854 | + ) |
| 702 855 | end |
| 703 856 | |
| 704 857 | @doc """ |
| 858 | + search filter substrings |
| 859 | + |
| 705 860 | """ |
| 706 861 | def substrings(type, value) when is_list(value) do |
| 707 | - lists = Enum.map(value, fn({atom, sub}) -> {atom, to_charlist(sub)} end) |
| 862 | + lists = Enum.map(value, fn {atom, sub} -> {atom, to_charlist(sub)} end) |
| 708 863 | :eldap.substrings(to_charlist(type), lists) |
| 709 864 | end |
| 710 865 | |
| 711 866 | @doc """ |
| 867 | + search filter substrings |
| 868 | + |
| 712 869 | """ |
| 713 870 | def substrings(type, {atom, sub}) do |
| 714 871 | substrings(type, [{atom, sub}]) |
| 715 872 | end |
| 716 873 | |
| 874 | + def add_filter(filters, add_filter) when is_list(filters) do |
| 875 | + filters ++ [add_filter] |
| 876 | + end |
| 877 | + |
| 878 | + def add_filter(filters, add_filter) do |
| 879 | + [filters] ++ [add_filter] |
| 880 | + end |
| 881 | + |
| 882 | + def fix_and_filter(filters) do |
| 883 | + with_and(filters) |
| 884 | + end |
| 885 | + |
| 717 886 | @doc """ |
| 718 887 | and search filter |
| 888 | + |
| 719 889 | """ |
| 720 890 | def with_and(filters) do |
| 721 891 | :eldap.and(filters) |
| @@ -739,48 +909,90 @@ defmodule ElixirLdap.Search do | |
| 739 909 | this function actually search |
| 740 910 | |
| 741 911 | """ |
| 742 | - def search(handle, base, scope, filter, deref, types_only \\ false, timeout \\ 0) |
| 743 | - def search(handle, base, scope, filter, deref, types_only, timeout) when is_list(base) do |
| 912 | + def search( |
| 913 | + handle, |
| 914 | + base, |
| 915 | + scope, |
| 916 | + filter, |
| 917 | + deref \\ :deref_always, |
| 918 | + types_only \\ false, |
| 919 | + timeout \\ 0 |
| 920 | + ) |
| 921 | + |
| 922 | + def search(handle, base, scope, filter, deref, types_only, timeout) |
| 923 | + when is_list(base) and is_atom(scope) and is_list(filter) do |
| 924 | + IO.inspect(filter) |
| 925 | + |
| 744 926 | if is_tuple(List.first(base)) do |
| 745 | - search(handle, [ |
| 927 | + search( |
| 928 | + handle, |
| 929 | + base: to_charlist(to_listchar_atom_key(base)), |
| 930 | + scope: search_scope(scope), |
| 931 | + filter: with_and(filter), |
| 932 | + deref: deref_aliases(deref), |
| 933 | + types_only: types_only, |
| 934 | + timeout: timeout |
| 935 | + ) |
| 936 | + else |
| 937 | + search( |
| 938 | + handle, |
| 939 | + base: to_charlist(base), |
| 940 | + scope: search_scope(scope), |
| 941 | + filter: filter, |
| 942 | + deref: deref_aliases(deref), |
| 943 | + types_only: types_only, |
| 944 | + timeout: timeout |
| 945 | + ) |
| 946 | + end |
| 947 | + end |
| 948 | + |
| 949 | + def search(handle, base, scope, filter, deref, types_only, timeout) |
| 950 | + when is_list(base) and is_atom(scope) and is_tuple(filter) do |
| 951 | + IO.inspect(filter) |
| 952 | + |
| 953 | + if is_tuple(List.first(base)) do |
| 954 | + search( |
| 955 | + handle, |
| 746 956 | base: to_charlist(to_listchar_atom_key(base)), |
| 747 957 | scope: search_scope(scope), |
| 748 958 | filter: filter, |
| 749 959 | deref: deref_aliases(deref), |
| 750 960 | types_only: types_only, |
| 751 961 | timeout: timeout |
| 752 | - ]) |
| 962 | + ) |
| 753 963 | else |
| 754 | - search(handle, [ |
| 964 | + search( |
| 965 | + handle, |
| 755 966 | base: to_charlist(base), |
| 756 967 | scope: search_scope(scope), |
| 757 968 | filter: filter, |
| 758 969 | deref: deref_aliases(deref), |
| 759 970 | types_only: types_only, |
| 760 971 | timeout: timeout |
| 761 | - ]) |
| 972 | + ) |
| 762 973 | end |
| 763 974 | end |
| 764 975 | |
| 765 | - def search(handle, base, scope, filter, deref, types_only, timeout) do |
| 766 | - search(handle, [ |
| 976 | + def search(handle, base, scope, filter, deref, types_only, timeout) when is_atom(scope) do |
| 977 | + search( |
| 978 | + handle, |
| 767 979 | base: to_charlist(base), |
| 768 980 | scope: search_scope(scope), |
| 769 981 | filter: filter, |
| 770 982 | deref: deref_aliases(deref), |
| 771 983 | types_only: types_only, |
| 772 984 | timeout: timeout |
| 773 | - ]) |
| 985 | + ) |
| 774 986 | end |
| 775 987 | |
| 776 988 | def search(handle, options) when is_list(options) do |
| 777 989 | case :eldap.search(handle, options) do |
| 778 990 | {:ok, result} -> |
| 779 991 | result = ElixirLdap.SearchResult.from_record(result) |
| 780 | - {:ok, result.entries |> Enum.map(fn(x) -> ElixirLdap.Entry.from_record(x) end)} |
| 992 | + {:ok, result.entries |> Enum.map(fn x -> ElixirLdap.Entry.from_record(x) end)} |
| 993 | + |
| 781 994 | {_, message} -> |
| 782 995 | {:error, message} |
| 783 996 | end |
| 784 997 | end |
| 785 998 | end |
| 786 | - |
Loading more files…