# phpman > perldoc > Net::LDAP

## NAME
    [Net::LDAP](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP/markdown) - Lightweight Directory Access Protocol

## SYNOPSIS
     use [Net::LDAP](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP/markdown);

     $ldap = [Net::LDAP](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP/markdown)->new( 'ldap.example.com' )  or  die "$@";

     $mesg = $ldap->bind;                         # anonymous bind

     $mesg->code  and  die $mesg->error;          # check for errors

     $srch = $ldap->search( base   => "c=US",     # perform a search
                            filter => "(&(sn=Barr)(o=Texas Instruments))"
                          );

     $srch->code  and  die $srch->error;          # check for errors

     foreach $entry ($srch->entries) { $entry->dump; }

     $mesg = $ldap->unbind;                       # take down session


     $ldap = [Net::LDAP](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP/markdown)->new( 'ldaps://ldap.example.com' )  or  die "$@";

     # simple bind with DN and password
     $mesg = $ldap->bind( 'cn=root, o=University of Michigan, c=us',
                          password => 'secret'
                        );

     $mesg->code  and  die $mesg->error;          # check for errors

     $result = $ldap->add( 'cn=Barbara Jensen, o=University of Michigan, c=US',
                           attrs => [
                             cn          => ['Barbara Jensen', 'Barbs Jensen'],
                             sn          => 'Jensen',
                             mail        => '<b.jensen@umich.edu>',
                             objectclass => ['top', 'person',
                                             'organizationalPerson',
                                             'inetOrgPerson' ],
                           ]
                         );

     $result->code  and  warn "failed to add entry: ", $result->error;

     $mesg = $ldap->unbind;                       # take down session

## DESCRIPTION
    [Net::LDAP](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP/markdown) is a collection of modules that implements a LDAP services API for Perl programs. The
    module may be used to search directories or perform maintenance functions such as adding,
    deleting or modifying entries.

    This document assumes that the reader has some knowledge of the LDAP protocol.

