package ldap

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Basic Data Types
Local Representation of LDAP Objects
Miscallaneous
Communication With Ldap_funclient
Interacting with LDAP Servers
Iterators Over Streams of ldapentry Objects
Schema Aware ldapentry Derivatives
1. General Schema Aware Entry
Schema Aware Entry for Account Managment

package ldap

ldap
- Library ldap
- Library ldap.ldif
- Library ldap.toplevel
  - Ldap_toplevel
- Sources
  - ldap
    
    lber.ml
    
    ldap_dn.ml
    
    ldap_dnlexer.ml
    
    ldap_dnparser.ml
    
    ldap_error.ml
    
    ldap_filter.ml
    
    ldap_filterlexer.ml
    
    ldap_filterparser.ml
    
    ldap_funclient.ml
    
    ldap_funserver.ml
    
    ldap_mutex.ml
    
    ldap_ooclient.ml
    
    ldap_protocol.ml
    
    ldap_schemalexer.ml
    
    ldap_schemaparser.ml
    
    ldap_txooclient.ml
    
    ldap_types.ml
    
    ldap_url.ml
    
    ldap_urllexer.ml
    
    ulist.ml
  - ldap.ldif
    
    ldif_changerec_lexer.ml
    
    ldif_changerec_oo.ml
    
    ldif_changerec_parser.ml
    
    ldif_oo.ml
    
    ldif_parser.ml
  - ldap.toplevel
    
    ldap_toplevel.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Ldap_ooclient`Source

an object oriented ldap client interface

Basic Data Types

Sourcetype op = string * string list

the type of an operation, eg. ("cn", ["foo";"bar"])

Sourcetype op_lst = op list

Sourcetype referral_policy = [

| `FOLLOW
| `RETURN

]

The policy the client should take when it encounteres a referral. This is currently not used

Sourcetype changetype = [

| `ADD
| `DELETE
| `MODDN
| `MODIFY
| `MODRDN

]

The change type of an ldapentry. This controls some aspects of it's behavior

Local Representation of LDAP Objects

Sourceclass type ldapentry_t = object ... end

The base type of an ldap entry represented in memory.

Sourceclass ldapentry : object ... end

