👤
Home Man
Search
Today's Posts
Register

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:
Select Section of Man Page:
Select Man Page Repository:

CentOS 7.0 - man page for net::ldap::examples (centos section 3)

Net::LDAP::Examples(3)	       User Contributed Perl Documentation	   Net::LDAP::Examples(3)

NAME
       Net::LDAP::Examples - PERL LDAP by Example

DESCRIPTION
       The following examples are of course PERL code, found to work with the Net::LDAP modules.

       The intent of this document is to give the reader a cut and paste jump start to getting an
       LDAP application working.

       Below you will find snippets of code that should work as-is with only a small amount of
       work to correct any variable assignments and LDAP specifics, e.g. Distinguished Name
       Syntax, related to the user's own implementation.

       The Standard Operating Proceedure that is followed here is:

       1 Package      - use Net::LDAP
       2 Initialization    - new
       3 Binding      - bind
       4 Operation    - add modify moddn search
       4.1 Processing - displaying data from a search
       5 Error	      - displaying error information
       6 Unbinding    - unbind

       Look to each of these for a snippet of code to meet your needs.

       What is not covered in these examples at this time:

       abandon and compare methods
       callback subroutines

CODE
   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;

LDAP SCHEMA RETRIEVAL
       The following code snippet shows how to retrieve schema information.

       The first procedure is to initialize a new LDAP object using the same procedures as listed
       at the beginning of this document.

       The second procedure is to bind to your directory server.  Some servers may require
       authentication to retrieve the schema from the directory server.  This procedure is listed
       at the beginning of this document too.

       After a successful bind you are ready to retrieve the schema information.  You do this by
       initializing a schema object.

	$schema = $ldap->schema ( );

       In this case Net::LDAP will attempt to determine the dn under which the schema can be
       found. First it will look for the attribute "subschemasubentry" in the root DSE. If that
       cannot be found then it will default to the assumption of "cn=schema"

       Alternatively you can specify the dn where the schema is to be found with

	$schema = $ldap->schema ( dn => $dn );

       Once we have a dn to search for, Net::LDAP will fetch the schema entry with

	 $mesg = $self->search ( base	=> $dn,
				 scope	=> 'base',
				 filter => '(objectClass=subschema)',
			       );

       Once the schema object has been initialized, schema methods are used to retrieve the data.
       There are a number of ways this can be done.  Information on the schema methods can be
       found in the Net::LDAP::Schema pod documentation.

       The following is a code snippet showing how to get and display information about returned
       attributes.

	#
	# Get the attributes
	#

	@attributes = $schema->all_attributes ( );

	#
	# Display the attributes
	#

	foreach $ar ( @attributes ) {
	  print "attributeType: ", $ar->{name}, "\n";

	  #
	  # Print all the details
	  #

	  foreach $key ( keys %{$ar} ) {
	    print join ( "\n\t\t", "\t$key:",
			 ref ( $ar->{$key} ) ? @{$ar->{$key}} : $ar->{$key}
		       ), "\n";
	  }
	}

       The process is the basically the same for getting objectClass information.  Where
       schema->all_attributes() is used, substitute schema->all_objectclasses().  From that point
       on the process is the same for both objectClasses and attributes.

BUGS
       None known, but there may be some

AUTHOR	(of this document)
       Russell Biggs <rgb@ticnet.com>

COPYRIGHT
       All rights to this document are hereby relinquished to Graham Barr.

perl v5.16.3				    2013-06-07			   Net::LDAP::Examples(3)


All times are GMT -4. The time now is 10:44 AM.

Unix & Linux Forums Content Copyrightę1993-2018. All Rights Reserved.
×
UNIX.COM Login
Username:
Password:  
Show Password





Not a Forum Member?
Forgot Password?