Metacat

#!/usr/bin/perl -w

 #

 #  '$RCSfile$'

 #  Copyright: 2001 Regents of the University of California 

 #

 #   '$Author: tao $'

 #     '$Date: 2007-02-11 17:22:05 -0800 (Sun, 11 Feb 2007) $'

 # '$Revision: 3177 $' 

 # 

 # This program is free software; you can redistribute it and/or modify

 # it under the terms of the GNU General Public License as published by

 # the Free Software Foundation; either version 2 of the License, or

 # (at your option) any later version.

 #

 # This program is distributed in the hope that it will be useful,

 # but WITHOUT ANY WARRANTY; without even the implied warranty of

 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 # GNU General Public License for more details.

 #

 # You should have received a copy of the GNU General Public License

 # along with this program; if not, write to the Free Software

 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 #

#

# This is a web-based application for allowing users to register a new

# account for Metacat access.  We currently only support LDAP even

# though metacat could potentially support other types of directories.

#

use strict;       # turn on strict syntax checking.

use Template;     # load the template-toolkit module.

use CGI;          # load the CGI module. 

use Net::LDAP;    # load the LDAP net libraries

use Net::SMTP;    # load the SMTP net libraries

use Digest::SHA1; # for creating the password hash

use MIME::Base64; # for creating the password hash

use URI;          # for parsing URL syntax

use AppConfig qw(:expand :argcount);

# Set up our default configuration

my $ldapurl = "@ldapurl@";

my $mainldapurl = "@ldapurl@";

my $root = "@user@";

my $rootpw = "@password@";

my $searchBase = "@ldapSearchBase@";

my $templatesDir = "@templates.dir@";

my $mailhost = "@mailhost@";

my $sender = "@sender@";

my $TIMEOUT = 20;

my $mainldapdownmessage = "The main ldap server " . $mainldapurl . " is down!";

# Get the CGI input variables

my $query = new CGI;

my $debug = 0;

#--------------------------------------------------------------------------80c->

# Set up the Template Toolkit to read html form templates

# set some configuration options for the template object

my $config_templates = {

             INCLUDE_PATH => $templatesDir, 

             INTERPOLATE  => 0,                    

             POST_CHOMP   => 1,                   

             };

# create an instance of the template

my $template = Template->new($config_templates) || handleGeneralServerFailure($Template::ERROR);

# Read the ldapweb.cfg file

my $config = AppConfig->new({ 

    GLOBAL => { ARGCOUNT => ARGCOUNT_ONE, } });

$config->define("ldapurl", { ARGCOUNT => ARGCOUNT_HASH} );           

$config->define("ldapsearchbase", { ARGCOUNT => ARGCOUNT_HASH} );

$config->define("dn", { ARGCOUNT => ARGCOUNT_HASH} );

$config->define("filter", { ARGCOUNT => ARGCOUNT_HASH} );

$config->define("user", { ARGCOUNT => ARGCOUNT_HASH} );

$config->define("password", { ARGCOUNT => ARGCOUNT_HASH} );

my $cfgfile = "ldapweb.cfg";

$config->file($cfgfile);

my $config_ldapurl = $config->get('ldapurl');

my $config_ldapsearchbase = $config->get('ldapsearchbase');

my $config_dn = $config->get('dn');

my $config_filter = $config->get('filter');

my $config_user = $config->get('user');

my $config_password = $config->get('password');

my @orglist;

foreach my $neworg (keys %$config_dn) {

    push(@orglist, $neworg);

    debug($neworg);

}

#--------------------------------------------------------------------------80c->

# Define the main program logic that calls subroutines to do the work

#--------------------------------------------------------------------------80c->

# The processing step we are handling

my $stage = $query->param('stage') || '@defaultStage@';

my $cfg = $query->param('cfg');

# define the possible stages

my %stages = (

              'initregister'      => \&handleInitRegister,

              'register'          => \&handleRegister,

              'registerconfirmed' => \&handleRegisterConfirmed,

              'simplesearch'      => \&handleSimpleSearch,

              'initaddentry'      => \&handleInitAddEntry,

              'addentry'          => \&handleAddEntry,

              'initmodifyentry'   => \&handleInitModifyEntry,

              'modifyentry'       => \&handleModifyEntry,

              'changepass'        => \&handleChangePassword,

              'initchangepass'    => \&handleInitialChangePassword,

              'resetpass'         => \&handleResetPassword,

              'initresetpass'     => \&handleInitialResetPassword,

             );

