cloud-mu 3.6.10 → 3.6.12

data/cookbooks/mu-master/files/default/389ds-perl/FileConn.pm

@@ -0,0 +1,461 @@
+# BEGIN COPYRIGHT BLOCK
+# Copyright (C) 2007 Red Hat, Inc.
+# All rights reserved.
+#
+# License: GPL (version 3 or any later version).
+# See LICENSE for details. 
+# END COPYRIGHT BLOCK
+#
+# FileConn is a subclass of Mozilla::LDAP::Conn.  This class does
+# not use LDAP.  Instead, it operates on a given LDAP file, allowing
+# you to search, add, modify, and delete entries in the file.
+#
+package FileConn;
+
+use Mozilla::LDAP::Conn;
+use Mozilla::LDAP::API qw(:constant ldap_explode_dn ldap_err2string); # Direct access to C API
+use Mozilla::LDAP::Utils qw(normalizeDN);
+use Mozilla::LDAP::LDIF;
+
+use DSUtil qw(debug);
+
+require    Exporter;
+@ISA       = qw(Exporter Mozilla::LDAP::Conn);
+@EXPORT    = qw();
+@EXPORT_OK = qw();
+
+sub new {
+    my $class = shift;
+    my $filename = shift;
+    my $readonly = shift;
+    my @namingContexts = @_;
+    my $self = {};
+
+    $self = bless $self, $class;
+
+    $self->{readonly} = $readonly;
+    for my $ctx (@namingContexts) {
+        $self->setNamingContext($ctx);
+    }
+    $self->setNamingContext(""); # root DSE
+    if (!$self->read($filename)) {
+        return;
+    }
+
+    return $self;
+}
+
+sub getParentDN {
+    my $dn = shift;
+    my @rdns = ldap_explode_dn($dn, 0);
+    shift @rdns;
+    return join(',', @rdns);
+}
+
+sub read {
+    my $self = shift;
+    my $filename = shift;
+
+    if ($filename) {
+        $self->{filename} = $filename;
+    } else {
+        $filename = $self->{filename};
+    }
+
+    if (!$self->{filename}) {
+        return 1; # no filename given - ok
+    }
+
+    if (!open( MYLDIF, "$filename" )) {
+        debug(1, "Could not open $filename: $!\n");
+        return 0;
+    }
+
+    my $in = new Mozilla::LDAP::LDIF(*MYLDIF);
+    $self->{reading} = 1;
+    while ($ent = readOneEntry $in) {
+        if (!$self->add($ent)) {
+            debug(1, "Error: could not add entry " . $ent->getDN() . ":" . $self->getErrorString());
+        }
+    }
+    delete $self->{reading};
+    close( MYLDIF );
+
+    return 1;
+}
+
+sub setNamingContext {
+    my $self = shift;
+    my $nc = shift;
+    my $ndn = normalizeDN($nc);
+    $self->{namingContexts}->{$ndn} = $ndn;
+}
+
+sub isNamingContext {
+    my $self = shift;
+    my $ndn = shift;
+    return exists($self->{namingContexts}->{$ndn});
+}
+
+# return all nodes below the given node
+sub iterate {
+    my $self = shift;
+    my $dn = shift;
+    my $scope = shift;
+    my $callback = shift;
+    my $context = shift;
+    my $suppress = shift;
+    my $ndn = normalizeDN($dn);
+    my $children;
+    if (exists($self->{$ndn}) and exists($self->{$ndn}->{children})) {
+        $children = $self->{$ndn}->{children};
+    }
+    if (($scope != LDAP_SCOPE_ONELEVEL) && exists($self->{$ndn}) &&
+        exists($self->{$ndn}->{data}) && $self->{$ndn}->{data} && !$suppress) {
+        &{$callback}($self->{$ndn}->{data}, $context);
+    }
+
+    if ($scope == LDAP_SCOPE_BASE) {
+        return;
+    }
+
+    for my $node (@{$children}) {
+        &{$callback}($node->{data}, $context);
+    }
+    if ($scope == LDAP_SCOPE_SUBTREE) {
+        for my $node (@{$children}) {
+            $self->iterate($node->{data}->getDN(), $scope, $callback, $context, 1);
+        }
+    }
+}
+
+sub writecb {
+    my $entry = shift;
+    my $fh = shift;
+    if (! $entry->getDN()) { # rootDSE requires special hack around perldap bug
+        my $ary = $entry->getLDIFrecords();
+        shift @$ary; # remove "dn"
+        shift @$ary; # remove the empty dn value
+        print $fh "dn:\n";
+        print $fh (Mozilla::LDAP::LDIF::pack_LDIF (78, $ary), "\n");
+    } else {
+        Mozilla::LDAP::LDIF::put_LDIF($fh, 78, $entry);
+    }
+}
+
+sub write {
+    my $self = shift;
+    my $filename = shift;
+
+    if ($filename) {
+        $self->{filename} = $filename;
+    } else {
+        $filename = $self->{filename};
+    }
+
+    if (!$self->{filename} or $self->{readonly} or $self->{reading}) {
+        return 1; # ok - no filename given - just ignore
+    }
+
+    if (!open( MYLDIF, ">$filename" )) {
+        debug(1, "Can't write $filename: $!\n");
+        return 0;
+    }
+
+    $self->iterate("", LDAP_SCOPE_SUBTREE, \&writecb, \*MYLDIF);
+    for my $ctx (keys %{$self->{namingContexts}}) {
+        next if (!$ctx); # skip "" - we already did that
+        $self->iterate($ctx, LDAP_SCOPE_SUBTREE, \&writecb, \*MYLDIF);
+    }
+    close( MYLDIF );
+
+    return 1;
+}
+
+sub setErrorCode {
+    my $self = shift;
+    $self->{lastErrorCode} = shift;
+}
+
+sub getErrorCode {
+    my $self = shift;
+    return $self->{lastErrorCode};
+}
+
+sub getErrorString {
+    my $self = shift;
+    return ldap_err2string($self->{lastErrorCode});
+}
+
+#############################################################################
+# Print the last error code...
+#
+sub printError
+{
+  my ($self, $str) = @_;
+
+  $str = "LDAP error:" unless defined($str);
+  print "$str ", $self->getErrorString(), "\n";
+}
+
+sub DESTROY {
+    my $self = shift;
+    $self->close();
+}
+
+sub close {
+    my $self = shift;
+    return if ($self->{readonly});
+    $self->write();
+}
+
+sub printcb {
+    my $entry = shift;
+
+    print $entry->getDN(), "\n";
+}
+
+sub print {
+    my $self = shift;
+    my $dn = shift;
+    my $scope = shift;
+    $self->iterate($dn, $scope, \&printcb);
+}
+
+# for each entry, call the user provided filter callback
+# with the entry and the user provided filter context
+# if the filtercb returns true, add the entry to the
+# list of entries to return
+sub searchcb {
+    my $entry = shift;
+    my $context = shift;
+    my $self = $context->[0];
+    my $filtercb = $context->[1];
+    my $filtercontext = $context->[2];
+    if (&{$filtercb}($entry, $filtercontext)) {
+        push @{$self->{entries}}, $entry;
+    }
+}
+
+sub matchall {
+    return 1;
+}
+
+sub matchAttrVal {
+    my $entry = shift;
+    my $context = shift;
+    my $attr = $context->[0];
+    my $val = $context->[1];
+
+    if ($val eq "*") {
+        return $entry->exists($attr);
+    }
+    return $entry->hasValue($attr, $val, 1);
+}   
+
+my $attrpat  = '[-;.:\w]*[-;\w]';
+
+# given a string filter, figure out which subroutine to 
+# use to match
+sub filterToMatchSub {
+    my $self = shift;
+    my ($basedn, $scope, $filter, $attrsonly, @rest) = @_;
+    my ($matchsub, $context);
+# do some filter processing
+    if (!$filter or ($filter eq "(objectclass=*)") or
+        ($filter eq "objectclass=*")) {
+        $matchsub = \&matchall;
+    } elsif ($filter =~ /^\(($attrpat)=(.+)\)$/o) {
+        push @{$context}, $1, $2;
+        $matchsub = \&matchAttrVal;
+#     } elsif ($filter =~ /^\(\|\(($attrpat)=(.+)\)\(($attrpat)=(.+)\)\)$/o) {
+#         $attr = $1;
+#         $val = $2;
+#         $attr1 = $1;
+#         $val1 = $2;
+#         $isand = 0;
+#     } elsif ($filter =~ /^\(\&\(($attrpat)=(.+)\)\(($attrpat)=(.+)\)\)$/o) {
+#         $attr = $1;
+#         $val = $2;
+#         $attr1 = $1;
+#         $val1 = $2;
+#         $isand = 1;
+#     } elsif ($filter =~ /^\(\|\(($attrpat)=(.+)\)\(($attrpat)=(.+)\)\)$/o) {) {
+# # 						   "(&(objectclass=nsBackendInstance)(|(nsslapd-suffix=$suffix)(nsslapd-suffix=$nsuffix)))");
+    }
+
+    $self->iterate($basedn, $scope, \&searchcb, [$self, $matchsub, $context]);
+}
+
+# simple searches only
+sub search {
+    my $self = shift;
+    my ($basedn, $scope, $filter, $attrsonly, @rest) = @_;
+    my $attrs;
+    if (ref($rest[0]) eq "ARRAY") {
+        $attrs = $rest[0];
+    } elsif (scalar(@rest) > 0) {
+        $attrs = \@rest;
+    }
+
+    $scope = Mozilla::LDAP::Utils::str2Scope($scope);
+
+    $self->{entries} = [];
+
+    my $ndn = normalizeDN($basedn);
+    if (!exists($self->{$ndn}) or !exists($self->{$ndn}->{data})) {
+        $self->setErrorCode(LDAP_NO_SUCH_OBJECT);
+        return undef;
+    }
+
+    $self->setErrorCode(0);
+    if (ref($filter) eq 'CODE') {
+        $self->iterate($basedn, $scope, \&searchcb, [$self, $filter, $attrsonly]);
+    } else {
+        $self->filterToMatchSub($basedn, $scope, $filter, $attrsonly);
+    }
+
+    return $self->nextEntry();
+}
+
+sub cloneEntry {
+    my $src = shift;
+    if (!$src) {
+        return undef;
+    }
+    my $dest = new Mozilla::LDAP::Entry();
+    $dest->setDN($src->getDN());
+    for my $key (keys %{$src}) {
+        if (ref($src->{$key})) {
+            my @copyary = @{$src->{$key}};
+            $dest->{$key} = [ @copyary ]; # make a deep copy
+        } else {
+            $dest->{$key} = $src->{$key};
+        }
+    }
+
+    return $dest;
+}
+
+# have to return a copy of the entry - disallow inplace updates
+sub nextEntry {
+    my $self = shift;
+    my $ent = shift @{$self->{entries}};
+    return cloneEntry($ent);
+}
+
+sub add {
+    my $self = shift;
+    my $entry = shift;
+    my $dn = $entry->getDN();
+    my $ndn = normalizeDN($dn);
+    my $parentdn = getParentDN($dn);
+    my $nparentdn = normalizeDN($parentdn);
+
+    $self->setErrorCode(0);
+    # special case of naming context - has no parent
+    if ($self->isNamingContext($ndn) and
+        !exists($self->{$ndn}->{data})) {
+        $self->{$ndn}->{data} = $entry;
+        return $self->write();
+    }
+
+    if ($ndn && exists($self->{$ndn})) {
+        $self->setErrorCode(LDAP_ALREADY_EXISTS);
+        return 0;
+    }
+
+    if ($ndn && $nparentdn && !exists($self->{$nparentdn})) {
+        $self->setErrorCode(LDAP_NO_SUCH_OBJECT);
+        return 0;
+    }
+    # each hash entry has two keys
+    # data is the actual Entry
+    # children is the array ref of the one level children of this dn
+    $self->{$ndn}->{data} = $entry;
+    # don't add parent to list of children
+    if ($nparentdn ne $ndn) {
+        push @{$self->{$nparentdn}->{children}}, $self->{$ndn};
+    }
+
+    return 1;
+}
+
+sub update {
+    my $self = shift;
+    my $entry = shift;
+    my $dn = $entry->getDN();
+    my $ndn = normalizeDN($dn);
+
+    if ($self->{readonly}) {
+        debug(1, "Attempt to update read only $self->{filename} entry $dn\n");
+        return 0;
+    }
+
+    $self->setErrorCode(0);
+    if (!exists($self->{$ndn})) {
+        $self->setErrorCode(LDAP_NO_SUCH_OBJECT);
+        debug(1, "Attempt to update entry $dn that does not exist\n");
+        return 0;
+    }
+
+    # The cloned entry will not contain the deleted attrs - the cloning
+    # process omits the deleted attrs via the Entry FETCH, FIRSTKEY, and NEXTKEY
+    # methods
+    $self->{$ndn}->{data} = cloneEntry($entry);
+    return $self->write();
+}
+
+sub delete {
+    my $self = shift;
+    my $dn = shift;
+
+    if ($self->{readonly}) {
+        debug(1, "Attempt to delete read only $self->{filename} entry $dn\n");
+        return 0;
+    }
+
+    if (ref($dn)) {
+        $dn = $dn->getDN(); # an Entry
+    }
+    my $ndn = normalizeDN($dn);
+
+    $self->setErrorCode(0);
+    if (!exists($self->{$ndn})) {
+        $self->setErrorCode(LDAP_NO_SUCH_OBJECT);
+        debug(1, "Attempt to delete entry $dn that does not exist\n");
+        return 0;
+    }
+
+    if (@{$self->{$ndn}->{children}}) {
+        $self->setErrorCode(LDAP_NOT_ALLOWED_ON_NONLEAF);
+        debug(1, "Attempt to delete entry $dn that has children\n");
+        return 0;
+    }
+
+    # delete the data associated with this node
+    delete $self->{$ndn}->{data};
+    delete $self->{$ndn}->{children};
+
+    my $parentdn = getParentDN($dn);
+    my $nparentdn = normalizeDN($parentdn);
+    # delete this node from its parent
+    if ($ndn ne $nparentdn) {
+        for (my $ii = 0; $ii < @{$self->{$nparentdn}->{children}}; ++$ii) {
+            # find matching hash ref in parent's child list
+            if ($self->{$nparentdn}->{children}->[$ii] eq $self->{$ndn}) {
+                # remove that element from the array
+                splice @{$self->{$nparentdn}->{children}}, $ii, 1;
+                # done - should only ever be one matching child
+                last;
+            }
+        }
+    }
+
+    # delete this node
+    delete $self->{$ndn};
+
+    return $self->write();
+}
+
+1;

