PACKAGE - Definitions¶

 use Net::LDAP;

INITIALIZING¶

 $ldap = Net::LDAP->new ( "yourLDAPhost.yourCompany.com" ) or die "$@";

BINDING¶

 $mesg = $ldap->bind ( version => 3 );          # use for searches
 $mesg = $ldap->bind ( "$userToAuthenticate",           
                       password => "$passwd",
                       version => 3 );          # use for changes/edits
 # see your LDAP administrator for information concerning the
 # user authentication setup at your site.

OPERATION - Generating a SEARCH¶

 sub LDAPsearch
 {
   my ($ldap,$searchString,$attrs,$base) = @_;
   # if they don't pass a base... set it for them
   if (!$base ) { $base = "o=mycompany, c=mycountry"; }
   # if they don't pass an array of attributes...
   # set up something for them
   if (!$attrs ) { $attrs = [ 'cn','mail' ]; }
   my $result = $ldap->search ( base    => "$base",
                                scope   => "sub",
                                filter  => "$searchString",
                                attrs   =>  $attrs
                              );

}

 my @Attrs = ( );               # request all available attributes
                                # to be returned.
 my $result = LDAPsearch ( $ldap, "sn=*", \@Attrs );

PROCESSING - Displaying SEARCH Results¶

 #------------
 #
 # Accessing the data as if in a structure
 #  i.e. Using the "as_struct"  method
 #
 my $href = $result->as_struct;
 # get an array of the DN names
 my @arrayOfDNs  = keys %$href;        # use DN hashes
 # process each DN using it as a key
 foreach ( @arrayOfDNs ) {
   print $_, "\n";
   my $valref = $$href{$_};
   # get an array of the attribute names
   # passed for this one DN.
   my @arrayOfAttrs = sort keys %$valref; #use Attr hashes
   my $attrName;        
   foreach $attrName (@arrayOfAttrs) {
     # skip any binary data: yuck!
     next if ( $attrName =~ /;binary$/ );
     # get the attribute value (pointer) using the
     # attribute name as the hash
     my $attrVal =  @$valref{$attrName};
     print "\t $attrName: @$attrVal \n";
   }
   print "#-------------------------------\n";
   # End of that DN
 }
 #
 #  end of as_struct method
 #
 #--------
 #------------
 #
 # handle each of the results independently
 # ... i.e. using the walk through method
 #
 my @entries = $result->entries;
 my $entr;
 foreach $entr ( @entries ) {
   print "DN: ", $entr->dn, "\n";
   my $attr;
   foreach $attr ( sort $entr->attributes ) {
     # skip binary we can't handle
     next if ( $attr =~ /;binary$/ );
     print "  $attr : ", $entr->get_value ( $attr ) ,"\n";
   }
   print "#-------------------------------\n";
 }
 #
 # end of walk through method
 #------------

OPERATION - Modifying entries¶

 #
 #   Modify
 #
 #  for each of the modifies below you'll need to supply
 #  a full DN (Distinguished Name) for the $dn variable.
 #   example:
 #    cn=Jo User,ou=person,o=mycompany,c=mycountry
 #
 #   I would recommend doing a search (listed above)
 #   then use the dn returned to populate the $dn variable.
 #
 #  Do we only have one result returned from the search?
 if ( $result->count != 1 ) { exit; }  # Nope.. exit
 my $dn = $entries[0]->dn;         # yes.. get the DN
 #######################################
 #
 #   MODIFY using a HASH
 #
 my %ReplaceHash = ( keyword => "x", proxy => "x" );
 my $result = LDAPmodifyUsingHash ( $ldap, $dn, \%ReplaceHash );
 sub LDAPmodifyUsingHash
 {
   my ($ldap, $dn, $whatToChange ) = @_;
   my $result = $ldap->modify ( $dn,
                                replace => { %$whatToChange }
                              );
   return $result;
 }
 #######################################
 #
 #   MODIFY using a ARRAY List
 #
 my @ReplaceArrayList = [ 'keyword', "xxxxxxxxxx",
                          'proxy' , "yyyyyyyyyy"   ];
 my $result = LDAPmodifyUsingArrayList ( $ldap, $dn, \@ReplaceArrayList );
 sub LDAPmodifyUsingArrayList
 {
   my ($ldap, $dn, $whatToChange ) = @_;
   my $result = $ldap->modify ( $dn,
                                changes => [
                                  replace => @$whatToChange
                                ]
                              );
   return $result;
 }
 #######################################
 #
 #   MODIFY using a ARRAY
 #
 my @ReplaceArray = ( 'keyword', "xxxxxxxxxx" ,
                      'proxy' , "yyyyyyyyyy"   );
 my $result = LDAPmodifyUsingArray ( $ldap, $dn, \@ReplaceArray );
 sub LDAPmodifyUsingArray
 {
   my ($ldap, $dn, $whatToChange ) = @_;
   my $result = $ldap->modify ( $dn,
                                changes => [
                                  replace => [ @$whatToChange ]
                                ]
                              );
   return $result;
 }
 #######################################
 #
 #   MODIFY an existing record using 'Changes'
 #    (or combination of add/delete/replace)
 #
 my @whatToChange;
 my @ReplaceArray;
 my @DeleteArray;
 my @AddArray;
 push @AddArray, 'cn', "me myself";
 push @ReplaceArray, 'sn', '!@#$%^&*()__+Hello There';
 push @ReplaceArray, 'cn', "me myself I";
 push @DeleteArray, 'cn', "me myself";
 if ( $#ReplaceArray > 0 ) {
   push @whatToChange, 'replace';
   push @whatToChange, \@ReplaceArray;
 }
 if ( $#DeleteArray > 0 ) {
   push @whatToChange, 'delete';
   push @whatToChange, \@DeleteArray;
 }
 if ( $#AddArray > 0 ) {
   push @whatToChange, 'add';
   push @whatToChange, \@AddArray;
 }
 $result = LDAPmodify ( $ldap, $dn, \@whatToChange );
 sub LDAPmodify
 {
   my ($ldap, $dn, $whatToChange) = @_;
   my $result = $ldap->modify ( $dn,
                                changes => [
                                  @$whatToChange
                                ]
                              );
   return $result;
 }