# call the appropriate routine based on the stage

if ( $stages{$stage} ) {

  $stages{$stage}->();

} else {

  &handleResponseMessage();

}

#--------------------------------------------------------------------------80c->

# Define the subroutines to do the work

#--------------------------------------------------------------------------80c->

#

# create the initial registration form 

#

sub handleInitRegister {

  my $vars = shift;

  print "Content-type: text/html\n\n";

  # process the template files:

  my $templateVars = { stage => "register", cfg => $cfg };

  #$$templateVars{'orgList'} = \@orglist;

  $$templateVars{'orgList'} = \@orglist;

  $template->process( "@defaultHeader@", $templateVars);

  $template->process( "@register@", $templateVars);

  $template->process( "@defaultFooter@", $templateVars);

  exit();

}

#

# process input from the register stage, which occurs when

# a user submits form data to create a new account

#

sub handleRegister {

    print "Content-type: text/html\n\n";

    my $allParams = { 'givenName' => $query->param('givenName'), 

                      'sn' => $query->param('sn'),

                      'o' => $query->param('o'), 

                      'mail' => $query->param('mail'), 

                      'uid' => $query->param('uid'), 

                      'userPassword' => $query->param('userPassword'), 

                      'userPassword2' => $query->param('userPassword2'), 

                      'title' => $query->param('title'), 

                      'telephoneNumber' => $query->param('telephoneNumber') };

    # Check that all required fields are provided and not null

    my @requiredParams = ( 'givenName', 'sn', 'o', 'mail', 

                           'uid', 'userPassword', 'userPassword2');

    if (! paramsAreValid(@requiredParams)) {

        my $errorMessage = "Required information is missing. " .

            "Please fill in all required fields and resubmit the form.";

        my $templateVars = { stage => "register",

                             cfg => $cfg,

                             allParams => $allParams,

                             errorMessage => $errorMessage };

        $$templateVars{'orgList'} = \@orglist;

        $template->process( "@defaultHeader@", $templateVars);

        $template->process( "@register@", $templateVars);

        $template->process( "@defaultFooter@", $templateVars);

        exit(0);

    } else {

        my $o = $query->param('o');    

        $ldapurl = $config_ldapurl->{$o};

        $searchBase = $config_ldapsearchbase->{$o};  

    }

    # Search LDAP for matching entries that already exist

    # Some forms use a single text search box, whereas others search per

    # attribute.

    my $filter;

    if ($query->param('searchField')) {

      $filter = "(|" . 

                "(uid=" . $query->param('searchField') . ") " .

                "(mail=" . $query->param('searchField') . ")" .

                "(&(sn=" . $query->param('searchField') . ") " . 

                "(givenName=" . $query->param('searchField') . "))" . 

                ")";

    } else {

      $filter = "(|" . 

                "(uid=" . $query->param('uid') . ") " .

                "(mail=" . $query->param('mail') . ")" .

                "(&(sn=" . $query->param('sn') . ") " . 

                "(givenName=" . $query->param('givenName') . "))" . 

                ")";

    }

    my @attrs = [ 'uid', 'o', 'cn', 'mail', 'telephoneNumber', 'title' ];

    my $found = findExistingAccounts($ldapurl, $searchBase, $filter, \@attrs);

    # If entries match, send back a request to confirm new-user creation

    if ($found) {

      my $templateVars = { stage => "registerconfirmed",

                           cfg => $cfg,

                           allParams => $allParams,

                           foundAccounts => $found };

      $$templateVars{'orgList'} = \@orglist;

      $template->process( "@defaultHeader@", $templateVars);

      $template->process( "@registerMatch@", $templateVars);

      $template->process( "@register@", $templateVars);

      $template->process( "@defaultFooter@", $templateVars);

    # Otherwise, create a new user in the LDAP directory

    } else {

        #print("ingore create account\n");

        createAccount($allParams);

    }

    exit();

}

#

# process input from the registerconfirmed stage, which occurs when

# a user chooses to create an account despite similarities to other

# existing accounts

#

sub handleRegisterConfirmed {

    my $allParams = { 'givenName' => $query->param('givenName'), 

                      'sn' => $query->param('sn'),

                      #'o' => $query->param('o'), 

                      'o' => 'unaffiliated', 

                      'mail' => $query->param('mail'), 

                      'uid' => $query->param('uid'), 

                      'userPassword' => $query->param('userPassword'), 

                      'userPassword2' => $query->param('userPassword2'), 

                      'title' => $query->param('title'), 

                      'telephoneNumber' => $query->param('telephoneNumber') };

    print "Content-type: text/html\n\n";

    createAccount($allParams);

    exit();

}

