[ Index ]

PHP Cross Reference of Unnamed Project

title

Body

[close]

/se3-unattended/var/se3/unattended/install/linuxaux/opt/perl/lib/site_perl/5.10.0/Net/LDAP/ -> Search.pm (source)

   1  # Copyright (c) 1997-2004 Graham Barr <gbarr@pobox.com>. All rights reserved.
   2  # This program is free software; you can redistribute it and/or
   3  # modify it under the same terms as Perl itself.
   4  
   5  package Net::LDAP::Search;
   6  
   7  use strict;
   8  use vars qw(@ISA $VERSION);
   9  use Net::LDAP::Message;
  10  use Net::LDAP::Entry;
  11  use Net::LDAP::Intermediate;
  12  use Net::LDAP::Filter;
  13  use Net::LDAP::Constant qw(LDAP_SUCCESS LDAP_DECODING_ERROR);
  14  
  15  @ISA = qw(Net::LDAP::Message);
  16  $VERSION = "0.13";
  17  
  18  
  19  sub first_entry { # compat
  20    my $self = shift;
  21    $self->entry(0);
  22  }
  23  
  24  
  25  sub next_entry { # compat
  26    my $self = shift;
  27    $self->entry( defined $self->{'CurrentEntry'}
  28          ? $self->{'CurrentEntry'} + 1
  29          : 0);
  30  }
  31  
  32  
  33  sub decode {
  34    my $self = shift;
  35    my $result = shift;
  36  
  37    return $self->SUPER::decode($result)
  38      if exists $result->{protocolOp}{searchResDone};
  39    return $self->SUPER::decode($result)
  40      if exists $result->{protocolOp}{intermediateResponse};
  41  
  42    my $data;
  43    @{$self}{qw(controls ctrl_hash)} = ($result->{controls}, undef);
  44  
  45    if ($data = delete $result->{protocolOp}{searchResEntry}) {
  46  
  47      my $entry = Net::LDAP::Entry->new;
  48  
  49      $entry->decode($data, raw => $self->{raw})
  50        or $self->set_error(LDAP_DECODING_ERROR,"LDAP decode error")
  51       and return;
  52  
  53      push(@{$self->{entries} ||= []}, $entry);
  54  
  55      $self->{callback}->($self,$entry)
  56        if (defined $self->{callback});
  57  
  58      return $self;
  59    }
  60    elsif ($data = delete $result->{protocolOp}{searchResRef}) {
  61  
  62      push(@{$self->{'reference'} ||= []}, @$data);
  63  
  64      $self->{callback}->($self, bless $data, 'Net::LDAP::Reference')
  65        if (defined $self->{callback});
  66  
  67      return $self;
  68    }
  69  
  70    $self->set_error(LDAP_DECODING_ERROR, "LDAP decode error");
  71    return;
  72  }
  73  
  74  sub entry {
  75    my $self = shift;
  76    my $index = shift || 0; # avoid undef warning and default to first entry
  77  
  78    my $entries = $self->{entries} ||= [];
  79    my $ldap = $self->parent;
  80  
  81    # There could be multiple response to a search request
  82    # but only the last will set {resultCode}
  83    until (exists $self->{resultCode} || (@{$entries} > $index)) {
  84      return
  85        unless $ldap->_recvresp($self->mesg_id) == LDAP_SUCCESS;
  86    }
  87  
  88    return
  89      unless (@{$entries} > $index);
  90  
  91    $self->{current_entry} = $index; # compat
  92  
  93    return $entries->[$index];
  94  }
  95  
  96  sub all_entries { goto &entries } # compat
  97  
  98  sub count {
  99    my $self = shift;
 100    scalar entries($self);
 101  }
 102  
 103  sub shift_entry {
 104    my $self = shift;
 105  
 106    entry($self, 0) ? shift @{$self->{entries}} : undef;
 107  }
 108  
 109  sub pop_entry {
 110    my $self = shift;
 111  
 112    entry($self, 0) ? pop @{$self->{entries}} : undef;
 113  }
 114  
 115  sub sorted {
 116    my $self = shift;
 117  
 118    $self->sync unless exists $self->{resultCode};
 119  
 120    return unless exists $self->{entries} && ref($self->{entries});
 121  
 122    return @{$self->{entries}} unless @{$self->{entries}} > 1;
 123  
 124    require Net::LDAP::Util;
 125  
 126    map { $_->[0] }
 127      sort {
 128        my $v;
 129        my $i = 2;
 130        foreach my $attr (@_) {
 131      $v = ($a->[$i] ||= join("\000", @{$a->[0]->get_value($attr, asref => 1) || []}))
 132            cmp
 133           ($b->[$i] ||= join("\000", @{$b->[0]->get_value($attr, asref => 1) || []}))
 134        and last;
 135      $i++;
 136        }
 137  
 138        $v ||= ($a->[1] ||= Net::LDAP::Util::canonical_dn( $a->[0]->dn, "reverse" => 1, separator => "\0"))
 139          cmp
 140           ($b->[1] ||= Net::LDAP::Util::canonical_dn( $b->[0]->dn, "reverse" => 1, separator => "\0"));
 141      }
 142      map { [ $_ ] } @{$self->{entries}};
 143  }
 144  
 145  sub references {
 146    my $self = shift;
 147  
 148    $self->sync unless exists $self->{resultCode};
 149  
 150    return unless exists $self->{'reference'} && ref($self->{'reference'});
 151  
 152    @{$self->{'reference'} || []}
 153  }
 154  
 155  sub as_struct {
 156    my $self = shift;
 157    my %result = map { ( $_->dn, ($_->{'attrs'} || $_->_build_attrs) ) } entries($self);
 158    return \%result;
 159  }
 160  
 161  sub entries {
 162    my $self = shift;
 163  
 164    $self->sync unless exists $self->{resultCode};
 165  
 166    @{$self->{entries} || []}
 167  }
 168  
 169  package Net::LDAP::Reference;
 170  
 171  sub references {
 172    my $self = shift;
 173  
 174    @{$self}
 175  }
 176  
 177  
 178  1;


Generated: Tue Mar 17 22:47:18 2015 Cross-referenced by PHPXref 0.7.1