#!/usr/bin/perl -w
# This script (sophomorix-admin) is maintained by Rüdiger Beck
# It is Free Software (License GPLv3)
# If you find errors, contact the author
# jeffbeck@web.de  or  jeffbeck@linuxmuster.net

# modules
use strict;
use Getopt::Long;
Getopt::Long::Configure ("bundling");
use Sophomorix::SophomorixConfig;
use List::MoreUtils qw(uniq);

#use Sophomorix::SophomorixConfig;
#use Sophomorix::SophomorixBase;
#use Sophomorix::SophomorixAPI;
#use Sophomorix::SophomorixPgLdap;
#use DBI;
#use Net::LDAP;
use Net::LDAP;
use Data::Dumper;
$Data::Dumper::Indent = 1;
$Data::Dumper::Sortkeys = 1;
$Data::Dumper::Useqq = 1;
$Data::Dumper::Terse = 1; 
use JSON;

use Sophomorix::SophomorixBase qw(
                                 print_line
                                 print_title
                                 unlock_sophomorix
                                 lock_sophomorix
                                 log_script_start
                                 log_script_end
                                 log_script_exit
                                 backup_auk_file
                                 get_passwd_charlist
                                 get_plain_password
                                 check_options
                                 config_sophomorix_read
                                 result_sophomorix_init
                                 result_sophomorix_add
                                 result_sophomorix_add_summary
                                 result_sophomorix_check_exit
                                 result_sophomorix_print
                                 remove_from_list
                                 json_dump
                                 );
use Sophomorix::SophomorixSambaAD qw(
                                 AD_school_create
                                 AD_bind_admin
                                 AD_dns_get
                                 AD_get_user
                                 AD_user_kill
                                 AD_unbind_admin
                                 AD_object_search
                                 AD_user_create
                                 AD_group_create
                                 AD_group_kill
                                 AD_group_addmember
                                 AD_get_schoolname
                                 AD_get_name_tokened
                                 AD_group_update
                                 AD_project_sync_members
                                 AD_dn_fetch_multivalue
                                 AD_get_passwd
                                 AD_get_users_v
                                 AD_get_full_userdata
                                    );
my @arguments = @ARGV;

# option vars
$Conf::log_level=1;
my $help=0;
my $info=0;
my $json=0;
my $create_school_admin="";
my $create_global_admin="";
my $create_school_binduser="";
my $create_global_binduser="";
my $school="";
my $admin="";
my $abs_path_ui_ini="";

my $password="";
my $random_password_save=0;
my $random_password_show=0;

my $kill="";
my $reset_class="";
$Conf::log_level=1;


# Parsen der Optionen
my $testopt=GetOptions(
           "help|h" => \$help,
           "info|i" => \$info,
           "json|j+" => \$json,
           "verbose|v+" => \$Conf::log_level,
           "create-school-admin=s" => \$create_school_admin,
           "create-global-admin=s" => \$create_global_admin,
           "create-school-binduser=s" => \$create_school_binduser,
           "create-global-binduser=s" => \$create_global_binduser,
           "school|s=s" => \$school,
           "admin|a=s" => \$admin,
           "abs-path-ui-ini=s" => \$abs_path_ui_ini,
           "password|passwd=s" => \$password,
           "random-passwd-save|random-password-save" => \$random_password_save,
           "random-passwd-show|random-password-show" => \$random_password_show,
           "kill=s" => \$kill,
          );

my %sophomorix_result=&result_sophomorix_init("sophomorix-admin");
# Prüfen, ob Optionen erkannt wurden
&check_options($testopt,\%sophomorix_result,$json);

# Reading Configuration
my ($ldap,$root_dse) = &AD_bind_admin(\@arguments,\%sophomorix_result,$json);
my $root_dns=&AD_dns_get($root_dse);
my %sophomorix_config=&config_sophomorix_read($ldap,$root_dse,\%sophomorix_result);
my ($smb_admin_pass)=&AD_get_passwd($DevelConf::sophomorix_file_admin,
                                     $DevelConf::secret_file_sophomorix_file_admin);