#

# change a user's password upon request

#

sub handleChangePassword {

    print "Content-type: text/html\n\n";

    my $allParams = { 'test' => "1", };

    if ($query->param('uid')) {

        $$allParams{'uid'} = $query->param('uid');

    }

    if ($query->param('o')) {

        $$allParams{'o'} = $query->param('o');

        my $o = $query->param('o');

        $ldapurl = $config_ldapurl->{$o};

        $searchBase = $config_ldapsearchbase->{$o};

    }

    # Check that all required fields are provided and not null

    my @requiredParams = ( 'uid', 'o', 'oldpass', 

                           'userPassword', 'userPassword2');

    if (! paramsAreValid(@requiredParams)) {

        my $errorMessage = "Required information is missing. " .

            "Please fill in all required fields and submit the form.";

        my $templateVars = { stage => "changepass",

                             cfg => $cfg,

                             allParams => $allParams,

                             errorMessage => $errorMessage };

        $$templateVars{'orgList'} = \@orglist;

        $template->process( "@defaultHeader@", $templateVars);

        $template->process( "@defaultChangePass@", $templateVars);

        $template->process( "@defaultFooter@", $templateVars);

        exit(0);

    }

    # We have all of the info we need, so try to change the password

    if ($query->param('userPassword') =~ $query->param('userPassword2')) {

        my $o = $query->param('o');

        $ldapurl = $config_ldapurl->{$o};

        $searchBase = $config_ldapsearchbase->{$o};

        $root = $config_user->{$o};

        $rootpw = $config_password->{$o};

        my $dn = "uid=" . $query->param('uid') . "," . $config_dn->{$o};;

        if ($query->param('o') =~ "LTER") {

            $template->process( "@defaultHeader@");

            $template->process( "@registerLter@");

            $template->process( "@defaultFooter@");

        } else {

            my $errorMessage = changePassword(

                    $dn, $query->param('userPassword'), 

                    $dn, $query->param('oldpass'), $query->param('o'));

            if ($errorMessage) {

                my $templateVars = { stage => "changepass",

                                     cfg => $cfg,

                                     allParams => $allParams,

                                     errorMessage => $errorMessage };

                $$templateVars{'orgList'} = \@orglist;

                $template->process( "@defaultHeader@", $templateVars);

                $template->process( "@defaultChangePass@", $templateVars);

                $template->process( "@defaultFooter@", $templateVars);

                exit(0);

            } else {

                my $templateVars = { stage => "changepass",

                                     cfg => $cfg,

                                     allParams => $allParams };

                $$templateVars{'orgList'} = \@orglist;

                $template->process( "@defaultHeader@", $templateVars);

                $template->process( "@changePassSuccess@", $templateVars);

                $template->process( "@defaultFooter@", $templateVars);

                exit(0);

            }

        }

    } else {

        my $errorMessage = "The passwords do not match. Try again.";

        my $templateVars = { stage => "changepass",

                             cfg => $cfg,

                             allParams => $allParams,

                             errorMessage => $errorMessage };

        $$templateVars{'orgList'} = \@orglist;

        $template->process( "@defaultHeader@", $templateVars);

        $template->process( "@defaultChangePass@", $templateVars);

        $template->process( "@defaultFooter@", $templateVars);

        exit(0);

    }

}

#

# change a user's password upon request - no input params

# only display chagepass template without any error

#

sub handleInitialChangePassword {

    print "Content-type: text/html\n\n";

    my $allParams = { 'test' => "1", };

    my $errorMessage = "";

    my $templateVars = { stage => "changepass",

                         cfg => $cfg,

                         allParams => $allParams,

                         errorMessage => $errorMessage };

    $$templateVars{'orgList'} = \@orglist;

    $template->process( "@defaultHeader@", $templateVars);

    $template->process( "@defaultChangePass@", $templateVars);

    $template->process( "@defaultFooter@", $templateVars);

    exit(0);

}

#

# reset a user's password upon request

#

