LDAP Programming in Python

You've heard about the next generation directory protocol called LDAP (lightweight directory access protocol), and you're wondering if it's possible to write programs that can interact with it. Maybe you've even set up an LDAP server of your own, and now you want to write programs for it. To these ends, this article gets you ready to write your own programs to automate the querying process of LDAP servers. Hopefully, it also provides you with a solid foundation for extending your knowledge to write configuration scripts and whatever else you want to do with LDAP.

Most major programming languages have an LDAP API, but I chose to use Python because it is perhaps the easiest and clearest language with which to demonstrate. If you do not already understand the basics of the Python programming language and LDAP, you probably should come back to this tutorial after you have become better acquainted with them.

Writing programs that access LDAP servers is easy to do using Python and python-ldap. The python-ldap package contains a module that wraps the OpenLDAP C API and provides an object-oriented client API to interact with LDAP directory servers. The package also contains modules to do other tasks related to LDAP, such as processing LDIF, LDAPURLs and LDAPv3 schemes and more.

Currently, standard implementations of Python do not come with python-ldap, but you can download it as a third-party package from SourceForge.

The best way to learn is to write an example program, so let's write a small and complete program to fetch some specific contact information from an LDAP server. Because indentation matters in Python, all the code given below is indented, so copy it as you see it.

The first thing we need to do is import the ldap module. So open your favorite text editor and type import ldap. For this program, we need to create two simple functions:

Let's create our main function and set up variables to authenticate with the LDAP server by using def main():.

If you are using a public server, you can leave the values for the who and cred blank. You can get a list of some public LDAP servers here

. It looks something like this:

   server = "ldap.somewhere.edu"
    who = ""
    cred = ""

Now we need to make a keyword set to what we want our search string to be. I use my first name for this sample program:

   keyword = "ryan"

Next, we need to bind to the LDAP server. Doing so creates an object named "l" that is then used throughout the program.

   try:
        l = ldap.open(server)
        l.simple_bind_s(who, cred)
        print "Successfully bound to server.\n"

We're now ready to query the server. We also now catch any possible errors if there is a problem authenticating:

       print "Searching..\n"
        my_search(l, keyword)
    except ldap.LDAPError, error_message:
        print "Couldn't Connect. %s " % error_message

Having written our main function, we now can create our search function:

   def my_search(l, keyword):

In a moment we will be calling python-ldap's built-in search method on our l object. Four variables--base, scope, filter and retrieve_attributes--are the parameters of that search method. Base is used for the DN (distinguished name) of the entry where the search should start. You can leave it blank for this example:

   base = ""

For scope we use SCOPE_SUBTREE to search the object and all its descendants:

   scope = ldap.SCOPE_SUBTREE

Our search filter consists of a cn (common name) and our keyword. Putting asterisks around our keyword (ryan) will match anything with the string ryan, such as Bryant.

   filter = "cn=" + "*" + keyword + "*"

The last argument we pass to the search method is used to return all the attributes of each entry:

   retrieve_attributes = None

Now, let's setup a few more variables, including a counter to keep track of the number of results returned:

   count = 0

a list to append the results to:

   result_set = []

and a variable to specify the length, in seconds, we're willing to wait for a response from the server:

   timeout = 0

Now we can begin our search by calling python-ldap's search method on our l object:

   try:
        result_id = l.search(base, scope, filter, retrieve_attributes)

Store any results in the result_set list

       while 1:
            result_type, result_data = l.result(result_id, timeout)
            if (result_data == []):
                break
            else:
                if result_type == ldap.RES_SEARCH_ENTRY:
                    result_set.append(result_data)

If we were to print result_set now, it might look like a big list of tuples and dicts. Instead, step through it and select only the data we want to see

       if len(result_set) == 0:
            print "No Results."
            return 
        for i in range(len(result_set)):
            for entry in result_set[i]:                 
                try:
                    name = entry[1]['cn'][0]
                    email = entry[1]['mail'][0]
                    phone = entry[1]['telephonenumber'][0]
                    desc = entry[1]['description'][0]
                    count = count + 1

Display the data, if any was found, in the following format:

    1.    Name:    Description:    E-mail:    Phone:    2.    Name:    Description:    E-mail:    Phone:    etc..

                   print "%d.\nName: %s\nDescription: %s\nE-mail: %s\nPhone: %s\n" %\
                           (count, name, desc, email, phone)
                except:
                    pass
    except ldap.LDAPError, error_message:
        print error_message