this object represents a remote object within local memory. It records all local changes made to it (if it's changetype is set to `MODIFY), and can commit them to the server at a later time via Ldap_ooclient.ldapcon.update_entry.

Miscallaneous

Source

val format_entry : 
  < attributes : string list
    ; dn : string
    ; get_value : string -> string list.. > ->
  unit

toplevel formatter for ldapentry, prints the whole entry with a nice structure. Each attribute is in the correct syntax to be copied and pasted into a modify operation.

Source

val format_entries : 
  < attributes : string list
    ; dn : string
    ; get_value : string -> string list.. >
    list ->
  unit

format lists of entries, in this case only print the dn

Sourcetype changerec = [

| `Modification of string * (Ldap_types.modify_optype * string * string list) list
| `Addition of ldapentry
| `Delete of string
| `Modrdn of string * int * string

]

The type of an ldap change record, used by extended LDIF

Communication With `Ldap_funclient`

Source

val to_entry : 
  [< `Entry of Ldap_types.search_result_entry | `Referral of string list ] ->
  ldapentry

given a search_result_entry as returned by ldap_funclient, produce an ldapentry containing either the entry, or the referral object

Sourceval of_entry : ldapentry -> Ldap_types.search_result_entry

given an ldapentry as returned by ldapcon, or constructed manually, produce a search_result_entry suitable for ldap_funclient, or ldap_funserver.

Interacting with LDAP Servers

Source

class ldapcon : ?connect_timeout:int -> ?referral_policy:[> `RETURN ] -> ?version:
  int -> string list -> object ... end

This class abstracts a connection to an LDAP server (or servers), an instance will be connected to the server you specify and can be used to perform operations on that server.

Iterators Over Streams of ldapentry Objects

Sourceval iter : (ldapentry -> unit) -> (?abandon:bool -> unit -> ldapentry) -> unit

given a source of ldapentry objects (unit -> ldapentry), such as the return value of ldapcon#search_a, apply f (first arg) to each entry See List.iter

Source

val rev_map : 
  (ldapentry -> 'a) ->
  (?abandon:bool -> unit -> ldapentry) ->
  'a list

given a source of ldapentry objects (unit -> ldapentry), such as the return value of ldapcon#search_a apply f (first arg) to each entry in reverse, and return a list containing the result of each application. See List.map

Sourceval map : (ldapentry -> 'a) -> (?abandon:bool -> unit -> ldapentry) -> 'a list

same as rev_map, but does it in order

Source

val fold : 
  (ldapentry -> 'a -> 'a) ->
  'a ->
  (?abandon:bool -> unit -> ldapentry) ->
  'a

given a source of ldapentry objects (unit -> ldapentry), such as the return value of ldapcon#search_a compute (f eN ... (f e2 (f e1 intial))) see List.fold_right.

Schema Aware ldapentry Derivatives

General Schema Aware Entry

Ldap_ooclient.scldapentry, A schema aware derivative of Ldap_ooclient.ldapentry. It contains an rfc2252 schema checker, and given the database schema, it can be used to garentee that operations performed in memory are valid against a standards compliant database. It has numerious uses, translation between two databases with different schemas an example of where it finds natural usage. For an example application

see http://tdir.sourceforge.net
tdir

Sourcemodule OrdOid : sig ... end

an ordered oid type, for placing oids in sets

Sourcemodule Setstr : sig ... end

A set of Oids

Sourcetype scflavor =

| Optimistic
(*
Add missing attributes to make the object consistant, or add objectclasses in order to make illegal attribues legal
*)
| Pessimistic
(*
Delete objectclasses which must attributes which are missing, and delete illegal attributes.
*)

The type of schema checking to perform in Ldap_ooclient.scldapentry. Normally this is picked automatically, however it can be overridden in some cases.

Source

val attrToOid : 
  Ldap_schemaparser.schema ->
  Ldap_schemaparser.Lcstring.t ->
  Ldap_schemaparser.Oid.t

given a name of an attribute name (canonical or otherwise), return its oid

raises Invalid_attribute
If the attribute is not found in the schema.

Sourceval oidToAttr : Ldap_schemaparser.schema -> Ldap_schemaparser.Oid.t -> string

given the oid of an attribute, return its canonical name

raises
Invalid_attribute If the attribute is not found in the schema.

Source

val ocToOid : 
  Ldap_schemaparser.schema ->
  Ldap_schemaparser.Lcstring.t ->
  Ldap_schemaparser.Oid.t

given a name of an objectclass (canonical or otherwise), return its oid.

raises Invalid_objectclass
If the objectclass is not found in the schema.

Sourceval oidToOc : Ldap_schemaparser.schema -> Ldap_schemaparser.Oid.t -> string

given the oid of an objectclass, return its canonical name

raises
Invalid_objectclass If the objectclass is not found in the schema.

Source

val getOc : 
  Ldap_schemaparser.schema ->
  Ldap_schemaparser.Lcstring.t ->
  Ldap_schemaparser.objectclass

get an objectclass structure by one of its names (canonical or otherwise, however getting it by canonical name is currently much faster)

raises Invalid_objectclass
If the objectclass is not found in the schema.

Source

val getAttr : 
  Ldap_schemaparser.schema ->
  Ldap_schemaparser.Lcstring.t ->
  Ldap_schemaparser.attribute

get an attr structure by one of its names (canonical or otherwise, however getting it by canonical name is currently much faster)

raises Invalid_attribute
If the attribute is not found in the schema.

Source

val equateAttrs : 
  Ldap_schemaparser.schema ->
  Ldap_schemaparser.Lcstring.t ->
  Ldap_schemaparser.Lcstring.t ->
  bool

equate attributes by oid. This allows non canonical names to be handled correctly, for example "uid" and "userID" are actually the same attribute.

raises Invalid_attribute
If either attribute is not found in the schema.

Sourceexception Invalid_objectclass of string

Sourceexception Invalid_attribute of string

Sourceexception Single_value of string

Sourceexception Objectclass_is_required

Sourceclass scldapentry : Ldap_schemaparser.schema -> object ... end

Schema Aware Entry for Account Managment

A derivative of Ldap_ooclient.scldapentry which includes abstractions for managing user accounts in the directory. This class is experimantal, and may be drastically changed in the next version. As with all experimental code, use with caution. A few of its features.

Loosely dependant attributes: Many attributes are derived from others via a function. ldapaccount allows you to codify that relationship by providing an attribute generator (Ldap_ooclient.generator) for the attribute, which will be used to derive it's value except in the case that it is specified explicitly
Attribute and Generator Grouping: via the service abstraction. Allows you to group attributes together with generators and default values in interesting ways. You can then assign the whole grouping a name, and refer to it by that name. See Ldap_ooclient.service
Difference Based: Service operations are difference based, all applications of service operations compute the delta between the current object, and what the service requires. The minumum set of changes necessary to satisfy the service are applied to the object.
Idempotentcy: As a result of being difference based, Service operations are itempotent. For example, adding a service twice has no effect on the object. It will not queue changes for modification to the directory, and it will not change the object in memory. Deleting a service twice has no effect...etc

Sourcetype generator = {

gen_name : string;
required : string list;
genfun : ldapentry_t -> string list;

}

The structure of a generator

Sourcetype service = {

svc_name : string;
static_attrs : (string * string list) list;
generate_attrs : string list;
depends : string list;

}

The structure of a service

Sourcetype generation_error =

| Missing_required of string list
| Generator_error of string

The type of error raised by attribute generators

Sourceexception No_generator of string

You've asked it to generate an attribute (in a service) which doesn't have a generator

Sourceexception Generation_failed of generation_error

Generator has failed because of some kind of error

Sourceexception No_service of string

The service you're talking about doesn't exist

Sourceexception Service_dep_unsatisfiable of string

A service which the one you tried to add depends on doesn't exists

Sourceexception Generator_dep_unsatisfiable of string * string

Your generator depends on an attribute which isn't in the schema

Sourceexception Cannot_sort_dependancies of string list

You have detached cycles in your generator dependancy lists

Source

class ldapaccount : Ldap_schemaparser.schema -> (string, generator) Hashtbl.t -> (string,
                                                                  service)
                                                                  Hashtbl.t -> object ... end

package ldap

Module Ldap_ooclientSource

Basic Data Types

Local Representation of LDAP Objects

Miscallaneous

Communication With Ldap_funclient

Interacting with LDAP Servers

Iterators Over Streams of ldapentry Objects

Schema Aware ldapentry Derivatives

General Schema Aware Entry

Schema Aware Entry for Account Managment

Module `Ldap_ooclient`Source

Communication With `Ldap_funclient`