OPERATION - Changing the RDN¶

 my $newRDN = "cn=Joseph User";
 my $result = LDAPrdnChange ( $ldap, $dn, $newRDN, "archive" );
 sub LDAPrdnChange
 {
   my ($ldap,$dn,$whatToChange,$action) = @_;
   my $branch;
   #
   # if the archive action is selected, move this
   # entry to another place in the directory.
   #
   if ( $action =~ /archive/i )  {
     $branch = "ou=newbranch, o=mycompany, c=mycountry";
   }
   #
   # use the 'deleteoldrdn' to keep from getting
   # multivalues in the NAMING attribute.
   # in most cases that would be the 'CN' attribute
   #
   my $result = $ldap->moddn ( $dn,
                               newrdn => $whatToChange,
                               deleteoldrdn => '1',
                               newsuperior => $branch
                             );
   return $result;
 }

OPERATION - Adding a new Record¶

 my $DNbranch = "ou=bailiwick, o=mycompany, c=mycountry";
 #
 # check with your Directory Schema or Administrator
 # for the correct objectClass... I'm sure it'll be different
 #
 my $CreateArray = [
   objectClass => [ "top", "person", "organizationalPerson", "inetOrgPerson" ],
   cn => "Jane User",
   uid => "0000001",
   sn => "User",
   mail => "JaneUser@mycompany.com"
 ];
 #
 # create the  new DN to look like this
 # " cn=Jo User + uid=0000001 , ou=bailiwick, o=mycompany, c=mycountry "
 #
 # NOTE: this DN  MUST be changed to meet your implementation
 #
 my $NewDN = "@$CreateArray[2]=".
             "@$CreateArray[3]+".
             "@$CreateArray[4]=".
             "@$CreateArray[5],".
             $DNbranch;
 LDAPentryCreate($ldap, $NewDN, $CreateArray);
 #
 # CreateArray is a reference to an anonymous array
 # you have to dereference it in the  subroutine it's
 # passed to.
 #
 sub LDAPentryCreate
 {
    my ($ldap, $dn, $whatToCreate) = @_;
    my $result = $ldap->add ( $dn, attrs => [ @$whatToCreate ] );
    return $result;
 }

ERROR - Retrieving and Displaying ERROR information¶

 if ( $result->code ) {
   #
   # if we've got an error... record it
   #
   LDAPerror ( "Searching", $result );
 }
 sub LDAPerror
 {
   my ($from, $mesg) = @_;
   print "Return code: ", $mesg->code;
   print "\tMessage: ", $mesg->error_name;
   print " :",          $mesg->error_text;
   print "MessageID: ", $mesg->mesg_id;
   print "\tDN: ", $mesg->dn;
   #---
   # Programmer note:
   #
   #  "$mesg->error" DOESN'T work!!!
   #
   #print "\tMessage: ", $mesg->error;
   #-----
 }

UNBIND¶

 $ldap->unbind;