# --help
if ($help==1) {
   # Scriptname ermitteln
   my @list = split(/\//,$0);
   my $scriptname = pop @list;
   # Befehlbeschreibung
   print('
sophomorix-admin adds admins

Options
  -h  / --help
  -v  / --verbose
  -vv / --verbose --verbose
  -i  / --info           one user per line
  --info --admin <user1>,<user2>         detailed view of user            

  --abs-path-ui-ini /path/to/ini  (use another ini file for webui permissions, for tests only)


Administrators:

# create a powerful global-admin:
sophomorix-admin --create-global-admin <name-of-admin> --password <fdrTfdtti>
sophomorix-admin --create-global-admin <name-of-admin> --random-passwd-show
sophomorix-admin --create-global-admin <name-of-admin> --random-passwd-save

# create an school-admin
sophomorix-admin --create-school-admin <name-of-admin> --school <schoolname> --password <fdrTfdtti>
sophomorix-admin --create-school-admin <name-of-admin> --school <schoolname> --random-passwd-show
sophomorix-admin --create-school-admin <name-of-admin> --school <schoolname> --random-passwd-save


Bind Users to access the samba AD-DIT:

# create a global-binduser:
sophomorix-admin --create-global-binduser <name-of-binduser> --password <fdrTfdtti>
sophomorix-admin --create-global-binduser <name-of-binduser> --random-passwd-show
sophomorix-admin --create-global-binduser <name-of-binduser> --random-passwd-save

# create an school-binduser:
sophomorix-admin --create-school-binduser <name-of-binduser> --school <schoolname> --password <fdrTfdtti>
sophomorix-admin --create-school-binduser <name-of-binduser> --school <schoolname> --random-passwd-show
sophomorix-admin --create-school-binduser <name-of-binduser> --school <schoolname> --random-passwd-save


# add a comment to a user:
sophomorix-user --user <username> --comment "This is the comment"


# kill an administrator or binduser created by sophomorix
sophomorix-admin --kill <name-of-admin>

Please see the sophomorix-admin(8) man pages for full documentation
');
   print "\n";
   exit;
}



# --info  overview
if ($info==1 and $admin eq ""){
   my $ref_user_v=&AD_get_users_v({ldap=>$ldap,
                                  root_dse=>$root_dse,
                                  root_dns=>$root_dns,
                                  school=>$school,
                                  admins_only=>"TRUE",
                                  sophomorix_config=>\%sophomorix_config,
                                });
    #print Dumper($ref_user_v);
    my $jsoninfo="ADMINS_V";
    my $jsoncomment="All admins";
    &json_dump({json => $json,
                jsoninfo => $jsoninfo,
                jsoncomment => $jsoncomment,
                object_name => $school,
                log_level => $Conf::log_level,
                hash_ref => $ref_user_v,
                sophomorix_config => \%sophomorix_config,
               });
    exit;
}



# --info --admin <admin1>, ...
if ($info==1 and $admin ne ""){
    my $ref_users=&AD_get_full_userdata({ldap=>$ldap,
                                        root_dse=>$root_dse,
                                        root_dns=>$root_dns,
                                        userlist=>$admin,
                                        sophomorix_config=>\%sophomorix_config,
                                      });
    #print Dumper($ref_users);
    my $jsoninfo="USER";
    my $jsoncomment="One sophomorix user";
    &json_dump({json => $json,
                jsoninfo => $jsoninfo,
                jsoncomment => $jsoncomment,
                object_name => $admin,
                log_level => $Conf::log_level,
                hash_ref => $ref_users,
                sophomorix_config => \%sophomorix_config,
               });
    exit;
}



&result_sophomorix_check_exit(\%sophomorix_result,\%sophomorix_config,$json);
# ===========================================================================
# Start
# ===========================================================================
&log_script_start(\@arguments,\%sophomorix_result,\%sophomorix_config);

############################################################
# Test if options are mixed correctly
############################################################

# passwd option
my $pwd_option_count=0;
if ($password ne ""){
    $pwd_option_count++;
}
if ($random_password_save==1){
    $pwd_option_count++;
}
if ($random_password_show==1){
    $pwd_option_count++;
}

if ($kill ne ""){
    # ok without password
} elsif ($pwd_option_count>1){
    print "\nERROR: Only one password option is allowed\n\n";
    exit 88;
} elsif ($pwd_option_count==0){
    print "\nERROR: A password option is needed\n\n";
    exit 88;
} 

# avoid double create
my $create_count=0;


# admins
# --create-school-admin
if ($create_school_admin ne ""){
    $create_count++;
    my ($count,$dn,$rdn)=&AD_object_search($ldap,$root_dse,"all",$create_school_admin);
    if ($count==0){
        # ok
    } else {
        print "\nERROR: Object $create_school_admin exists already in AD\n\n";
        exit 88;
    }
    if ($school eq ""){
        print "\nERROR: Option --school is needed with option --create-school-admin\n\n";
        exit 88;
    }
}

# --create-global-admin
if ($create_global_admin ne ""){
    $create_count++;
    my ($count,$dn,$rdn)=&AD_object_search($ldap,$root_dse,"all",$create_global_admin);
    if ($count==0){
        # ok
    } else {
        print "\nERROR: Object $create_global_admin exists already in AD\n\n";
        exit 88;
    }
    if ($school ne ""){
        print "\nERROR: Option --school is useless with option --create-global-admin\n\n";
        exit 88;
    }
}



# bindusers
# --create-school-binduser
if ($create_school_binduser ne ""){
    $create_count++;
    my ($count,$dn,$rdn)=&AD_object_search($ldap,$root_dse,"all",$create_school_binduser);
    if ($count==0){
        # ok
    } else {
        print "\nERROR: Object $create_school_binduser exists already in AD\n\n";
        exit 88;
    }
    if ($school eq ""){
        print "\nERROR: Option --school is needed with option --create-school-binduser\n\n";
        exit 88;
    }
}

# --create-global-binduser
if ($create_global_binduser ne ""){
    $create_count++;
    my ($count,$dn,$rdn)=&AD_object_search($ldap,$root_dse,"all",$create_global_binduser);
    if ($count==0){
        # ok
    } else {
        print "\nERROR: Object $create_global_binduser exists already in AD\n\n";
        exit 88;
    }
    if ($school ne ""){
        print "\nERROR: Option --school is useless with option --create-global-binduser\n\n";
        exit 88;
    }
}




if ($create_count>1){
        print "\nERROR: You can only use one --create* option at a time\n\n";
        exit 88;

}

############################################################
# Options do it
############################################################

# admins
# --create-school-admin <user>
if ($create_school_admin ne "" and $school ne ""){
    # test if school exists
    if (exists $sophomorix_config{'SCHOOLS'}{$school}){
        # is ok
    } else {
        print "\nERROR: School $school is not a valid school for a school-admin on this server\n\n";
        &print_valid_schools;
        exit 88;
    }

    my $group_token;
    if ($school eq $DevelConf::name_default_school){
        $group_token=$sophomorix_config{'INI'}{'administrator.school'}{'GROUPBASENAME'};
    } else {
        $group_token=$school."-".
	             $sophomorix_config{'INI'}{'administrator.school'}{'GROUPBASENAME'};
    }

    # make sure school exists
    &print_title("Creating admin $create_school_admin in school $school");
    &AD_school_create({ldap=>$ldap,
                       root_dse=>$root_dse,
                       root_dns=>$root_dns,
                       school=>$school,
                       smb_admin_pass=>$smb_admin_pass,
                       sophomorix_config=>\%sophomorix_config,
                       sophomorix_result=>\%sophomorix_result,
                     });

    $password=&choose_password($create_school_admin,"administrator.school",$password,$random_password_save,$random_password_show);
    my $role=$sophomorix_config{'INI'}{'administrator.school'}{'USER_ROLE'};
    &AD_user_create({ldap=>$ldap,
                    root_dse => $root_dse, 
                    root_dns => $root_dns, 
                    user_count => "1",
                    max_user_count => "1",
                    login => $create_school_admin,
                    group => $group_token,
                    group_basename => $sophomorix_config{'INI'}{'administrator.school'}{'GROUPBASENAME'},
                    firstname_ascii => $school,
                    surname_ascii => $sophomorix_config{'INI'}{'administrator.school'}{'DEFAULT_sn_ASCII'},
                    firstname_utf8 => $school,
                    surname_utf8 => $sophomorix_config{'INI'}{'administrator.school'}{'DEFAULT_sn'},
                    birthdate => "---",
                    sophomorix_first_password => $password,
                    unid => "---",
                    role => $role,
                    type => "sophomorixadmin",
                    school => $school,
                    tolerationdate => "---",
                    deactivationdate => "---",
                    status => "P",
                    file => $sophomorix_config{'INI'}{'administrator.school'}{'ADMINFILE'},
                    smb_admin_pass=>$smb_admin_pass,
                    json=>$json,
                    webui_permissions_calculated=>$sophomorix_config{'ROLES'}{$school}{$role}{'UI'}{'WEBUI_PERMISSIONS'},
                    sophomorix_config=>\%sophomorix_config,
                    sophomorix_result=>\%sophomorix_result,
                  });
} elsif ($create_school_admin ne "" and $school eq ""){
    print "\nERROR: Option --school <school> is needed to create the admin $create_school_admin\n\n";
    exit 88;
} 




# --create-global-admin <user>
if ($create_global_admin){
    $school=$sophomorix_config{'INI'}{'GLOBAL'}{'SCHOOLNAME'};
    my $group_token=$sophomorix_config{'INI'}{'administrator.global'}{'GROUPPREFIX'}.
	             $sophomorix_config{'INI'}{'administrator.global'}{'GROUPBASENAME'};
    &print_title("Creating admin $create_global_admin in school $school");
    &AD_school_create({ldap=>$ldap,
                       root_dse=>$root_dse,
                       root_dns=>$root_dns,
                       school=>$DevelConf::name_default_school,
                       smb_admin_pass=>$smb_admin_pass,
                       sophomorix_config=>\%sophomorix_config,
                       sophomorix_result=>\%sophomorix_result,
                     });

    $password=&choose_password($create_global_admin,"administrator.global",$password,$random_password_save,$random_password_show);
    my $role=$sophomorix_config{'INI'}{'administrator.global'}{'USER_ROLE'};
    &AD_user_create({ldap=>$ldap,
                    root_dse => $root_dse, 
                    root_dns => $root_dns, 
                    user_count => "1",
                    max_user_count => "1",
                    login => $create_global_admin,
                    group => $group_token,
                    group_basename => $sophomorix_config{'INI'}{'administrator.global'}{'GROUPBASENAME'},
                    firstname_ascii => $sophomorix_config{'INI'}{'administrator.global'}{'DEFAULT_givenName_ASCII'},
                    surname_ascii => $sophomorix_config{'INI'}{'administrator.global'}{'DEFAULT_sn_ASCII'},
                    firstname_utf8 => $sophomorix_config{'INI'}{'administrator.global'}{'DEFAULT_givenName'},
                    surname_utf8 => $sophomorix_config{'INI'}{'administrator.global'}{'DEFAULT_sn'},
                    birthdate => "---",
                    sophomorix_first_password => $password,
                    unid => "---",
                    role => $role,
                    type => "sophomorixadmin",
                    school => $school,
                    tolerationdate => "---",
                    deactivationdate => "---",
                    status => "P",
                    file => $sophomorix_config{'INI'}{'administrator.global'}{'ADMINFILE'},
                    smb_admin_pass=>$smb_admin_pass,
                    json=>$json,
                    webui_permissions_calculated=>$sophomorix_config{'UI'}{'CONFIG'}{'WEBUI_PERMISSIONS'}{$role}{'WEBUI_PERMISSIONS'},
                    sophomorix_config=>\%sophomorix_config,
                    sophomorix_result=>\%sophomorix_result,
                  });
}



# bindusers
# --create-school-binduser <user>
if ($create_school_binduser ne "" and $school ne ""){
    # test if school exists
    if (exists $sophomorix_config{'SCHOOLS'}{$school}){
        # is ok
    } else {
        print "\nERROR: School $school is not a valid school for a school-binduser on this server\n\n";
        &print_valid_schools;
        exit 88;
    }

    my $group_token;
    if (exists $sophomorix_config{'INI'}{'binduser.school'}{'GROUPNAME'}){
        # if a group ist given
        $group_token=$sophomorix_config{'INI'}{'binduser.school'}{'GROUPNAME'};
    } elsif ($school eq $DevelConf::name_default_school){
        $group_token=$sophomorix_config{'INI'}{'binduser.school'}{'GROUPBASENAME'};
    } else {
        $group_token=$school."-".
	             $sophomorix_config{'INI'}{'binduser.school'}{'GROUPBASENAME'};
    }

    # make sure school exists
    &print_title("Creating binduser $create_school_binduser in school $school");
    &AD_school_create({ldap=>$ldap,
                       root_dse=>$root_dse,
                       root_dns=>$root_dns,
                       school=>$school,
                       smb_admin_pass=>$smb_admin_pass,
                       sophomorix_config=>\%sophomorix_config,
                       sophomorix_result=>\%sophomorix_result,
                     });

    $password=&choose_password($create_school_binduser,"binduser.school",$password,$random_password_save,$random_password_show);

    &AD_user_create({ldap=>$ldap,
                    root_dse => $root_dse, 
                    root_dns => $root_dns, 
                    user_count => "1",
                    max_user_count => "1",
                    login => $create_school_binduser,
                    group => $group_token,
                    group_basename => $sophomorix_config{'INI'}{'binduser.school'}{'GROUPBASENAME'},
                    firstname_ascii => $school,
                    surname_ascii => $sophomorix_config{'INI'}{'binduser.school'}{'DEFAULT_sn_ASCII'},
                    firstname_utf8 => $school,
                    surname_utf8 => $sophomorix_config{'INI'}{'binduser.school'}{'DEFAULT_sn'},
                    birthdate => "---",
                    sophomorix_first_password => $password,
                    unid => "---",
                    role => $sophomorix_config{'INI'}{'binduser.school'}{'USER_ROLE'},
                    type => "sophomorixbinduser",
                    school => $school,
                    tolerationdate => "---",
                    deactivationdate => "---",
                    status => "P",
                    file => $sophomorix_config{'INI'}{'binduser.school'}{'BINDUSERFILE'},
                    smb_admin_pass=>$smb_admin_pass,
                    json=>$json,
                    sophomorix_config=>\%sophomorix_config,
                    sophomorix_result=>\%sophomorix_result,
                  });
} elsif ($create_school_binduser ne "" and $school eq ""){
    print "\nERROR: Option --school <school> is needed to create the binduser $create_school_binduser\n\n";
    exit 88;
} 




# --create-global-binduser <user>
if ($create_global_binduser ne ""){
    $school=$sophomorix_config{'INI'}{'GLOBAL'}{'SCHOOLNAME'};
    my $group_token=$sophomorix_config{'INI'}{'binduser.global'}{'GROUPPREFIX'}.
	             $sophomorix_config{'INI'}{'binduser.global'}{'GROUPBASENAME'};
    &print_title("Creating binduser $create_global_binduser in school $school");
    &AD_school_create({ldap=>$ldap,
                       root_dse=>$root_dse,
                       root_dns=>$root_dns,
                       school=>$DevelConf::name_default_school,
                       smb_admin_pass=>$smb_admin_pass,
                       sophomorix_config=>\%sophomorix_config,
                       sophomorix_result=>\%sophomorix_result,
                     });

    $password=&choose_password($create_global_binduser,"binduser.global",$password,$random_password_save,$random_password_show);

    &AD_user_create({ldap=>$ldap,
                    root_dse => $root_dse, 
                    root_dns => $root_dns, 
                    user_count => "1",
                    max_user_count => "1",
                    login => $create_global_binduser,
                    group => $group_token,
                    group_basename => $sophomorix_config{'INI'}{'binduser.global'}{'GROUPBASENAME'},
                    firstname_ascii => $sophomorix_config{'INI'}{'binduser.global'}{'DEFAULT_givenName_ASCII'},
                    surname_ascii => $sophomorix_config{'INI'}{'binduser.global'}{'DEFAULT_sn_ASCII'},
                    firstname_utf8 => $sophomorix_config{'INI'}{'binduser.global'}{'DEFAULT_givenName'},
                    surname_utf8 => $sophomorix_config{'INI'}{'binduser.global'}{'DEFAULT_sn'},
                    birthdate => "---",
                    sophomorix_first_password => $password,
                    unid => "---",
                    role => $sophomorix_config{'INI'}{'binduser.global'}{'USER_ROLE'},
                    type => "sophomorixglobalbinduser",
                    school => $school,
                    tolerationdate => "---",
                    deactivationdate => "---",
                    status => "P",
                    file => $sophomorix_config{'INI'}{'binduser.global'}{'BINDUSERFILE'},
                    smb_admin_pass=>$smb_admin_pass,
                    json=>$json,
                    sophomorix_config=>\%sophomorix_config,
                    sophomorix_result=>\%sophomorix_result,
                  });
} 



# --kill <user>
if ($kill ne ""){
    # make sure it exists and is an administrator created by sophomorix
    my ($firstname_utf8_AD,$lastname_utf8_AD,$adminclass_AD,$existing_AD,$exammode_AD,$role_AD,
        $home_directory_AD,$user_account_control_AD,$toleration_date_AD,$deactivation_date_AD,
        $school_AD,$status_AD,$firstpassword_AD,$unid_AD)=
    &AD_get_user({ldap=>$ldap,
                  root_dse=>$root_dse,
                  root_dns=>$root_dns,
                  user=>$kill,
                });

    if ($existing_AD eq "FALSE"){
        print "\nERROR: User $kill does not exist\n\n";
        exit 88;
    }
    if ($role_AD eq $sophomorix_config{'INI'}{'administrator.global'}{'USER_ROLE'} or
        $role_AD eq $sophomorix_config{'INI'}{'administrator.school'}{'USER_ROLE'} or
        $role_AD eq $sophomorix_config{'INI'}{'binduser.global'}{'USER_ROLE'} or
        $role_AD eq $sophomorix_config{'INI'}{'binduser.school'}{'USER_ROLE'}
       ){
        &AD_user_kill({ldap=>$ldap,
                       root_dse=>$root_dse,
                       root_dns=>$root_dns,
                       login=>$kill,
                       user_count=>"1",
                       max_user_count=>"1",
                       smb_admin_pass=>$smb_admin_pass,
                       json=>$json,
                       sophomorix_config=>\%sophomorix_config,
                       sophomorix_result=>\%sophomorix_result,
                     });
        my $pwd_file=$sophomorix_config{'INI'}{'PATHS'}{'SECRET_PWD'}."/".$kill;
        if (-e $pwd_file){
            &Sophomorix::SophomorixBase::print_title("Removing $pwd_file");
            system ("rm -f $pwd_file");
        }
    } else {
        print "\nERROR: User $kill is not an administrator created by sophomorix\n\n";
        exit 88;
    }
}


&AD_unbind_admin($ldap);
&log_script_end(\@arguments,\%sophomorix_result,\%sophomorix_config,$json);
############################################################
# End
############################################################



############################################################
# subs
############################################################
sub print_valid_schools{
    my @list=();
    foreach my $key (keys %{$sophomorix_config{'SCHOOLS'}}) {
	push @list, $key;
    }
    @list=sort @list;
    push @list, $sophomorix_config{'INI'}{'GLOBAL'}{'SCHOOLNAME'};
    print "   * Valid schools on are:\n";
    foreach my $file (@list){
        print "      * $file\n";
    }
}


sub choose_password {
    my ($user,$role_user,$password,$random_password_save,$random_password_show) = @_;
    if ($random_password_save==1){
        my @password_chars=&get_passwd_charlist();
        $password=&Sophomorix::SophomorixBase::create_plain_password(
            $sophomorix_config{'INI'}{$role_user}{'RANDOM_PWD'},
            $sophomorix_config{'INI'}{$role_user}{'RANDOM_PWD_LENGTH'},
            "01.01.1970", # dummy birthday
            @password_chars);
        my $mkdir=$sophomorix_config{'INI'}{'PATHS'}{'SECRET_PWD'};
        system("mkdir -p $mkdir");
        my $pwd_file=$sophomorix_config{'INI'}{'PATHS'}{'SECRET_PWD'}."/".$user;
        open(SECRET, ">$pwd_file") || die "ERROR: $! $pwd_file";
        print SECRET $password;
        close(SECRET);
        system("chown root:root $pwd_file");
        system("chmod 0600 $pwd_file");
    } elsif ($random_password_show==1){
        my @password_chars=&get_passwd_charlist();
        $password=&Sophomorix::SophomorixBase::create_plain_password(
            $sophomorix_config{'INI'}{$role_user}{'RANDOM_PWD'},
            $sophomorix_config{'INI'}{$role_user}{'RANDOM_PWD_LENGTH'},
            "01.01.1970", # dummy birthday
            @password_chars);
        &result_sophomorix_add_summary({
                     NAME=>"ADD", 
                     RESULT=>$password, 
                     RESULT_TYPE => "string",
                     DESCRIPTION_POST => " is the password of the user ".$user, 
                     DESCRIPTION_PRE => "Password of user ".$user." is:", 
                     FORMAT_TYPE => 1,
                     sophomorix_result=>\%sophomorix_result,
			       });
    }
    return $password;
}