data/cookbooks/mu-master/files/default/389ds-perl/Inf.pm

@@ -0,0 +1,268 @@
+# BEGIN COPYRIGHT BLOCK
+# Copyright (C) 2007 Red Hat, Inc.
+# All rights reserved.
+#
+# License: GPL (version 3 or any later version).
+# See LICENSE for details. 
+# END COPYRIGHT BLOCK
+#
+
+# manages inf files - gets values
+# given keys
+
+package Inf;
+
+use DSUtil;
+use File::Temp qw(tempfile tempdir);
+
+#require    Exporter;
+#@ISA       = qw(Exporter);
+#@EXPORT    = qw();
+
+sub new {
+    my $type = shift;
+    my $self = {};
+
+    $self->{filename} = shift;
+    $self->{writable} = shift; # do not overwrite user supplied file
+    # if you want to init an Inf with a writable file, use
+    # $inf = new Inf($filename, 1)
+
+    $self = bless $self, $type;
+
+    if ($self->{filename}) {
+        if($self->read() != 0){
+            undef $self;
+        }
+    }
+
+    return $self;
+}
+
+sub read {
+# each key in the table is a section name
+# the value is a hash ref of the items in that section
+#   in that hash ref, each key is the config param name,
+#   and the value is the config param value
+    my $self = shift;
+    my $filename = shift;
+    my $curSection = "";
+
+    if ($filename) {
+        $self->{filename} = $filename;
+    } else {
+        $filename = $self->{filename};
+    }
+
+    my $incontinuation = 0;
+    my $curkey;
+    my $curval;
+    my $inffh;
+    if ($filename eq "-") {
+        $inffh = \*STDIN;
+    } else {
+        if (!open(INF, $filename)) {
+            debug(0, "Error: could not open inf file $filename: $!\n");
+            return -1;
+        }
+        $inffh = \*INF;
+    }
+    my $line;
+    while ($line = <$inffh>) {
+        my $iscontinuation;
+        chop $line; # trim trailing newline
+        if ($line =~ /^\s*$/) { # skip blank/empty lines
+            $incontinuation = 0;
+            next;
+        }
+        if ($line =~ /^\s*\#/) { # skip comment lines
+            $incontinuation = 0;
+            next;
+        }
+        if ($line =~ /\\$/) { # line ends in \ - continued on next line
+            chop $line;
+            $iscontinuation = 1;
+        }
+        if ($incontinuation) {
+            if ($curval) {
+                $self->{$curSection}->{$curkey}->[$curval] .= "\n" . $line; # add line in entirety to current value
+            } else {
+                $self->{$curSection}->{$curkey} .= "\n" . $line; # add line in entirety to current value
+            }
+        } elsif ($line =~ /^\[(.*?)\]/) { # e.g. [General]
+            $curSection = $1;
+            $iscontinuation = 0; # disallow section continuations
+        } elsif ($line =~ /^\s*(.*?)\s*=\s*(.*?)\s*$/) { # key = value
+            $curkey = $1;
+            # a single value is just a single scalar
+            # multiple values are represented by an array ref
+            if (exists($self->{$curSection}->{$curkey})) {
+                if (!ref($self->{$curSection}->{$curkey})) {
+                    # convert single scalar to array ref
+                    my $ary = [$self->{$curSection}->{$curkey}];
+                    $self->{$curSection}->{$curkey} = $ary;
+                }
+                # just push the new value
+                push @{$self->{$curSection}->{$curkey}}, $2;
+                $curval = @{$self->{$curSection}->{$curkey}} - 1; # curval is index of last item
+            } else {
+                # single value
+                $self->{$curSection}->{$curkey} = $2;
+                $curval = 0; # only 1 value
+            }
+        }
+        if ($iscontinuation) { # if line ends with a backslash, continue the data on the next line
+            $incontinuation = 1;
+        } else {
+            $incontinuation = 0;
+        }
+	}
+    if ($inffh ne \*STDIN) {
+        close $inffh;
+    }
+
+    return 0;
+}
+
+sub section {
+    my $self = shift;
+    my $key = shift;
+
+    if (!exists($self->{$key})) {
+        debug(0, "Error: unknown inf section $key\n");
+        return undef;
+    }
+
+    return $self->{$key};
+}
+
+sub writeSection {
+    my $self = shift;
+    my $name = shift;
+    my $fh = shift;
+    my $section = $self->{$name};
+    if (ref($section) eq 'HASH') {
+        print $fh "[$name]\n";
+        for my $key (sort keys %{$section}) {
+            if (exists($section->{$key}) and defined($section->{$key}) and
+                (length($section->{$key}) > 0)) {
+                my @vals = ();
+                if (ref($section->{$key})) {
+                    @vals = @{$section->{$key}};
+                } else {
+                    @vals = ($section->{$key});
+                }
+                for my $val (@vals) {
+                    $val =~ s/\n/\\\n/g; # make continuation lines
+                    print $fh "$key = $val\n";
+                }
+            }
+        }
+    }
+}
+
+sub write {
+    my $self = shift;
+    my $filename = shift;
+    my $fh;
+
+    return if ($filename and $filename eq "-");
+
+    # see if user wants to force use of a temp file
+    if ($filename and $filename eq '__temp__') {
+        $self->{writable} = 1;
+        $filename = '';
+        delete $self->{filename};
+    }
+
+    if (!$self->{writable}) {
+        return; # do not overwrite read only file
+    }
+
+    if ($filename) { # use user supplied filename
+        $self->{filename} = $filename;
+    } elsif ($self->{filename}) { # use existing filename
+        $filename = $self->{filename};
+    } else { # create temp filename
+        ($fh, $self->{filename}) = tempfile("setupXXXXXX", UNLINK => 0,
+                                            SUFFIX => ".inf", OPEN => 1,
+                                            DIR => File::Spec->tmpdir);
+    }
+
+    my $savemask = umask(0077);
+    if (!$fh) {
+        if (!open(INF, ">$filename")) {
+            debug(0, "Error: could not write inf file $filename: $!\n");
+            umask($savemask);
+            return;
+        }
+        $fh = *INF;
+    }
+    # write General section first
+    $self->writeSection('General', $fh);
+    for my $key (keys %{$self}) {
+        next if ($key eq 'General');
+        $self->writeSection($key, $fh);
+    }
+    close $fh;
+    umask($savemask);
+}
+
+sub updateFromArgs {
+    my $self = shift;
+    my $argsinf = {}; # tmp for args read in
+
+    if (!@_) {
+        return 1; # no args - just return
+    }
+
+    # read args into temp inf
+    for my $arg (@_) {
+        if ($arg =~ /^([\w_-]+)\.([\w_-]+)=(.*)$/) { # e.g. section.param=value
+            my $sec = $1;
+            my $parm = $2;
+            my $val = $3;
+            # a single value is just a single scalar
+            # multiple values are represented by an array ref
+            if (exists($argsinf->{$sec}->{$parm})) {
+                if (!ref($argsinf->{$sec}->{$parm})) {
+                    # convert single scalar to array ref
+                    my $ary = [$argsinf->{$sec}->{$parm}];
+                    $argsinf->{$sec}->{$parm} = $ary;
+                }
+                # just push the new value
+                push @{$argsinf->{$sec}->{$parm}}, $val;
+            } else {
+                # single value
+                $argsinf->{$sec}->{$parm} = $val;
+            }
+        } else { # error
+            debug(0, "Error: unknown command line option $arg\n");
+            return;
+        }
+    }
+
+    # no args read - just return true
+    if (!$argsinf || !%{$argsinf}) {
+        return 1;
+    }
+
+    # override inf with vals read from args
+    while (my ($name, $sec) = each %{$argsinf}) {
+        if (ref($sec) eq 'HASH') {
+            for my $key (keys %{$sec}) {
+                if (defined($sec->{$key})) {
+                    my $val = $sec->{$key};
+                    $self->{$name}->{$key} = $val;
+                }
+            }
+        }
+    }
+
+    return 1;
+}
+
+#############################################################################
+# Mandatory TRUE return value.
+#
+1;