## CONSTRUCTOR
    new ( HOST, OPTIONS )
        Creates a new [Net::LDAP](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP/markdown) object and opens a connection to the named host.

        "HOST" may be a host name or an IP address. TCP port may be specified after the host name
        followed by a colon (such as localhost:10389). The default TCP port for LDAP is 389.

        You can also specify a URI, such as 'ldaps://127.0.0.1:666' or
        'ldapi://%2fvar%2flib%2fldap_sock'. Note that '%2f's in the LDAPI socket path will be
        translated into '/'. This is to support LDAP query options like base, search etc. although
        the query part of the URI will be ignored in this context. If port was not specified in the
        URI, the default is either 389 or 636 for 'LDAP' and 'LDAPS' schemes respectively.

        "HOST" may also be a reference to an array of hosts, host-port pairs or URIs to try. Each
        will be tried in order until a connection is made. Only when all have failed will the result
        of "undef" be returned.

        port => N
            Port to connect to on the remote server. May be overridden by "HOST".

        scheme => 'ldap' | 'ldaps' | 'ldapi'
            Connection scheme to use when not using an URI as "HOST". (Default: ldap)

        keepalive => 1
            If given, set the socket's SO_KEEPALIVE option depending on the Boolean value of the
            option. (Default: use system default)

            Failures in changing the socket's SO_KEEPALIVE option are ignored.

        timeout => N
            Timeout passed to [IO::Socket](https://www.chedong.com/phpMan.php/perldoc/IO%3A%3ASocket/markdown) when connecting the remote server. (Default: 120)

        multihomed => N
            Will be passed to [IO::Socket](https://www.chedong.com/phpMan.php/perldoc/IO%3A%3ASocket/markdown) as the "MultiHomed" parameter when connecting to the remote
            server

        localaddr => HOST
            Will be passed to [IO::Socket](https://www.chedong.com/phpMan.php/perldoc/IO%3A%3ASocket/markdown) as the "LocalAddr" parameter, which sets the client's IP
            address (as opposed to the server's IP address.)

        debug => N
            Set the debug level. See the debug method for details.

        async => 1
            Perform all operations asynchronously.

        onerror => 'die' | 'warn' | 'undef' | sub { ... }
            In synchronous mode, change what happens when an error is detected.

            'die'
                [Net::LDAP](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP/markdown) will croak whenever an error is detected.

            'warn'
                [Net::LDAP](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP/markdown) will warn whenever an error is detected.

            'undef'
                [Net::LDAP](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP/markdown) will warn whenever an error is detected and "-w" is in effect. The method
                that was called will return "undef".

                Note this value is the string 'undef', not the "undef" value.

            sub { ... }
                The given sub will be called in a scalar context with a single argument, the result
                message. The value returned will be the return value for the method that was called.

        version => N
            Set the protocol version being used (default is LDAPv3). This is useful if you want to
            talk to an old server and therefore have to use LDAPv2.

        raw => REGEX
            Use REGEX to denote the names of attributes that are to be considered binary in search
            results.

            When this option is given, [Net::LDAP](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP/markdown) converts all values of attributes not matching this
            REGEX into Perl UTF-8 strings so that the regular Perl operators (pattern matching, ...)
            can operate as one expects even on strings with international characters.

            If this option is not given, attribute values are treated as byte strings.

            Example: raw => qr/(?i:^jpegPhoto|;binary)/

        inet4 => N
        inet6 => N
            Try to connect to the server using the specified IP protocol only, i.e. either IPv4 or
            IPv6. If the protocol selected is not supported, connecting will fail.

            The default is to use any of the two protocols.

        Example

          $ldap = [Net::LDAP](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP/markdown)->new( 'remote.host', async => 1 );

        LDAPS connections have some extra valid options, see the start_tls method for details. Note
        the default port for LDAPS is 636, and the default value for 'sslversion' is the value used
        as default by [IO::Socket::SSL](https://www.chedong.com/phpMan.php/perldoc/IO%3A%3ASocket%3A%3ASSL/markdown).

        For LDAPI connections, HOST is actually the location of a UNIX domain socket to connect to.
        The default location is '/var/run/ldapi'.

## METHODS
    Each of the following methods take as arguments some number of fixed parameters followed by
    options, these options are passed in a named fashion, for example

      $mesg = $ldap->bind( "cn=me,o=example", password => "mypasswd");

    The return value from these methods is an object derived from the [Net::LDAP::Message](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AMessage/markdown) class. The
    methods of this class allow you to examine the status of the request.

    abandon ( ID, OPTIONS )
        Abandon a previously issued request. "ID" may be a number or an object which is a sub-class
        of [Net::LDAP::Message](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AMessage/markdown), returned from a previous method call.

        control => CONTROL
        control => [ CONTROL, ... ]
            See "CONTROLS" below

        callback => CALLBACK
            See "CALLBACKS" below

        Example

          $res = $ldap->search( @search_args );

          $mesg = $ldap->abandon( $res ); # This could be written as $res->abandon

    add ( DN, OPTIONS )
        Add a new entry to the directory. "DN" can be either a [Net::LDAP::Entry](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AEntry/markdown) object or a string.

        attrs => [ ATTR => VALUE, ... ]
            "VALUE" should be a string if only a single value is wanted, or a reference to an array
            of strings if multiple values are wanted.

            This argument is not used if "DN" is a [Net::LDAP::Entry](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AEntry/markdown) object.

        control => CONTROL
        control => [ CONTROL, ... ]
            See "CONTROLS" below

        callback => CALLBACK
            See "CALLBACKS" below

        Example

          # $entry is an object of class [Net::LDAP::Entry](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AEntry/markdown)
          $mesg = $ldap->add( $entry );

          $mesg = $ldap->add( $dn,
                              attrs => [
                                name  => 'Graham Barr',
                                attr  => 'value1',
                                attr  => 'value2',
                                multi => [qw(value1 value2)]
                              ]
                            );

    bind ( DN, OPTIONS )
        Bind (log in) to the server. "DN" is the DN to bind with. An anonymous bind may be done by
        calling bind without any arguments.

        control => CONTROL
        control => [ CONTROL, ... ]
            See "CONTROLS" below

        callback => CALLBACK
            See "CALLBACKS" below

        noauth | anonymous => 1
            Bind without any password. The value passed with this option is ignored.

        password => PASSWORD
            Bind with the given password.

        sasl => SASLOBJ
            Bind using a SASL mechanism. The argument given should be a sub-class of [Authen::SASL](https://www.chedong.com/phpMan.php/perldoc/Authen%3A%3ASASL/markdown) or
            an [Authen::SASL](https://www.chedong.com/phpMan.php/perldoc/Authen%3A%3ASASL/markdown) client connection by calling "client_new" on an [Authen::SASL](https://www.chedong.com/phpMan.php/perldoc/Authen%3A%3ASASL/markdown) object.

            If passed an [Authen::SASL](https://www.chedong.com/phpMan.php/perldoc/Authen%3A%3ASASL/markdown) object then "client_new" will be called to create a client
            connection object. The hostname passed by "[Net::LDAP](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP/markdown)" to "client_new" can be set using
            the "sasl_host" option below. If this is not correct for your environment, consider
            calling "client_new" yourself and passing the client connection object as "SASLOBJ".

        sasl_host => SASLHOST
            When binding using SASL, allow the hostname used in the SASL communication to differ
            from the hostname connected to.

            If "SASLHOST" evaluates to TRUE, then it is used as the SASL hostname.

            If it evaluates to FALSE, then the value is determined by calling "peerhost" on the
            socket. In older versions of [Net::LDAP](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP/markdown) this was the standard behaviour, but it turned
            out to cause more trouble than it fixed.

            When the option is not given, the SASL host name used defaults to the host name / IP
            address taken from the "HOST" parameter when connecting.

        Example

          $mesg = $ldap->bind; # Anonymous bind

          $mesg = $ldap->bind( $dn, password => $password );

          # $sasl is an object of class [Authen::SASL](https://www.chedong.com/phpMan.php/perldoc/Authen%3A%3ASASL/markdown)
          $mesg = $ldap->bind( $dn, sasl => $sasl, version => 3 );

    compare ( DN, OPTIONS )
        Compare values in an attribute in the entry given by "DN" on the server. "DN" may be a
        string or a [Net::LDAP::Entry](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AEntry/markdown) object.

        attr => ATTR
            The name of the attribute to compare.

        value => VALUE
            The value to compare with.

        control => CONTROL
        control => [ CONTROL, ... ]
            See "CONTROLS" below.

        callback => CALLBACK
            See "CALLBACKS" below.

        Example

          $mesg = $ldap->compare( $dn,
                                  attr  => 'cn',
                                  value => 'Graham Barr'
                                );

    delete ( DN, OPTIONS )
        Delete the entry given by "DN" from the server. "DN" may be a string or a [Net::LDAP::Entry](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AEntry/markdown)
        object.

        control => CONTROL
        control => [ CONTROL, ... ]
            See "CONTROLS" below.

        callback => CALLBACK
            See "CALLBACKS" below.

        Example

         $mesg = $ldap->delete( $dn );

    moddn ( DN, OPTIONS )
        Rename the entry given by "DN" on the server. "DN" may be a string or a [Net::LDAP::Entry](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AEntry/markdown)
        object.

        newrdn => RDN
            This value should be a new RDN to assign to "DN".

        deleteoldrdn => 1
            This option should be passed if the existing RDN is to be deleted.

        newsuperior => NEWDN
            If given this value should be the DN of the new superior for "DN".

        control => CONTROL
        control => [ CONTROL, ... ]
            See "CONTROLS" below.

        callback => CALLBACK
            See "CALLBACKS" below.

        Example

         $mesg = $ldap->moddn( $dn, newrdn => 'cn=Graham Barr' );

    modify ( DN, OPTIONS )
        Modify the contents of the entry given by "DN" on the server. "DN" may be a string or a
        [Net::LDAP::Entry](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AEntry/markdown) object.

        add => { ATTR => VALUE, ... }
            Add more attributes or values to the entry. "VALUE" should be a string if only a single
            value is wanted in the attribute, or a reference to an array of strings if multiple
            values are wanted.

              $mesg = $ldap->modify( $dn,
                add => {
                  description => 'List of members',    # Add description attribute
                  member      => [
                    'cn=member1,ou=people,dc=example,dc=com',    # Add to attribute
                    'cn=member2,ou=people,dc=example,dc=com',
                  ]
                }
              );

        delete => [ ATTR, ... ]
            Delete complete attributes from the entry.

              $mesg = $ldap->modify( $dn,
                delete => ['member','description'] # Delete attributes
              );

        delete => { ATTR => VALUE, ... }
            Delete individual values from an attribute. "VALUE" should be a string if only a single
            value is being deleted from the attribute, or a reference to an array of strings if
            multiple values are being deleted.

            If "VALUE" is a reference to an empty array or all existing values of the attribute are
            being deleted, then the attribute will be deleted from the entry.

              $mesg = $ldap->modify( $dn,
                delete => {
                  description => 'List of members',
                  member      => [
                    'cn=member1,ou=people,dc=example,dc=com',    # Remove members
                    'cn=member2,ou=people,dc=example,dc=com',
                  ],
                  seeAlso => [],   # Remove attribute
                }
              );

        replace => { ATTR => VALUE, ... }
            Replace any existing values in each given attribute with "VALUE". "VALUE" should be a
            string if only a single value is wanted in the attribute, or a reference to an array of
            strings if multiple values are wanted. A reference to an empty array will remove the
            entire attribute. If the attribute does not already exist in the entry, it will be
            created.

              $mesg = $ldap->modify( $dn,
                replace => {
                  description => 'New List of members', # Change the description
                  member      => [ # Replace whole list with these
                    'cn=member1,ou=people,dc=example,dc=com',
                    'cn=member2,ou=people,dc=example,dc=com',
                  ],
                  seeAlso => [],   # Remove attribute
                }
              );

        increment => { ATTR => VALUE, ... }
            Atomically increment the existing value in each given attribute by the provided "VALUE".
            The attributes need to have integer syntax, or be otherwise "incrementable". Note this
            will only work if the server advertises support for LDAP_FEATURE_MODIFY_INCREMENT. Use
            "supported_feature" in [Net::LDAP::RootDSE](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3ARootDSE/markdown) to check this.

              $mesg = $ldap->modify( $dn,
                increment => {
                  uidNumber => 1 # increment uidNumber by 1
                }
              );

        changes => [ OP => [ ATTR => VALUE ], ... ]
            This is an alternative to add, delete, replace and increment where the whole operation
            can be given in a single argument. "OP" should be add, delete, replace or increment.
            "VALUE" should be either a string or a reference to an array of strings, as before.

            Use this form if you want to control the order in which the operations will be
            performed.

              $mesg = $ldap->modify( $dn,
                changes => [
                  add => [
                    description => 'A description',
                    member      => $newMember,
                  ],
                  delete => [
                    seeAlso => [],
                  ],
                  add => [
                    anotherAttribute => $value,
                  ],
                ]
              );

        control => CONTROL
        control => [ CONTROL, ... ]
            See "CONTROLS" below.

        callback => CALLBACK
            See "CALLBACKS" below.

        Example

         $mesg = $ldap->modify( $dn, add => { sn => 'Barr' } );

         $mesg = $ldap->modify( $dn, delete => [qw(faxNumber)] );

         $mesg = $ldap->modify( $dn, delete => { 'telephoneNumber' => '911' } );

         $mesg = $ldap->modify( $dn, replace => { 'mail' => '<gbarr@pobox.com>' } );

         $mesg = $ldap->modify( $dn,
                                changes => [
                                    # add sn=Barr
                                  add     => [ sn => 'Barr' ],
                                    # delete all fax numbers
                                  delete  => [ faxNumber => []],
                                    # delete phone number 911
                                  delete  => [ telephoneNumber => ['911']],
                                    # change email address
                                  replace => [ mail => '<gbarr@pobox.com>']
                                ]
                              );

    search ( OPTIONS )
        Search the directory using a given filter. This can be used to read attributes from a single
        entry, from entries immediately below a particular entry, or a whole subtree of entries.

        The result is an object of class [Net::LDAP::Search](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3ASearch/markdown).

        base => DN
            The DN that is the base object entry relative to which the search is to be performed.

        scope => 'base' | 'one' | 'sub' | 'subtree' | 'children'
            By default the search is performed on the whole tree below the specified base object.
            This maybe changed by specifying a "scope" parameter with one of the following values:

            base
                Search only the base object.

            one Search the entries immediately below the base object.

            sub
            subtree
                Search the whole tree below (and including) the base object. This is the default.

            children
                Search the whole subtree below the base object, excluding the base object itself.

                Note: *children* scope requires LDAPv3 subordinate feature extension.

        deref => 'never' | 'search' | 'find' | 'always'
            By default aliases are dereferenced to locate the base object for the search, but not
            when searching subordinates of the base object. This may be changed by specifying a
            "deref" parameter with one of the following values:

            never
                Do not dereference aliases in searching or in locating the base object of the
                search.

            search
                Dereference aliases in subordinates of the base object in searching, but not in
                locating the base object of the search.

            find
                Dereference aliases in locating the base object of the search, but not when
                searching subordinates of the base object. This is the default.

            always
                Dereference aliases both in searching and in locating the base object of the search.

        sizelimit => N
            A sizelimit that restricts the maximum number of entries to be returned as a result of
            the search. A value of 0, and the default, means that no restriction is requested.
            Servers may enforce a maximum number of entries to return.

        timelimit => N
            A timelimit that restricts the maximum time (in seconds) allowed for a search. A value
            of 0 (the default), means that no timelimit will be requested.

        typesonly => 1
            Only attribute types (no values) should be returned. Normally attribute types and values
            are returned.

        filter => FILTER
            A filter that defines the conditions an entry in the directory must meet in order for it
            to be returned by the search. This may be a string or a [Net::LDAP::Filter](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AFilter/markdown) object. Values
            inside filters may need to be escaped to avoid security problems; see [Net::LDAP::Filter](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AFilter/markdown)
            for a definition of the filter format, including the escaping rules.

        attrs => [ ATTR, ... ]
            A list of attributes to be returned for each entry that matches the search filter.

            If not specified, then the server will return the attributes that are specified as
            accessible by default given your bind credentials.

            Certain additional attributes such as "createTimestamp" and other operational attributes
            may also be available for the asking:

              $mesg = $ldap->search( ... ,
                                     attrs => ['createTimestamp']
                                   );

            To retrieve the default attributes and additional ones, use '*'.

              $mesg = $ldap->search( ... ,
                                     attrs => ['*', 'createTimestamp']
                                   );

            To retrieve no attributes (the server only returns the DNs of matching entries), use
            '1.1':

              $mesg = $ldap->search( ... ,
                                     attrs => ['1.1']
                                   );

        control => CONTROL
        control => [ CONTROL, ... ]
            See "CONTROLS" below.

        callback => CALLBACK
            See "CALLBACKS" below.

        raw => REGEX
            Use REGEX to denote the names of attributes that are to be considered binary in search
            results.

            When this option is given, [Net::LDAP](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP/markdown) converts all values of attributes not matching this
            REGEX into Perl UTF-8 strings so that the regular Perl operators (pattern matching, ...)
            can operate as one expects even on strings with international characters.

            If this option is not given, attribute values are treated as byte strings.

            The value provided here overwrites the value inherited from the constructor.

            Example: raw => qr/(?i:^jpegPhoto|;binary)/

        Example

         $mesg = $ldap->search(
                                base   => $base_dn,
                                scope  => 'sub',
                                filter => '(|(objectclass=rfc822mailgroup)(sn=jones))'
                              );

         [Net::LDAP::LDIF](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3ALDIF/markdown)->new( \*STDOUT,"w" )->write( $mesg->entries );

    start_tls ( OPTIONS )
        Calling this method will convert the existing connection to using Transport Layer Security
        (TLS), which provides an encrypted connection. This is *only* possible if the connection
        uses LDAPv3, and requires that the server advertises support for LDAP_EXTENSION_START_TLS.
        Use "supported_extension" in [Net::LDAP::RootDSE](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3ARootDSE/markdown) to check this.

        verify => 'none' | 'optional' | 'require'
            How to verify the server's certificate:

            none
                The server may provide a certificate but it will not be checked - this may mean you
                are be connected to the wrong server

            optional
                Verify only when the server offers a certificate

            require
                The server must provide a certificate, and it must be valid.

            If you set verify to optional or require, you must also set either cafile or capath. The
            most secure option is require.

        sslversion => 'sslv2' | 'sslv3' | 'sslv23' | 'tlsv1' | 'tlsv1_1' | 'tlsv1_2'
            This defines the version of the SSL/TLS protocol to use. Default is to use the value
            that [IO::Socket::SSL](https://www.chedong.com/phpMan.php/perldoc/IO%3A%3ASocket%3A%3ASSL/markdown) uses as default.

            See "SSL_version" in [IO::Socket::SSL](https://www.chedong.com/phpMan.php/perldoc/IO%3A%3ASocket%3A%3ASSL/markdown) for more details.

        sslserver => SSLHOST
            Allow changing the server name to use in certificate hostname verification in case the
            target hostname does not match the LDAP server's certificate. If not given it defaults
            to the name of the HOST connected to.

            See "SSL_verifycn_name" in [IO::Socket::SSL](https://www.chedong.com/phpMan.php/perldoc/IO%3A%3ASocket%3A%3ASSL/markdown) for more details.

        ciphers => CIPHERS
            Specify which subset of cipher suites are permissible for this connection, using the
            standard OpenSSL string format. The default behavior is to keep the decision on the
            underlying cryptographic library.

        clientcert => '/path/to/cert.pem'
        clientkey => '/path/to/key.pem'
        keydecrypt => sub { ... }
            If you want to use the client to offer a certificate to the server for SSL
            authentication (which is not the same as for the LDAP Bind operation) then set
            clientcert to the user's certificate file, and clientkey to the user's private key file.
            These files must be in PEM format.

            If the private key is encrypted (highly recommended) then keydecrypt should be a
            subroutine that returns the decrypting key. For example:

             $ldap = [Net::LDAP](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP/markdown)->new( 'myhost.example.com', version => 3 );
             $mesg = $ldap->start_tls(
                                       verify => 'require',
                                       clientcert => 'mycert.pem',
                                       clientkey => 'mykey.pem',
                                       keydecrypt => sub { 'secret'; },
                                       capath => '/usr/local/cacerts/'
                                     );

        capath => '/path/to/servercerts/'
        cafile => '/path/to/servercert.pem'
            When verifying the server's certificate, either set capath to the pathname of the
            directory containing CA certificates, or set cafile to the filename containing the
            certificate of the CA who signed the server's certificate. These certificates must all
            be in PEM format.

            The directory in 'capath' must contain certificates named using the hash value of the
            certificates' subject names. To generate these names, use OpenSSL like this in Unix:

                ln -s cacert.pem `openssl x509 -hash -noout < cacert.pem`.0

            (assuming that the certificate of the CA is in cacert.pem.)

        checkcrl => 1
            If capath has been configured, then it will also be searched for certificate revocation
            lists (CRLs) when verifying the server's certificate. The CRLs' names must follow the
            form hash.rnum where hash is the hash over the issuer's DN and num is a number starting
            with 0.

            See "SSL_check_crl" in [IO::Socket::SSL](https://www.chedong.com/phpMan.php/perldoc/IO%3A%3ASocket%3A%3ASSL/markdown) for further information.

    unbind ( )
        The unbind method does not take any parameters and will unbind you from the server. Some
        servers may allow you to re-bind or perform other operations after unbinding. If you wish to
        switch to another set of credentials while continuing to use the same connection, re-binding
        with another DN and password, without unbind-ing, will generally work.

        Example

         $mesg = $ldap->unbind;

    done ( )
        Convenience alias for "unbind()", named after the clean-up method of [Net::LDAP::LDIF](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3ALDIF/markdown).

    The following methods are for convenience, and do not return "[Net::LDAP::Message](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AMessage/markdown)" objects.

    async ( VALUE )
        If "VALUE" is given the async mode will be set. The previous value will be returned. The
        value is *true* if LDAP operations are being performed asynchronously.

    certificate ( )
        Returns an X509_Certificate object containing the server's certificate. See the
        [IO::Socket::SSL](https://www.chedong.com/phpMan.php/perldoc/IO%3A%3ASocket%3A%3ASSL/markdown) documentation for information about this class.

        For example, to get the subject name (in a peculiar OpenSSL-specific format, different from
        RFC 1779 and RFC 4514) from the server's certificate, do this:

            print "Subject DN: " . $ldaps->certificate->subject_name . "\n";

    cipher ( )
        Returns the cipher mode being used by the connection, in the string format used by OpenSSL.

    debug ( VALUE )
        If "VALUE" is given the debug bit-value will be set. The previous value will be returned.
        Debug output will be sent to "STDERR". The bits of this value are:

         1   Show outgoing packets (using asn_hexdump).
         2   Show incoming packets (using asn_hexdump).
         4   Show outgoing packets (using asn_dump).
         8   Show incoming packets (using asn_dump).

        The default value is 0.

    disconnect ( )
        Disconnect from the server

    root_dse ( OPTIONS )
        The root_dse method retrieves cached information from the server's rootDSE.

        attrs => [ ATTR, ... ]
            A reference to a list of attributes to be returned. If not specified, then the following
            attributes will be requested

              subschemaSubentry
              namingContexts
              altServer
              supportedExtension
              supportedFeatures
              supportedControl
              supportedSASLMechanisms
              supportedLDAPVersion

        The result is an object of class [Net::LDAP::RootDSE](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3ARootDSE/markdown).

        Example

         my $root = $ldap->root_dse;
         # get naming Context
         $root->get_value( 'namingContexts', asref => 1 );
         # get supported LDAP versions
         $root->supported_version;

        As the root DSE may change in certain circumstances - for instance when you change the
        connection using start_tls - you should always use the root_dse method to return the most
        up-to-date copy of the root DSE.

    schema ( OPTIONS )
        Read schema information from the server.

        The result is an object of class [Net::LDAP::Schema](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3ASchema/markdown). Read this documentation for further
        information about methods that can be performed with this object.

        dn => DN
            If a DN is supplied, it will become the base object entry from which the search for
            schema information will be conducted. If no DN is supplied the base object entry will be
            determined from the rootDSE entry.

        Example

         my $schema = $ldap->schema;
         # get objectClasses
         @ocs = $schema->all_objectclasses;
         # Get the attributes
         @atts = $schema->all_attributes;

    sasl ( )
        Returns the "[Authen::SASL](https://www.chedong.com/phpMan.php/perldoc/Authen%3A%3ASASL/markdown)" object associated with the LDAP object, or "undef" if there
        isn't.

    socket ( OPTIONS )
        Returns the underlying socket object being used.

        The exact object type returned depends on whether SASL layers are established. Without SASL
        layers the result is always an "[IO::Socket](https://www.chedong.com/phpMan.php/perldoc/IO%3A%3ASocket/markdown)" object; with SASL layers the outcome depends on
        the options given:

        sasl_layer => FLAG
            This option is only relevant if SASL layers are established.

            If it it missing or if is set to a TRUE value, then the SASL layer handle is returned.
            Depending on the SASL library used, the object returned is not necessarily an
            "[IO::Socket](https://www.chedong.com/phpMan.php/perldoc/IO%3A%3ASocket/markdown)" object.

            If it exists, but is set to a value evaluating to FALSE, then the base "[IO::Socket](https://www.chedong.com/phpMan.php/perldoc/IO%3A%3ASocket/markdown)"
            object underneath the SASL layer is returned.

    host ( )
        Returns the host to which the connection was established. For LDAPI connections the socket
        path is returned.

    port ( )
        Returns the port connected to or "undef" in case of LDAPI connections.

    uri ( )
        Returns the URI connected to.

        As the value returned is that element of the constructor's HOST argument with which the
        connection was established this may or may not be a legal URI.

    scheme ( )
        Returns the scheme of the connection. One of *ldap*, *ldaps* or *ldapi*.

    sync ( MESG )
        Wait for a given "MESG" request to be completed by the server. If no "MESG" is given, then
        wait for all outstanding requests to be completed.

        Returns an error code defined in [Net::LDAP::Constant](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AConstant/markdown).

    process ( MESG )
        Process any messages that the server has sent, but do not block. If "MESG" is specified then
        return as soon as "MESG" has been processed.

        Returns an error code defined in [Net::LDAP::Constant](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AConstant/markdown).

    version ( )
        Returns the version of the LDAP protocol that is being used.

## CONTROLS
    Many of the methods described above accept a control option. This allows the user to pass
    controls to the server as described in LDAPv3.

    A control is a reference to a HASH and should contain the three elements below. If any of the
    controls are blessed then the method "to_asn" will be called which should return a reference to
    a HASH containing the three elements described below.

    For most purposes [Net::LDAP::Control](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AControl/markdown) objects are the easiest way to generate controls.

    type => OID
        This element must be present and is the name of the type of control being requested.

    critical => FLAG
        critical is optional and should be a Boolean value, if it is not specified then it is
        assumed to be *false*.

    value => VALUE
        If the control being requested requires a value then this element should hold the value for
        the server.

## CALLBACKS
    Most of the above commands accept a callback option. This option should be a reference to a
    subroutine. This subroutine will be called for each packet received from the server as a
    response to the request sent.

    When the subroutine is called the first argument will be the [Net::LDAP::Message](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AMessage/markdown) object which was
    returned from the method.

    If the request is a search then multiple packets can be received from the server. Each entry is
    received as a separate packet. For each of these the subroutine will be called with a
    [Net::LDAP::Entry](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AEntry/markdown) object as the second argument.

    During a search the server may also send a list of references. When such a list is received then
    the subroutine will be called with a [Net::LDAP::Reference](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AReference/markdown) object as the second argument.

## LDAP ERROR CODES
    [Net::LDAP](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP/markdown) also exports constants for the error codes that can be received from the server, see
    [Net::LDAP::Constant](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AConstant/markdown).

## SEE ALSO
    [Net::LDAP::Constant](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AConstant/markdown), [Net::LDAP::Control](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AControl/markdown), [Net::LDAP::Entry](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AEntry/markdown), [Net::LDAP::Filter](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AFilter/markdown),
    [Net::LDAP::Message](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AMessage/markdown), [Net::LDAP::Reference](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3AReference/markdown), [Net::LDAP::Search](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3ASearch/markdown), [Net::LDAP::RFC](https://www.chedong.com/phpMan.php/perldoc/Net%3A%3ALDAP%3A%3ARFC/markdown)

    The homepage for the perl-ldap modules can be found at <http://ldap.perl.org/>.

## ACKNOWLEDGEMENTS
    This document is based on a document originally written by Russell Fulton
    <<r.fulton@auckland.ac.nz>>.

    Chris Ridd <<chris.ridd@isode.com>> for the many hours spent testing and contribution of the ldap*
    command line utilities.

## MAILING LIST
    A discussion mailing list is hosted by the Perl Foundation at <<perl-ldap@perl.org>> No
    subscription is necessary!

## BUGS
    We hope you do not find any, but if you do please report them to the mailing list.

    If you have a patch, please send it as an attachment to the mailing list.

## AUTHOR
    Graham Barr <<gbarr@pobox.com>>

## COPYRIGHT
    Copyright (c) 1997-2004 Graham Barr. All rights reserved. This program is free software; you can
    redistribute it and/or modify it under the same terms as Perl itself.