use Win32::NetAdmin qw(GetUsers GroupIsMember FILTER_NORMAL_ACCOUNT);
use Win32API::Net;

my $noldapserver = 0;
my $ldap = Net::LDAP -> new($dc1) or $noldapserver=1;
if ( $noldapserver == 1 )  {
   $ldap = Net::LDAP -> new($dc2) or die "Error connecting to specified domain controllers $@ \n";
}
my $mesg = $ldap -> bind($user,
                                        password => $passwd
                                        );
$mesg = $ldap -> search( 
                                        base => $base,
                                        filter => "(&(objectclass=user)(samAccountname=*))"
                                        );
# Check for Error Code
if ( $mesg -> code ) {
        &LDAPerror( "Search", $mesg );
}
# Ergebnisanzahl auslesen
my $max = $mesg -> count;

# Ergebnisse durchgehen
for ( my $i = 0; $i < $max; $i++ ) {
        my $entry = $mesg -> entry ( $i );
        my $user = lc( $entry -> get_value( 'samAccountname' ) );
        my @groups = $entry -> get_value('memberOf');
        # weiterer code, u.a. Gruppenprüfung s.u.
}

foreach ( @groups ) {
        my $gruppe = $_;
        my @gnamen = split( /,/, $gruppe );
        if ( $gnamen[1] ne "OU=Gruppen"  ) { # es interessieren nur Gruppen unterhalb der OU Gruppen
                next();
        }
        my $grp = ( split( /=/, $gnamen[0] ) )[1];
        if ( $Freigaben{$grp} ) {
                # etwas tun
        }
}

#!/usr/bin/perl -T -w

use Net::LDAP;
use Net::LDAP::Control::Paged;
use Net::LDAP::Constant ( "LDAP_CONTROL_PAGED" );

$dc1="172.xx.xx.xx";
$dc2="172.xx.xx.xx";

$hqbase="dc=dom,dc=local";

$user="cn=USER,cn=Users,dc=dom,dc=local";
$passwd="PASSWORD";

# Connecting to Active Directory domain controllers
$noldapserver=0;
$ldap = Net::LDAP->new($dc1) or
   $noldapserver=1;
if ($noldapserver == 1)  {
   $ldap = Net::LDAP->new($dc2) or
      die "Error connecting to specified domain controllers $@ \n";
}

$mesg = $ldap->bind ( dn => $user,
                      password =>$passwd);
if ( $mesg->code()) {
    die ("error:", $mesg->error_text((),"\n"));
}

# How many LDAP query results to grab for each paged round
# Set to under 1000 for Active Directory
$page = Net::LDAP::Control::Paged->new( size => 990 );

@args = ( base     => $hqbase,
         filter => "(& (mailnickname=*) (| (&(objectCategory=person)
                    (objectClass=user)(!(homeMDB=*))(!(msExchHomeServerName=*)))
                    (&(objectCategory=person)(objectClass=user)(|(homeMDB=*)
                    (msExchHomeServerName=*)))(&(objectCategory=person))
                     ))",
          control  => [ $page ],
          attrs  => "proxyAddresses",
);

my $cookie;
while(1) {
  # Perform search
  my $mesg = $ldap->search( @args );

# Filtering results for proxyAddresses attributes  
  foreach my $entry ( $mesg->entries ) {
    my $name = $entry->get_value( "cn" );
    # LDAP Attributes are multi-valued, so we have to print each one.
    foreach my $mail ( $entry->get_value( "proxyAddresses" ) ) {
      if ( $mail =~ s/^(smtp|SMTP)://gs ) {
        if ( ! ( $mail =~ /SystemMailbox/i ) ) {
          print $mail . "\n"; 
        }
      }
    }
  }

  # Only continue on LDAP_SUCCESS
  $mesg->code and last;

  # Get cookie from paged control
  my($resp)  = $mesg->control( LDAP_CONTROL_PAGED ) or last;
  $cookie    = $resp->cookie or last;

  # Set cookie in paged control
  $page->cookie($cookie);
}

if ($cookie) {
  # We had an abnormal exit, so let the server know we do not want any more
  $page->cookie($cookie);
  $page->size(0);
  $ldap->search( @args );
  # Also would be a good idea to die unhappily and inform OP at this point
     die("LDAP query unsuccessful");
}

exit(0);

my @domainControllers = ( $dc1, $dc2 );
my $ldap = Net::LDAP->new( \@domainControllers, version => 3 );

search: attrs  => "proxyAddresses",

attrs => [ 'cn', 'proxyAddresses', ... ]

foreach my $entry ( $mesg->entries ) {

while( my $entry = $mesg->shift_entry ) {

package MyApp::LdapSearch;
use warnings; 
use strict;

sub search {
    my( $class, $ldapConnection, %args ) = @_;

    my $self = bless( {}, $class );

    my $pageSize = 200; # falls kein PageSize mitgegeben, verwende 200
    $pageSize = delete $args{pageSize} if exists $args{pageSize};

    $self->{page} = Net::LDAP::Control::Paged->new( size => $pageSize );
    $args{control}  = [ $page ];
    
    # speichere den kram zur spaeteren verwendung in getNextEntry
    $self->{ldapConnection} = $ldapConnection;
    $self->{searchArgs} = \%args;

    $self->{result} = $ldapConnection->search( %args );

    return $self;
}

sub getNextEntry {
    my( $self ) = @_;

    my $result = $self->{result};

    if( my $entry = $self->{result}->shift_entry ) {
        return $entry;
    }
    
    my( $resp )  = $result->control( LDAP_CONTROL_PAGED ) or return;
    my $cookie    = $resp->cookie or return;
    
    # Set cookie in paged control
    $self->{page}->cookie( $cookie );

    $self->{result} =  $self->{ldapConnection}->search( $self->{searchArgs} );
    if( my $entry = $self->{result}->shift_entry ) {
        return $entry;
    }
    return;
}

# und im Hauptprogramm dann sowas wie:

my $result = MyApp::LdapSearch->search(
    $ldap, 
    base  => $hqbase,
    filter => $filter,
    attrs  => \@attributes,
    scope  => 'sub',
);

while( my $entry = $result->getNextEntry ) {
    my $name = $entry->get_value( 'cn' );
    # ...
} # while

my $ldap = Net::LDAP->new( \@domainControllers, version => 3 );

while( my $entry = $mesg->shift_entry ) {