sub handleResetPassword {

    print "Content-type: text/html\n\n";

    my $allParams = { 'test' => "1", };

    if ($query->param('uid')) {

        $$allParams{'uid'} = $query->param('uid');

    }

    if ($query->param('o')) {

        $$allParams{'o'} = $query->param('o');

        my $o = $query->param('o');

        $ldapurl = $config_ldapurl->{$o};

        $searchBase = $config_ldapsearchbase->{$o};

        $root = $config_user->{$o};

        $rootpw = $config_password->{$o};

    }

    # Check that all required fields are provided and not null

    my @requiredParams = ( 'uid', 'o' );

    if (! paramsAreValid(@requiredParams)) {

        my $errorMessage = "Required information is missing. " .

            "Please fill in all required fields and submit the form.";

        my $templateVars = { stage => "resetpass",

                             cfg => $cfg,

                             allParams => $allParams,

                             errorMessage => $errorMessage };

        $$templateVars{'orgList'} = \@orglist;

        $template->process( "@defaultHeader@", $templateVars);

        $template->process( "@defaultResetPass@", $templateVars);

        $template->process( "@defaultFooter@", $templateVars);

        exit(0);

    }

    # We have all of the info we need, so try to change the password

    my $o = $query->param('o');

    my $dn = "uid=" . $query->param('uid') . "," . $config_dn->{$o};

    if ($query->param('o') =~ "LTER") {

        $template->process( "@defaultHeader@");

        $template->process( "@registerLter@");

        $template->process( "@defaultFooter@");

        exit(0);

    } else {

        my $errorMessage = "";

        my $recipient;

        my $userPass;

        my $entry = getLdapEntry($ldapurl, $searchBase, 

                $query->param('uid'), $query->param('o'));

        if ($entry) {

            $recipient = $entry->get_value('mail');

            $userPass = getRandomPassword();

            $errorMessage = changePassword($dn, $userPass, $root, $rootpw, $query->param('o'));

        } else {

            $errorMessage = "User not found in database.  Please try again.";

        }

        if ($errorMessage) {

            my $templateVars = { stage => "resetpass",

                                 cfg => $cfg,

                                 allParams => $allParams,

                                 errorMessage => $errorMessage };

            $$templateVars{'orgList'} = \@orglist;

            $template->process( "@defaultHeader@", $templateVars);

            $template->process( "@defaultResetPass@", $templateVars);

            $template->process( "@defaultFooter@", $templateVars);

            exit(0);

        } else {

            my $errorMessage = sendPasswordNotification($query->param('uid'),

                    $query->param('o'), $userPass, $recipient, $cfg);

            my $templateVars = { stage => "resetpass",

                                 cfg => $cfg,

                                 allParams => $allParams,

                                 errorMessage => $errorMessage };

            $$templateVars{'orgList'} = \@orglist;

            $template->process( "@defaultHeader@", $templateVars);

            $template->process( "@resetPassSuccess@", $templateVars);

            $template->process( "@defaultFooter@", $templateVars);

            exit(0);

        }

    }

}

#

# reset a user's password upon request- no initial params

# only display resetpass template without any error

#

sub handleInitialResetPassword {

    print "Content-type: text/html\n\n";

    my $errorMessage = "";

    my $allParams = { 'test' => "1", };

    my $templateVars = { stage => "resetpass",

                         cfg => $cfg,

                         allParams => $allParams,

                         errorMessage => $errorMessage };

    $$templateVars{'orgList'} = \@orglist;

    $template->process( "@defaultHeader@", $templateVars);

    $template->process( "@defaultResetPass@", $templateVars);

    $template->process( "@defaultFooter@", $templateVars);

    exit(0);

}

#

# Construct a random string to use for a newly reset password

#

sub getRandomPassword {

    my $length = shift;

    if (!$length) {

        $length = 8;

    }

    my $newPass = "";

    my @chars = ( "A" .. "Z", "a" .. "z", 0 .. 9, qw(! @ $ ^) );

    $newPass = join("", @chars[ map { rand @chars } ( 1 .. $length ) ]);

    return $newPass;

}

#

# Change a password to a new value, binding as the provided user

#

sub changePassword {

    my $userDN = shift;

    my $userPass = shift;

    my $bindDN = shift;

    my $bindPass = shift;

    my $o = shift;

    my $ldapurl = $config_ldapurl->{$o};

    my $searchBase = $config_ldapsearchbase->{$o};

    my $errorMessage = 0;

    my $ldap;

    if ($ldapurl =~ $mainldapurl){

        #if main ldap server is down, a html file containing warning message will be returned

        $ldap = Net::LDAP->new($ldapurl, timeout => $TIMEOUT) or handleGeneralServerFailure($mainldapdownmessage);

    }

    else{

        #if a referral ldap server is down, we will ignore it silently

        $ldap = Net::LDAP->new($ldapurl, timeout => $TIMEOUT) or return;

    } 

    #$ldap->start_tls( verify => 'require',

                      #cafile => '/usr/share/ssl/ldapcerts/cacert.pem');

    $ldap->start_tls( verify => 'none');

    my $bindresult = $ldap->bind( version => 3, dn => $bindDN, 

                                  password => $bindPass );

    if ($bindresult->code) {

        $errorMessage = "Failed to log in. Are you sure your old " .

                        "password is correct? Try again...";

        return $errorMessage;

    }

    # Find the user here and change their entry

    my $newpass = createSeededPassHash($userPass);

    my $modifications = { userPassword => $newpass };

    my $result = $ldap->modify( $userDN, replace => { %$modifications });

    if ($result->code()) {

        my $errorMessage = "There was an error changing the password." .

                           "<br />\n" . $result->error;

    } 

    $ldap->unbind;   # take down session

    return $errorMessage;

}

#

# generate a Seeded SHA1 hash of a plaintext password

#

sub createSeededPassHash {

    my $secret = shift;

    my $salt = "";

    for (my $i=0; $i < 4; $i++) {

        $salt .= int(rand(10));

    }

    my $ctx = Digest::SHA1->new;

    $ctx->add($secret);

    $ctx->add($salt);

    my $hashedPasswd = '{SSHA}' . encode_base64($ctx->digest . $salt ,'');

    return $hashedPasswd;

}

#

# Look up an ldap entry for a user

#

sub getLdapEntry {

    my $ldapurl = shift;

    my $base = shift;

    my $username = shift;

    my $org = shift;

    my $entry = "";

    my $mesg;

    my $ldap;

    print("ldap server ", $ldapurl, "\n");

    if ($ldapurl =~ $mainldapurl){

        #if main ldap server is down, a html file containing warning message will be returned

        $ldap = Net::LDAP->new($ldapurl, timeout => $TIMEOUT) or handleGeneralServerFailure($mainldapdownmessage);

    }

    else{

        #if a referral ldap server is down, we will ignore it silently

        $ldap = Net::LDAP->new($ldapurl, timeout => $TIMEOUT) or return;

    }

    $ldap->start_tls( verify => 'none');

    my $bindresult = $ldap->bind;

    if ($bindresult->code) {

        return $entry;

    }

    if($config_filter->{$org}){

        $mesg = $ldap->search ( base   => $base,

                filter => "(&(uid=$username)($config_filter->{$org}))");

    } else {

        $mesg = $ldap->search ( base   => $base, filter => "(uid=$username)");

    }

    if ($mesg->count > 0) {

        $entry = $mesg->pop_entry;

        $ldap->unbind;   # take down session

    } else {

        $ldap->unbind;   # take down session

        # Follow references by recursive call to self

        my @references = $mesg->references();

        for (my $i = 0; $i <= $#references; $i++) {

            my $uri = URI->new($references[$i]);

            my $host = $uri->host();

            my $path = $uri->path();

            $path =~ s/^\///;

            $entry = &getLdapEntry($host, $path, $username, $org);

            if ($entry) {

                return $entry;

            }

        }

    }

    return $entry;

}

# 

# send an email message notifying the user of the pw change

#

sub sendPasswordNotification {

    my $username = shift;

    my $org = shift;

    my $newPass = shift;

    my $recipient = shift;

    my $cfg = shift;

    my $errorMessage = "";

    if ($recipient) {

        # Send the email message to them

        my $smtp = Net::SMTP->new($mailhost);

        $smtp->mail($sender);

        $smtp->to($recipient);

        my $message = <<"        ENDOFMESSAGE";

        To: $recipient

        From: $sender

        Subject: KNB Password Reset

        Somebody (hopefully you) requested that your KNB password be reset.  

        This is generally done when somebody forgets their password.  Your 

        password can be changed by visiting the following URL:

        @cgiurl@?stage=changepass&cfg=$cfg

            Username: $username

        Organization: $org

        New Password: $newPass

        Thanks,

            The KNB Development Team

        ENDOFMESSAGE

        $message =~ s/^[ \t\r\f]+//gm;

        $smtp->data($message);

        $smtp->quit;

    } else {

        $errorMessage = "Failed to send password because I " .

                        "couldn't find a valid email address.";

    }

    return $errorMessage;

}

#

# search the LDAP directory to see if a similar account already exists

#

sub findExistingAccounts {

    my $ldapurl = shift;

    my $base = shift;

    my $filter = shift;

    my $attref = shift;

    my $ldap;

    my $foundAccounts = 0;

    #print("the ldapurl in findExstingAccounts is ", $ldapurl, "\n");

    if ($ldapurl =~ $mainldapurl){

        #if main ldap server is down, a html file containing warning message will be returned

        $ldap = Net::LDAP->new($ldapurl, timeout => $TIMEOUT) or handleGeneralServerFailure($mainldapdownmessage);

    }

    else{

        #if a referral ldap server is down, we will ignore it silently

        $ldap = Net::LDAP->new($ldapurl, timeout => $TIMEOUT) or return;

    }

    $ldap->start_tls( verify => 'none');

    $ldap->bind( version => 3, anonymous => 1);

    my $mesg = $ldap->search (

        base   => $base,

        filter => $filter,

        attrs => @$attref,

    );

    if ($mesg->count() > 0) {

        $foundAccounts = "";

        my $entry;

        foreach $entry ($mesg->all_entries) { 

            $foundAccounts .= "<p>\n<b><u>Account:</u> ";

            $foundAccounts .= $entry->dn();

            $foundAccounts .= "</b><br />\n";

            foreach my $attribute ($entry->attributes()) {

                $foundAccounts .= "$attribute: ";

                $foundAccounts .= $entry->get_value($attribute);

                $foundAccounts .= "<br />\n";

            }

            $foundAccounts .= "</p>\n";

        }

    }

    $ldap->unbind;   # take down session

    # Follow references

    my @references = $mesg->references();

    for (my $i = 0; $i <= $#references; $i++) {

        my $uri = URI->new($references[$i]);

        my $host = $uri->host();

        my $path = $uri->path();

        $path =~ s/^\///;

        my $refFound = &findExistingAccounts($host, $path, $filter, $attref);

        if ($refFound) {

            $foundAccounts .= $refFound;

        }

    }

    #print "<p>Checking referrals...</p>\n";

    #my @referrals = $mesg->referrals();

    #print "<p>Referrals count: ", scalar(@referrals), "</p>\n";

    #for (my $i = 0; $i <= $#referrals; $i++) {

        #print "<p>Referral: ", $referrals[$i], "</p>\n";

    #}

    return $foundAccounts;

}

#

# Validate that we have the proper set of input parameters

#

sub paramsAreValid {

    my @pnames = @_;

    my $allValid = 1;

    foreach my $parameter (@pnames) {

        if (!defined($query->param($parameter)) || 

            ! $query->param($parameter) ||

            $query->param($parameter) =~ /^\s+$/) {

            $allValid = 0;

        }

    }

    return $allValid;

}

#

# Bind to LDAP and create a new account using the information provided

# by the user

#

sub createAccount {

    my $allParams = shift;

    if ($query->param('o') =~ "LTER") {

        $template->process( "@defaultHeader@");

        $template->process( "@registerLter@");

        $template->process( "@defaultFooter@");

    } else {

        # Be sure the passwords match

        if ($query->param('userPassword') !~ $query->param('userPassword2')) {

            my $errorMessage = "The passwords do not match. Try again.";

            my $templateVars = { stage => "register",

                                 cfg => $cfg,

                                 allParams => $allParams,

                                 errorMessage => $errorMessage };

            $$templateVars{'orgList'} = \@orglist;

            $template->process( "@defaultHeader@", $templateVars);

            $template->process( "@registerFailed@", $templateVars);

            $template->process( "@register@", $templateVars);

            $template->process( "@defaultFooter@", $templateVars);

            exit(0);

        }

        my $o = $query->param('o');

        my $ldapurl = $config_ldapurl->{$o};

        my $root = $config_user->{$o};

        my $rootpw = $config_password->{$o};

        my $searchBase = $config_ldapsearchbase->{$o};

        my $dnBase = $config_dn->{$o};

        #if main ldap server is down, a html file containing warning message will be returned

        my $ldap = Net::LDAP->new($ldapurl, timeout => $TIMEOUT) or handleGeneralServerFailure("The ldap server " . $ldapurl . " is down!");

        $ldap->start_tls( verify => 'none');

        $ldap->bind( version => 3, dn => $root, password => $rootpw );

        #print "Inserting new entry...\n";

        my $dn = 'uid=' . $query->param('uid') . ',' . $dnBase;

        # Create a hashed version of the password

        my $shapass = createSeededPassHash($query->param('userPassword'));

        # Do the insertion

        my $additions = [ 

                'uid'   => $query->param('uid'),

                'o'   => $query->param('o'),