cgi-files/Modules/System/Users.pm

   1 #################################################################################
   2 # Xestia Scanner Server - Users System Module                                   #
   3 # Version 0.1.0                                                                 #
   4 #                                                                               #
   5 # This module is licensed under the same license as Xestia Scanner Server which #
   6 # is licensed under the GPL version 3.                                          #
   7 #                                                                               #
   8 # This program is free software: you can redistribute it and/or modify          #
   9 # it under the terms of the GNU General Public License as published by          #
  10 # the Free Software Foundation, version 3 of the License.                       #
  11 #                                                                               #
  12 # This program is distributed in the hope that it will be useful,               #
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of                #
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                 #
  15 # GNU General Public License for more details.                                  #
  16 #                                                                               #
  17 # You should have received a copy of the GNU General Public License             #
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.         #
  19 #################################################################################
  20
  21 package Modules::System::Users;
  22
  23 use Modules::System::Common;
  24 use Modules::System::Scan;
  25 use strict;
  26 use warnings;
  27 use Exporter;
  28 use Sane;
  29
  30 our @ISA = qw(Exporter);
  31 our @EXPORT = qw(xestiascan_users_list xestiascan_users_add xestiascan_users_edit xestiascan_users_delete xestiascan_users_flush);
  32
  33 sub xestiascan_users_list{
  34 #################################################################################
  35 # xestiascan_users_list: Get the list of available users.                       #
  36 #                                                                               #
  37 # Usage:                                                                        #
  38 #                                                                               #
  39 # xestiascan_users_list(options);                                               #
  40 #                                                                               #
  41 # Specifies the following options as a hash (in any order).                     #
  42 #                                                                               #
  43 # HideDeactivatedUsers  Hide deactivated users.                                 #
  44 #################################################################################
  45
  46         # Get the values that have been passed to the subroutine.
  47
  48         my ($options) = @_;
  49
  50         my $showdeactivated = 0;
  51
  52         if ($options->{"ShowDeactivatedUsers"} && $options->{"ShowDeactivatedUsers"} eq 1){
  53
  54                 # Show deactivated users.
  55
  56                 $showdeactivated = 1;
  57
  58         }
  59
  60         # Connect to the database server.
  61
  62         $main::xestiascan_authmodule->connect();
  63
  64         # Check if any errors occured while connecting to the database server.
  65
  66         if ($main::xestiascan_authmodule->geterror eq "AuthConnectionError"){
  67
  68                 # A database connection error has occured so return
  69                 # an error.
  70
  71                 xestiascan_error("authconnectionerror", $main::xestiascan_authmodule->geterror(1));
  72
  73         }
  74
  75         # Get the permissions for the user and check if the user is allowed to access this.
  76
  77         my $access_userlist = $main::xestiascan_authmodule->getpermissions({ Username => $main::loggedin_user, PermissionType => "Admin" });
  78
  79         xestiascan_error("usernameblank") if ($main::xestiascan_authmodule->geterror eq "UsernameBlank");
  80         xestiascan_error("permissiontypeblank") if ($main::xestiascan_authmodule->geterror eq "PermissionTypeBlank");
  81         xestiascan_error("autherror", $main::xestiascan_authmodule->geterror(1)) if ($main::xestiascan_authmodule->geterror eq "DatabaseError");
  82
  83         if ($access_userlist ne 1){
  84
  85                 # User not allowed to access the user list so return an error.
  86                 xestiascan_error("notpermitted");
  87
  88         }
  89
  90         my %user_list;
  91         my $user_name;
  92         my $cssstyle = 0;
  93         my $cssname = "";
  94
  95         # Print the top menu.
  96
  97         $main::xestiascan_presmodule->startbox("sectionboxnofloat");
  98         $main::xestiascan_presmodule->startbox("sectiontitle");
  99         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{listusers});
 100         $main::xestiascan_presmodule->endbox();
 101         $main::xestiascan_presmodule->startbox("secondbox");
 102
 103         $main::xestiascan_presmodule->startform($main::xestiascan_env{"script_filename"}, "POST");
 104         $main::xestiascan_presmodule->addhiddendata("mode", "users");
 105
 106         $main::xestiascan_presmodule->addbutton("action", { Value => "add", Description => $main::xestiascan_lang{users}{adduser} });
 107         $main::xestiascan_presmodule->addtext(" | ");
 108         $main::xestiascan_presmodule->addbutton("action", { Value => "flush", Description => $main::xestiascan_lang{users}{logoutallusers} });
 109
 110         $main::xestiascan_presmodule->addlinebreak();
 111
 112         $main::xestiascan_presmodule->addcheckbox("showdeactivated", { OptionDescription => $main::xestiascan_lang{users}{showdeactivated}, Checked => $showdeactivated });
 113         $main::xestiascan_presmodule->addtext(" | ");
 114         $main::xestiascan_presmodule->addsubmit($main::xestiascan_lang{users}{update});
 115         $main::xestiascan_presmodule->addlinebreak();
 116         $main::xestiascan_presmodule->endform();
 117
 118         # Get the list of users and return a message if the permissions system is
 119         # unsupported by this database server type.
 120
 121         %user_list = $main::xestiascan_authmodule->getuserlist({ Reduced => 1, ShowDeactivated => $showdeactivated });
 122
 123         if ($main::xestiascan_authmodule->geterror eq "DatabaseError"){
 124
 125                 # A database error has occured so return an error with
 126                 # the extended error information.
 127
 128                 xestiascan_error("autherror", $main::xestiascan_authmodule->geterror(1));
 129
 130         }
 131
 132         $main::xestiascan_presmodule->starttable("", { CellPadding => "5", CellSpacing => "0" });
 133         $main::xestiascan_presmodule->startheader();
 134         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{username}, { Style => "tablecellheader" });
 135         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{name}, { Style => "tablecellheader" });
 136         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{options}, { Style => "tablecellheader" });
 137         $main::xestiascan_presmodule->endheader();
 138
 139         foreach $user_name (keys %user_list){
 140
 141                 $main::xestiascan_presmodule->startrow();
 142
 143                 if ($cssstyle eq 0){
 144
 145                         $cssname = "tablecell1";
 146                         $cssstyle = 1;
 147
 148                 } else {
 149
 150                         $cssname = "tablecell2";
 151                         $cssstyle = 0;
 152
 153                 }
 154
 155                 $cssname = "tablecelldisabled" if $user_list{$user_name}{deactivated} eq 1;
 156
 157                 $main::xestiascan_presmodule->addcell($cssname);
 158                 $main::xestiascan_presmodule->addtext($user_list{$user_name}{username});
 159                 $main::xestiascan_presmodule->endcell();
 160                 $main::xestiascan_presmodule->addcell($cssname);
 161                 $main::xestiascan_presmodule->addtext($user_list{$user_name}{name});
 162                 $main::xestiascan_presmodule->endcell();
 163                 $main::xestiascan_presmodule->addcell($cssname);
 164                 $main::xestiascan_presmodule->addlink($main::xestiascan_env{"script_filename"}  . "?mode=users&action=edit&user=" . $user_list{$user_name}{username}, { Text => $main::xestiascan_lang{options}{edit} });
 165                 $main::xestiascan_presmodule->addlink($main::xestiascan_env{"script_filename"}  . "?mode=users&action=delete&user=" . $user_list{$user_name}{username}, { Text => $main::xestiascan_lang{options}{delete} });
 166                 $main::xestiascan_presmodule->endcell();
 167
 168                 $main::xestiascan_presmodule->endrow();
 169
 170         }
 171
 172         $main::xestiascan_presmodule->endtable();
 173
 174         $main::xestiascan_presmodule->endbox();
 175         $main::xestiascan_presmodule->endbox();
 176
 177         # Disconnect from the database server.
 178
 179         $main::xestiascan_authmodule->disconnect();
 180
 181         return $main::xestiascan_presmodule->grab();
 182
 183 }
 184
 185 sub xestiascan_users_add{
 186 #################################################################################
 187 # xestiascan_users_add: Add a user to the user list.                            #
 188 #                                                                               #
 189 # Usage:                                                                        #
 190 #                                                                               #
 191 # xestiascan_users_add(username, userinfo, scannerinfo, outputmoduleinfo,       #
 192 #                       exportmoduleinfo, confirm);                             #
 193 #                                                                               #
 194 # username              Specifies the username to add to the user list.         #
 195 # userinfo              Specifies the userinfo as a hashref.                    #
 196 # scannerinfo           Specifies the scanner permissions as a hashref.         #
 197 # outputmoduleinfo      Specifies the output module permissions as a hashref.   #
 198 # exportmoduleinfo      Specifies the export module permissions as a hashref.   #
 199 # confirm               Confirms the action to add a user to the user list.     #
 200 #################################################################################
 201
 202         my $username    = shift;
 203
 204         my $passed_userinfo             = shift;
 205         my $passed_scannerinfo          = shift;
 206         my $passed_outputmoduleinfo     = shift;
 207         my $passed_exportmoduleinfo     = shift;
 208
 209         my $confirm = shift;
 210
 211         $confirm = 0 if !$confirm;
 212
 213         # Connect to the database server.
 214
 215         $main::xestiascan_authmodule->connect();
 216
 217         # Check if any errors occured while connecting to the database server.
 218
 219         if ($main::xestiascan_authmodule->geterror eq "AuthConnectionError"){
 220
 221                 # A database connection error has occured so return
 222                 # an error.
 223
 224                 xestiascan_error("authconnectionerror", $main::xestiascan_authmodule->geterror(1));
 225
 226         }
 227
 228         # Check to see if the user has permission to manage users.
 229
 230         my $access_userlist = $main::xestiascan_authmodule->getpermissions({ Username => $main::loggedin_user, PermissionType => "Admin" });
 231
 232         xestiascan_error("usernameblank") if ($main::xestiascan_authmodule->geterror eq "UsernameBlank");
 233         xestiascan_error("permissiontypeblank") if ($main::xestiascan_authmodule->geterror eq "PermissionTypeBlank");
 234         xestiascan_error("autherror", $main::xestiascan_authmodule->geterror(1)) if ($main::xestiascan_authmodule->geterror eq "DatabaseError");
 235
 236         if ($access_userlist ne 1){
 237
 238                 # User not allowed to access the user list so return an error.
 239                 xestiascan_error("notpermitted");
 240
 241         }
 242
 243         # Check if there is a value in the username value and if there is then
 244         # assume a user is being added.
 245
 246         if ($confirm eq 1){
 247
 248                 my %final_userinfo              = ();
 249                 my %final_scannerinfo           = ();
 250                 my %final_outputmoduleinfo      = ();
 251                 my %final_exportmoduleinfo      = ();
 252                 my $hashkey;
 253                 my $hashkey_short;
 254
 255                 # De-reference the user information hash.
 256
 257                 $hashkey = "";
 258
 259                 foreach $hashkey (keys %$passed_userinfo){
 260
 261                         $final_userinfo{$hashkey} = $$passed_userinfo{$hashkey};
 262
 263                 }
 264
 265                 # De-reference the scanner information hash.
 266
 267                 $hashkey = "";
 268                 $hashkey_short = "";
 269
 270                 foreach $hashkey (keys %$passed_scannerinfo){
 271
 272                         $hashkey_short = $hashkey;
 273                         $hashkey_short =~ s/^scanner_//g;
 274
 275                         $final_scannerinfo{$hashkey_short} = $$passed_scannerinfo{$hashkey};
 276
 277                 }
 278
 279                 # De-reference the output module information hash.
 280
 281                 $hashkey = "";
 282                 $hashkey_short = "";
 283
 284                 foreach $hashkey (keys %$passed_outputmoduleinfo){
 285
 286                         $hashkey_short = $hashkey;
 287                         $hashkey_short =~ s/^outputmodule_//g;
 288
 289                         $final_outputmoduleinfo{$hashkey_short} = $$passed_outputmoduleinfo{$hashkey};
 290
 291                 }
 292
 293                 # De-reference the export module information hash.
 294
 295                 $hashkey = "";
 296                 $hashkey_short = "";
 297
 298                 foreach $hashkey (keys %$passed_exportmoduleinfo){
 299
 300                         $hashkey_short = $hashkey;
 301                         $hashkey_short =~ s/^exportmodule_//g;
 302
 303                         $final_exportmoduleinfo{$hashkey_short} = $$passed_exportmoduleinfo{$hashkey};
 304
 305                 }
 306
 307                 # Check if the username and password are blank and if they are
 308                 # then return an error.
 309
 310                 if (!$username){
 311
 312                         xestiascan_error("usernameblank");
 313
 314                 }
 315
 316                 if (!$final_userinfo{Password}){
 317
 318                         xestiascan_error("passwordblank");
 319
 320                 }
 321
 322                 # Check if the password matches with the confirm password value
 323                 # and return an error if this is not the case.
 324
 325                 if ($final_userinfo{Password} ne $final_userinfo{ConfirmPassword}){
 326
 327                         xestiascan_error("passwordsdonotmatch");
 328
 329                 }
 330
 331                 # Check all the values being passed to this subroutine are UTF-8
 332                 # valid.
 333
 334                 xestiascan_variablecheck(xestiascan_utf8convert($username), "utf8", 0, 0);
 335                 xestiascan_variablecheck(xestiascan_utf8convert($final_userinfo{Name}), "utf8", 0, 0);
 336                 xestiascan_variablecheck(xestiascan_utf8convert($final_userinfo{Password}), "utf8", 0, 0);
 337
 338                 # Check the length of the username, name and password to make sure
 339                 # they are valid.
 340
 341                 my $username_maxlength_check = xestiascan_variablecheck(xestiascan_utf8convert($username), "maxlength", 64, 1);
 342                 my $name_maxlength_check = xestiascan_variablecheck(xestiascan_utf8convert($final_userinfo{Name}), "maxlength", 256, 1);
 343                 my $password_maxlength_check = xestiascan_variablecheck(xestiascan_utf8convert($final_userinfo{Password}), "maxlength", 128, 1);
 344
 345                 if ($username_maxlength_check eq 1){
 346
 347                         # Username is too long so return an error.
 348
 349                         xestiascan_error("usernametoolong");
 350
 351                 }
 352
 353                 if ($name_maxlength_check eq 1){
 354
 355                         # Name is too long so return an error.
 356
 357                         xestiascan_error("nametoolong");
 358
 359                 }
 360
 361                 if ($password_maxlength_check eq 1){
 362
 363                         # Password is too long so return an error,
 364
 365                         xestiascan_error("passwordtoolong");
 366
 367                 }
 368
 369                 my $final_scanner;
 370
 371                 foreach $final_scanner (keys %final_scannerinfo){
 372
 373                         # Check to make sure that the scanner name and value
 374                         # are both valid UTF8.
 375
 376                         xestiascan_variablecheck($final_scanner, "utf8", 0, 0);
 377                         xestiascan_variablecheck($final_scannerinfo{$final_scanner}, "utf8", 0, 0);
 378
 379                 }
 380
 381                 # Check that the export and output modules contain valid UTF8
 382                 # and are valid filenames.
 383
 384                 my $final_module;
 385                 my $module_lettersnumbers_check;
 386
 387                 foreach $final_module (keys %final_outputmoduleinfo){
 388
 389                         xestiascan_variablecheck($final_module, "utf8", 0, 0);
 390                         xestiascan_variablecheck($final_outputmoduleinfo{$final_module}, "utf8", 0, 0);
 391
 392                         $module_lettersnumbers_check = xestiascan_variablecheck($final_module, "lettersnumbers", 0, 1);
 393                         xestiascan_error("moduleinvalid", xestiascan_language($main::xestiascan_lang{scan}{nameofoutputmoduleerror}, $final_module)) if $module_lettersnumbers_check eq 1;
 394
 395                 }
 396
 397                 $final_module = "";
 398                 $module_lettersnumbers_check = 0;
 399
 400                 foreach $final_module (keys %final_exportmoduleinfo){
 401
 402                         xestiascan_variablecheck($final_module, "utf8", 0, 0);
 403                         xestiascan_variablecheck($final_exportmoduleinfo{$final_module}, "utf8", 0, 0);
 404
 405                         $module_lettersnumbers_check = xestiascan_variablecheck($final_module, "lettersnumbers", 0, 1);
 406                         xestiascan_error("moduleinvalid", xestiascan_language($main::xestiascan_lang{scan}{nameofexportmoduleerror}, $final_module)) if $module_lettersnumbers_check eq 1;
 407
 408                 }
 409
 410                 # Add the user via adduser and pass the permissions to the
 411                 # edituser subroutine for the authentication module.
 412
 413                 $main::xestiascan_authmodule->adduser($username, %final_userinfo);
 414
 415                 if ($main::xestiascan_authmodule->geterror eq "DatabaseError"){
 416
 417                         xestiascan_error("userediterror", $main::xestiascan_authmodule->geterror(1));
 418
 419                 }
 420
 421                 if ($main::xestiascan_authmodule->geterror eq "UserExists"){
 422
 423                         xestiascan_error("userexists");
 424
 425                 }
 426
 427                 $main::xestiascan_authmodule->edituser($username, "Scanner", %final_scannerinfo);
 428
 429                 if ($main::xestiascan_authmodule->geterror eq "DatabaseError"){
 430
 431                         xestiascan_error("userediterror", $main::xestiascan_authmodule->geterror(1));
 432
 433                 }
 434
 435                 $main::xestiascan_authmodule->edituser($username, "OutputModule", %final_outputmoduleinfo);
 436
 437                 if ($main::xestiascan_authmodule->geterror eq "DatabaseError"){
 438
 439                         xestiascan_error("userediterror", $main::xestiascan_authmodule->geterror(1));
 440
 441                 }
 442
 443                 $main::xestiascan_authmodule->edituser($username, "ExportModule", %final_exportmoduleinfo);
 444
 445                 if ($main::xestiascan_authmodule->geterror eq "DatabaseError"){
 446
 447                         xestiascan_error("userediterror", $main::xestiascan_authmodule->geterror(1));
 448
 449                 }
 450
 451                 # Disconnect from the database server.
 452
 453                 $main::xestiascan_authmodule->disconnect();
 454
 455                 if ($main::xestiascan_authmodule->geterror eq "DatabaseError"){
 456
 457                         # A database error has occured so return an error with
 458                         # the extended error information.
 459
 460                         xestiascan_error("autherror", $main::xestiascan_authmodule->geterror(1));
 461
 462                 }
 463
 464                 # Write a message saying that the user has been added.
 465
 466                 $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{useradded}, { Style => "pageheader" });
 467                 $main::xestiascan_presmodule->addlinebreak();
 468                 $main::xestiascan_presmodule->addlinebreak();
 469                 $main::xestiascan_presmodule->addtext(xestiascan_language($main::xestiascan_lang{users}{useraddedtolist}, xestiascan_utf8convert($username)));
 470                 $main::xestiascan_presmodule->addlinebreak();
 471                 $main::xestiascan_presmodule->addlinebreak();
 472                 $main::xestiascan_presmodule->addlink($main::xestiascan_env{"script_filename"} . "?mode=users", { Text => $main::xestiascan_lang{users}{returnuserlist} });
 473
 474
 475                 return $main::xestiascan_presmodule->grab();
 476
 477         }
 478
 479         # Disconnect from the database server.
 480
 481         $main::xestiascan_authmodule->disconnect();
 482
 483         # As there is no username value, print a form for adding a user.
 484
 485         # Get the list of available scanners.
 486
 487         my %scannerlist;
 488         my $scanner;
 489
 490         tie(%scannerlist, 'Tie::IxHash');
 491
 492         foreach $scanner (Sane->get_devices){
 493                 $scannerlist{$scanner->{'name'}}{name}          = $scanner->{'name'};
 494                 $scannerlist{$scanner->{'name'}}{model}         = $scanner->{'model'};
 495                 $scannerlist{$scanner->{'name'}}{vendor}        = $scanner->{'vendor'};
 496         }
 497
 498         # Get the list of available output modules.
 499
 500         my @availableoutputmodules;
 501         @availableoutputmodules = xestiascan_scan_getoutputmodules;
 502
 503         # Get the list of available export modules.
 504
 505         my @availableexportmodules;
 506         @availableexportmodules = xestiascan_scan_getexportmodules;
 507
 508         # Print out the form for editing the user.
 509
 510         $main::xestiascan_presmodule->startbox("sectionboxnofloat");
 511         $main::xestiascan_presmodule->startbox("sectiontitle");
 512         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{adduser});
 513         $main::xestiascan_presmodule->endbox();
 514         $main::xestiascan_presmodule->startbox("secondbox");
 515
 516         $main::xestiascan_presmodule->startform($main::xestiascan_env{"script_filename"}, "POST");
 517         $main::xestiascan_presmodule->addhiddendata("mode", "users");
 518         $main::xestiascan_presmodule->addhiddendata("action", "add");
 519         $main::xestiascan_presmodule->addhiddendata("confirm", "1");
 520
 521         # Process the user information.
 522
 523         $main::xestiascan_presmodule->addboldtext($main::xestiascan_lang{users}{userdetails});
 524
 525         $main::xestiascan_presmodule->addlinebreak();
 526         $main::xestiascan_presmodule->addlinebreak();
 527
 528         $main::xestiascan_presmodule->starttable("", { CellPadding => "5", CellSpacing => "0" });
 529         $main::xestiascan_presmodule->startheader();
 530         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{common}{setting}, { Style => "tablecellheader" });
 531         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{common}{value}, { Style => "tablecellheader" });
 532         $main::xestiascan_presmodule->endheader();
 533
 534         $main::xestiascan_presmodule->startrow();
 535         $main::xestiascan_presmodule->addcell("tablecell1");
 536         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{username});
 537         $main::xestiascan_presmodule->endcell();
 538         $main::xestiascan_presmodule->addcell("tablecell1");
 539         $main::xestiascan_presmodule->addinputbox("username", { MaxLength => "64", Size => "32"});
 540         $main::xestiascan_presmodule->endcell();
 541         $main::xestiascan_presmodule->endrow();
 542
 543         $main::xestiascan_presmodule->startrow();
 544         $main::xestiascan_presmodule->addcell("tablecell2");
 545         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{name});
 546         $main::xestiascan_presmodule->endcell();
 547         $main::xestiascan_presmodule->addcell("tablecell2");
 548         $main::xestiascan_presmodule->addinputbox("name", { MaxLength => "128", Size => "32" });
 549         $main::xestiascan_presmodule->endcell();
 550         $main::xestiascan_presmodule->endrow();
 551
 552         $main::xestiascan_presmodule->startrow();
 553         $main::xestiascan_presmodule->addcell("tablecell1");
 554         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{adminprivs});
 555         $main::xestiascan_presmodule->endcell();
 556         $main::xestiascan_presmodule->addcell("tablecell1");
 557         $main::xestiascan_presmodule->addcheckbox("admin");
 558         $main::xestiascan_presmodule->endcell();
 559         $main::xestiascan_presmodule->endrow();
 560
 561         $main::xestiascan_presmodule->startrow();
 562         $main::xestiascan_presmodule->addcell("tablecell2");
 563         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{accountenabled});
 564         $main::xestiascan_presmodule->endcell();
 565         $main::xestiascan_presmodule->addcell("tablecell2");
 566         $main::xestiascan_presmodule->addcheckbox("enabled");
 567         $main::xestiascan_presmodule->endcell();
 568         $main::xestiascan_presmodule->endrow();
 569
 570         $main::xestiascan_presmodule->startrow();
 571         $main::xestiascan_presmodule->addcell("tablecell1");
 572         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{password});
 573         $main::xestiascan_presmodule->endcell();
 574         $main::xestiascan_presmodule->addcell("tablecell1");
 575         $main::xestiascan_presmodule->addinputbox("password", { MaxLength => "256", Size => "32", Password => 1 });
 576         $main::xestiascan_presmodule->endcell();
 577         $main::xestiascan_presmodule->endrow();
 578
 579         $main::xestiascan_presmodule->startrow();
 580         $main::xestiascan_presmodule->addcell("tablecell2");
 581         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{confirmpassword});
 582         $main::xestiascan_presmodule->endcell();
 583         $main::xestiascan_presmodule->addcell("tablecell2");
 584         $main::xestiascan_presmodule->addinputbox("confirmpassword", { MaxLength => "256", Size => "32", Password => 1 });
 585         $main::xestiascan_presmodule->endcell();
 586         $main::xestiascan_presmodule->endrow();
 587
 588         $main::xestiascan_presmodule->endtable();
 589
 590
 591         $main::xestiascan_presmodule->addlinebreak();
 592
 593         # Process the list of available scanners.
 594
 595         $main::xestiascan_presmodule->addboldtext($main::xestiascan_lang{users}{scannerlist});
 596         $main::xestiascan_presmodule->addlinebreak();
 597         $main::xestiascan_presmodule->addlinebreak();
 598
 599         $main::xestiascan_presmodule->starttable("", { CellPadding => "5", CellSpacing => "0" });
 600         $main::xestiascan_presmodule->startheader();
 601         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{scannername}, { Style => "tablecellheader" });
 602         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{allowaccess}, { Style => "tablecellheader" });
 603         $main::xestiascan_presmodule->endheader();
 604
 605         my $scannername;
 606         my $cssname = "";
 607         my $cssstyle = 0;
 608         my @connectedscanners;
 609
 610         # Process the list of connected scanners.
 611
 612         foreach $scannername (keys %scannerlist){
 613
 614                 $main::xestiascan_presmodule->startrow();
 615
 616                 # Setup the styling for the row.
 617
 618                 if ($cssstyle eq 0){
 619
 620                         $cssname = "tablecell1";
 621                         $cssstyle = 1;
 622
 623                 } else {
 624
 625                         $cssname = "tablecell2";
 626                         $cssstyle = 0;
 627
 628                 }
 629
 630                 # Add the name of the scanner.
 631
 632                 $main::xestiascan_presmodule->addcell($cssname);
 633                 $main::xestiascan_presmodule->addboldtext($scannerlist{$scannername}{vendor} . " " . $scannerlist{$scannername}{model});
 634                 $main::xestiascan_presmodule->addlinebreak();
 635                 $main::xestiascan_presmodule->additalictext($scannerlist{$scannername}{name});
 636                 $main::xestiascan_presmodule->endcell();
 637
 638                 # See if it has permissions (or not) to use the scanner.
 639
 640                 $main::xestiascan_presmodule->addcell($cssname);
 641
 642                 $main::xestiascan_presmodule->addcheckbox("scanner_" . $scannerlist{$scannername}{name}, { Checked => 0 });
 643
 644                 $main::xestiascan_presmodule->endcell();
 645
 646                 push(@connectedscanners, $scannername);
 647
 648                 $main::xestiascan_presmodule->endrow();
 649
 650         }
 651
 652         $main::xestiascan_presmodule->endtable();
 653
 654         $main::xestiascan_presmodule->addlinebreak();
 655
 656         $main::xestiascan_presmodule->addboldtext($main::xestiascan_lang{users}{outputmodulelist});
 657         $main::xestiascan_presmodule->addlinebreak();
 658         $main::xestiascan_presmodule->addlinebreak();
 659
 660         $main::xestiascan_presmodule->starttable("", { CellPadding => "5", CellSpacing => "0" });
 661         $main::xestiascan_presmodule->startheader();
 662         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{modulename}, { Style => "tablecellheader" });
 663         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{allowaccess}, { Style => "tablecellheader" });
 664         $main::xestiascan_presmodule->endheader();
 665
 666         my $outputmodulename;
 667         my $outputmoduleavailable = 0;
 668         my $outputmoduleavailname;
 669         $cssstyle = 0;
 670
 671         # Process the list of available user output modules.
 672
 673         foreach $outputmodulename (@availableoutputmodules){
 674
 675                 # Check if the module is in the list of available
 676                 # output modules, otherwise mark as not available.
 677
 678                 # Setup the styling for the row.
 679
 680                 if ($cssstyle eq 0){
 681
 682                         $cssname = "tablecell1";
 683                         $cssstyle = 1;
 684
 685                 } else {
 686
 687                         $cssname = "tablecell2";
 688                         $cssstyle = 0;
 689
 690                 }
 691
 692                 $main::xestiascan_presmodule->addcell($cssname);
 693                 $main::xestiascan_presmodule->addtext($outputmodulename);
 694                 $main::xestiascan_presmodule->endcell();
 695
 696                 $main::xestiascan_presmodule->addcell($cssname);
 697
 698                 $main::xestiascan_presmodule->addcheckbox("outputmodule_" . $outputmodulename, { Checked => 0 });
 699
 700                 $main::xestiascan_presmodule->endcell();
 701
 702                 $main::xestiascan_presmodule->endrow();
 703
 704         }
 705
 706         $main::xestiascan_presmodule->endtable();
 707
 708         $main::xestiascan_presmodule->addlinebreak();
 709
 710         $main::xestiascan_presmodule->addboldtext($main::xestiascan_lang{users}{exportmodulelist});
 711         $main::xestiascan_presmodule->addlinebreak();
 712         $main::xestiascan_presmodule->addlinebreak();
 713
 714         $main::xestiascan_presmodule->starttable("", { CellPadding => "5", CellSpacing => "0" });
 715         $main::xestiascan_presmodule->startheader();
 716         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{modulename}, { Style => "tablecellheader" });
 717         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{allowaccess}, { Style => "tablecellheader" });
 718         $main::xestiascan_presmodule->endheader();
 719
 720         my $exportmodulename;
 721         my $exportmoduleavailable = 0;
 722         my $exportmoduleavailname;
 723         $cssstyle = 0;
 724
 725         # Process the list of available user export modules.
 726
 727         foreach $exportmodulename (@availableexportmodules){
 728
 729                 # Setup the styling for the row.
 730
 731                 if ($cssstyle eq 0){
 732
 733                         $cssname = "tablecell1";
 734                         $cssstyle = 1;
 735
 736                 } else {
 737
 738                         $cssname = "tablecell2";
 739                         $cssstyle = 0;
 740
 741                 }
 742
 743                 $main::xestiascan_presmodule->addcell($cssname);
 744                 $main::xestiascan_presmodule->addtext($exportmodulename);
 745                 $main::xestiascan_presmodule->endcell();
 746
 747                 $main::xestiascan_presmodule->addcell($cssname);
 748
 749                 $main::xestiascan_presmodule->addcheckbox("exportmodule_" . $exportmodulename, { Checked => 0 });
 750
 751                 $main::xestiascan_presmodule->endcell();
 752
 753                 $main::xestiascan_presmodule->endrow();
 754
 755         }
 756
 757         $main::xestiascan_presmodule->endtable();
 758
 759         $main::xestiascan_presmodule->addlinebreak();
 760
 761         $main::xestiascan_presmodule->addsubmit($main::xestiascan_lang{users}{adduserbutton});
 762         $main::xestiascan_presmodule->addtext(" | ");
 763         $main::xestiascan_presmodule->addreset($main::xestiascan_lang{common}{clearvalues});
 764
 765         $main::xestiascan_presmodule->endform();
 766
 767         $main::xestiascan_presmodule->endbox();
 768         $main::xestiascan_presmodule->endbox();
 769
 770         return $main::xestiascan_presmodule->grab();
 771
 772 }
 773
 774 sub xestiascan_users_edit{
 775 #################################################################################
 776 # xestiascan_users_edit: Edit a user in the user list.                          #
 777 #                                                                               #
 778 # Usage:                                                                        #
 779 #                                                                               #
 780 # xestiascan_users_edit(username, userinfo, scannerinfo, outputmoduleinfo,      #
 781 #                       exportmoduleinfo, confirm);                             #
 782 #                                                                               #
 783 # username              Specifies the username to edit.                         #
 784 # userinfo              Specifies the user information as a hash.               #
 785 # scannerinfo           Specifies the scanner information as a hash.            #
 786 # outputmoduleinfo      Specifies the output module information as a hash.      #
 787 # exportmoduleinfo      Specifies the export module information as a hash.      #
 788 # confirm               Specifies if the action to edit has been confirmed.     #
 789 #################################################################################
 790
 791         my $username    = shift;
 792
 793         my $passed_userinfo             = shift;
 794         my $passed_scannerinfo          = shift;
 795         my $passed_outputmoduleinfo     = shift;
 796         my $passed_exportmoduleinfo     = shift;
 797
 798         my $confirm = shift;
 799
 800         if (!$username){
 801
 802                 # Username is blank so return an error.
 803
 804                 xestiascan_error("usernameblank");
 805
 806         }
 807
 808         if (!$confirm){
 809
 810                 $confirm = 0;
 811
 812         }
 813
 814         # Check to see if the username is valid.
 815
 816         xestiascan_variablecheck(xestiascan_utf8convert($username), "utf8", 0, 0);
 817
 818         my $username_maxlength_check = xestiascan_variablecheck(xestiascan_utf8convert($username), "maxlength", 64, 1);
 819
 820         if ($username_maxlength_check eq 1){
 821
 822                 # Username is too long so return an error.
 823
 824                 xestiascan_error("usernametoolong");
 825
 826         }
 827
 828         # Connect to the database server.
 829
 830         $main::xestiascan_authmodule->connect();
 831
 832         # Check if any errors occured while connecting to the database server.
 833
 834         if ($main::xestiascan_authmodule->geterror eq "AuthConnectionError"){
 835
 836                 # A database connection error has occured so return
 837                 # an error.
 838
 839                 xestiascan_error("authconnectionerror", $main::xestiascan_authmodule->geterror(1));
 840
 841         }
 842
 843         # Check to see if the user has permission to manage users.
 844
 845         my $access_userlist = $main::xestiascan_authmodule->getpermissions({ Username => $main::loggedin_user, PermissionType => "Admin" });
 846
 847         xestiascan_error("usernameblank") if ($main::xestiascan_authmodule->geterror eq "UsernameBlank");
 848         xestiascan_error("permissiontypeblank") if ($main::xestiascan_authmodule->geterror eq "PermissionTypeBlank");
 849         xestiascan_error("autherror", $main::xestiascan_authmodule->geterror(1)) if ($main::xestiascan_authmodule->geterror eq "DatabaseError");
 850
 851         if ($access_userlist ne 1){
 852
 853                 # User not allowed to access the user list so return an error.
 854                 xestiascan_error("notpermitted");
 855
 856         }
 857
 858
 859         # Check to see if the action to edit the user has been confirmed and
 860         # if it has then edit the user.
 861
 862         if ($confirm eq 1){
 863
 864                 my %final_userinfo              = ();
 865                 my %final_scannerinfo           = ();
 866                 my %final_outputmoduleinfo      = ();
 867                 my %final_exportmoduleinfo      = ();
 868                 my $hashkey;
 869                 my $hashkey_short;
 870
 871                 # De-reference the user information hash.
 872
 873                 $hashkey = "";
 874
 875                 foreach $hashkey (keys %$passed_userinfo){
 876
 877                         $final_userinfo{$hashkey} = $$passed_userinfo{$hashkey};
 878
 879                 }
 880
 881                 # De-reference the scanner information hash.
 882
 883                 $hashkey = "";
 884                 $hashkey_short = "";
 885
 886                 foreach $hashkey (keys %$passed_scannerinfo){
 887
 888                         $hashkey_short = $hashkey;
 889                         $hashkey_short =~ s/^scanner_//g;
 890
 891                         $final_scannerinfo{$hashkey_short} = $$passed_scannerinfo{$hashkey};
 892
 893                 }
 894
 895                 # De-reference the output module information hash.
 896
 897                 $hashkey = "";
 898                 $hashkey_short = "";
 899
 900                 foreach $hashkey (keys %$passed_outputmoduleinfo){
 901
 902                         $hashkey_short = $hashkey;
 903                         $hashkey_short =~ s/^outputmodule_//g;
 904
 905                         $final_outputmoduleinfo{$hashkey_short} = $$passed_outputmoduleinfo{$hashkey};
 906
 907                 }
 908
 909                 # De-reference the export module information hash.
 910
 911                 $hashkey = "";
 912                 $hashkey_short = "";
 913
 914                 foreach $hashkey (keys %$passed_exportmoduleinfo){
 915
 916                         $hashkey_short = $hashkey;
 917                         $hashkey_short =~ s/^exportmodule_//g;
 918
 919                         $final_exportmoduleinfo{$hashkey_short} = $$passed_exportmoduleinfo{$hashkey};
 920
 921                 }
 922
 923                 # Check if the username and password are blank and if they are
 924                 # then return an error.
 925
 926                 if (!$username){
 927
 928                         xestiascan_error("usernameblank");
 929
 930                 }
 931
 932                 # Check if the password matches with the confirm password value
 933                 # and return an error if this is not the case.
 934
 935                 if ($final_userinfo{Password} ne $final_userinfo{ConfirmPassword}){
 936
 937                         xestiascan_error("passwordsdonotmatch");
 938
 939                 }
 940
 941                 # Check all the values being passed to this subroutine are UTF-8
 942                 # valid.
 943
 944                 xestiascan_variablecheck(xestiascan_utf8convert($username), "utf8", 0, 0);
 945                 xestiascan_variablecheck(xestiascan_utf8convert($final_userinfo{NewUsername}), "utf8", 0, 0);
 946                 xestiascan_variablecheck(xestiascan_utf8convert($final_userinfo{Name}), "utf8", 0, 0);
 947                 xestiascan_variablecheck(xestiascan_utf8convert($final_userinfo{Password}), "utf8", 0, 0);
 948
 949                 # Check the length of the username, name and password to make sure
 950                 # they are valid.
 951
 952                 my $username_maxlength_check = xestiascan_variablecheck(xestiascan_utf8convert($username), "maxlength", 64, 1);
 953                 my $newusername_maxlength_check = xestiascan_variablecheck(xestiascan_utf8convert($final_userinfo{NewUsername}), "maxlength", 32, 1);
 954                 my $name_maxlength_check = xestiascan_variablecheck(xestiascan_utf8convert($final_userinfo{Name}), "maxlength", 256, 1);
 955                 my $password_maxlength_check = xestiascan_variablecheck(xestiascan_utf8convert($final_userinfo{Password}), "maxlength", 128, 1);
 956
 957                 if ($username_maxlength_check eq 1){
 958
 959                         # Username is too long so return an error.
 960
 961                         xestiascan_error("usernametoolong");
 962
 963                 }
 964
 965                 if ($name_maxlength_check eq 1){
 966
 967                         # Name is too long so return an error.
 968
 969                         xestiascan_error("nametoolong");
 970
 971                 }
 972
 973                 if ($password_maxlength_check eq 1){
 974
 975                         # Password is too long so return an error,
 976
 977                         xestiascan_error("passwordtoolong");
 978
 979                 }
 980
 981                 my $final_scanner;
 982
 983                 foreach $final_scanner (keys %final_scannerinfo){
 984
 985                         # Check to make sure that the scanner name and value
 986                         # are both valid UTF8.
 987
 988                         xestiascan_variablecheck($final_scanner, "utf8", 0, 0);
 989                         xestiascan_variablecheck($final_scannerinfo{$final_scanner}, "utf8", 0, 0);
 990
 991                 }
 992
 993                 # Check that the export and output modules contain valid UTF8
 994                 # and are valid filenames.
 995
 996                 my $final_module;
 997                 my $module_lettersnumbers_check;
 998
 999                 foreach $final_module (keys %final_outputmoduleinfo){
1000
1001                         xestiascan_variablecheck($final_module, "utf8", 0, 0);
1002                         xestiascan_variablecheck($final_outputmoduleinfo{$final_module}, "utf8", 0, 0);
1003
1004                         $module_lettersnumbers_check = xestiascan_variablecheck($final_module, "lettersnumbers", 0, 1);
1005                         xestiascan_error("moduleinvalid", xestiascan_language($main::xestiascan_lang{scan}{nameofoutputmoduleerror}, $final_module)) if $module_lettersnumbers_check eq 1;
1006
1007                 }
1008
1009                 $final_module = "";
1010                 $module_lettersnumbers_check = 0;
1011
1012                 foreach $final_module (keys %final_exportmoduleinfo){
1013
1014                         xestiascan_variablecheck($final_module, "utf8", 0, 0);
1015                         xestiascan_variablecheck($final_exportmoduleinfo{$final_module}, "utf8", 0, 0);
1016
1017                         $module_lettersnumbers_check = xestiascan_variablecheck($final_module, "lettersnumbers", 0, 1);
1018                         xestiascan_error("moduleinvalid", xestiascan_language($main::xestiascan_lang{scan}{nameofexportmoduleerror}, $final_module)) if $module_lettersnumbers_check eq 1;
1019
1020                 }
1021
1022                 # Get the list of available scanners.
1023
1024                 my %scannerlist;
1025                 my $scanner;
1026
1027                 tie(%scannerlist, 'Tie::IxHash');
1028
1029                 foreach $scanner (Sane->get_devices){
1030                         $scannerlist{$scanner->{'name'}}{name}          = $scanner->{'name'};
1031                         $scannerlist{$scanner->{'name'}}{model}         = $scanner->{'model'};
1032                         $scannerlist{$scanner->{'name'}}{vendor}        = $scanner->{'vendor'};
1033                 }
1034
1035                 # Get the list of available output modules.
1036
1037                 my @availableoutputmodules;
1038                 @availableoutputmodules = xestiascan_scan_getoutputmodules;
1039
1040                 # Get the list of available export modules.
1041
1042                 my @availableexportmodules;
1043                 @availableexportmodules = xestiascan_scan_getexportmodules;
1044
1045                 # Pass the permissions to the edituser subroutine
1046                 # for the authentication module.
1047
1048                 $main::xestiascan_authmodule->edituser($username, "User", %final_userinfo);
1049
1050                 if ($main::xestiascan_authmodule->geterror eq "DatabaseError"){
1051
1052                         xestiascan_error("userediterror", $main::xestiascan_authmodule->geterror(1));
1053
1054                 }
1055
1056                 $main::xestiascan_authmodule->edituser($username, "Scanner", %final_scannerinfo);
1057
1058                 if ($main::xestiascan_authmodule->geterror eq "DatabaseError"){
1059
1060                         xestiascan_error("userediterror", $main::xestiascan_authmodule->geterror(1));
1061
1062                 }
1063
1064                 $main::xestiascan_authmodule->edituser($username, "OutputModule", %final_outputmoduleinfo);
1065
1066                 if ($main::xestiascan_authmodule->geterror eq "DatabaseError"){
1067
1068                         xestiascan_error("userediterror", $main::xestiascan_authmodule->geterror(1));
1069
1070                 }
1071
1072                 $main::xestiascan_authmodule->edituser($username, "ExportModule", %final_exportmoduleinfo);
1073
1074                 if ($main::xestiascan_authmodule->geterror eq "DatabaseError"){
1075
1076                         xestiascan_error("userediterror", $main::xestiascan_authmodule->geterror(1));
1077
1078                 }
1079
1080                 $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{useredited}, { Style => "pageheader" });
1081                 $main::xestiascan_presmodule->addlinebreak();
1082                 $main::xestiascan_presmodule->addlinebreak();
1083                 $main::xestiascan_presmodule->addtext(xestiascan_language($main::xestiascan_lang{users}{usereditedsuccess}, xestiascan_utf8convert($username))) ;
1084                 $main::xestiascan_presmodule->addlinebreak();
1085                 $main::xestiascan_presmodule->addlinebreak();
1086                 $main::xestiascan_presmodule->addlink($main::xestiascan_env{"script_filename"} . "?mode=users", { Text => $main::xestiascan_lang{users}{returnuserlist} });
1087
1088                 return $main::xestiascan_presmodule->grab();
1089
1090         }
1091
1092
1093         # Get the general information about the user.
1094
1095         my %userinfo;
1096
1097         %userinfo = $main::xestiascan_authmodule->getpermissions({ Username => xestiascan_utf8convert($username), PermissionType => "UserInfo" });
1098
1099         xestiascan_error("usernameblank") if ($main::xestiascan_authmodule->geterror eq "UsernameBlank");
1100         xestiascan_error("permissiontypeblank") if ($main::xestiascan_authmodule->geterror eq "PermissionTypeBlank");
1101         xestiascan_error("autherror", $main::xestiascan_authmodule->geterror(1)) if ($main::xestiascan_authmodule->geterror eq "DatabaseError");
1102
1103         # Get the list of scanners with permissions for the user.
1104
1105         my %userscannerinfo;
1106
1107         %userscannerinfo = $main::xestiascan_authmodule->getpermissions({ Username => xestiascan_utf8convert($username), PermissionType => "Scanner" });
1108
1109         xestiascan_error("usernameblank") if ($main::xestiascan_authmodule->geterror eq "UsernameBlank");
1110         xestiascan_error("permissiontypeblank") if ($main::xestiascan_authmodule->geterror eq "PermissionTypeBlank");
1111         xestiascan_error("autherror", $main::xestiascan_authmodule->geterror(1)) if ($main::xestiascan_authmodule->geterror eq "DatabaseError");
1112
1113         # Get the list of output modules with permissions for the user.
1114
1115         my %useroutputinfo;
1116
1117         %useroutputinfo = $main::xestiascan_authmodule->getpermissions({ Username => xestiascan_utf8convert($username), PermissionType => "OutputModule" });
1118
1119         xestiascan_error("usernameblank") if ($main::xestiascan_authmodule->geterror eq "UsernameBlank");
1120         xestiascan_error("permissiontypeblank") if ($main::xestiascan_authmodule->geterror eq "PermissionTypeBlank");
1121         xestiascan_error("autherror", $main::xestiascan_authmodule->geterror(1)) if ($main::xestiascan_authmodule->geterror eq "DatabaseError");
1122
1123         # Get the list of export modules with permissions for the user.
1124
1125         my %userexportinfo;
1126
1127         %userexportinfo = $main::xestiascan_authmodule->getpermissions({ Username => xestiascan_utf8convert($username), PermissionType => "ExportModule" });
1128
1129         xestiascan_error("usernameblank") if ($main::xestiascan_authmodule->geterror eq "UsernameBlank");
1130         xestiascan_error("permissiontypeblank") if ($main::xestiascan_authmodule->geterror eq "PermissionTypeBlank");
1131         xestiascan_error("autherror", $main::xestiascan_authmodule->geterror(1)) if ($main::xestiascan_authmodule->geterror eq "DatabaseError");
1132
1133         # Get the list of available scanners.
1134
1135         my %scannerlist;
1136         my $scanner;
1137
1138         tie(%scannerlist, 'Tie::IxHash');
1139
1140         foreach $scanner (Sane->get_devices){
1141                 $scannerlist{$scanner->{'name'}}{name}          = $scanner->{'name'};
1142                 $scannerlist{$scanner->{'name'}}{model}         = $scanner->{'model'};
1143                 $scannerlist{$scanner->{'name'}}{vendor}        = $scanner->{'vendor'};
1144         }
1145
1146         # Get the list of available output modules.
1147
1148         my @availableoutputmodules;
1149         @availableoutputmodules = xestiascan_scan_getoutputmodules;
1150
1151         # Get the list of available export modules.
1152
1153         my @availableexportmodules;
1154         @availableexportmodules = xestiascan_scan_getexportmodules;
1155
1156         # Print out the form for editing the user.
1157
1158         $main::xestiascan_presmodule->startbox("sectionboxnofloat");
1159         $main::xestiascan_presmodule->startbox("sectiontitle");
1160         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{edituser});
1161         $main::xestiascan_presmodule->endbox();
1162         $main::xestiascan_presmodule->startbox("secondbox");
1163
1164         $main::xestiascan_presmodule->startform($main::xestiascan_env{"script_filename"}, "POST");
1165         $main::xestiascan_presmodule->addhiddendata("mode", "users");
1166         $main::xestiascan_presmodule->addhiddendata("action", "edit");
1167         $main::xestiascan_presmodule->addhiddendata("confirm", "1");
1168         $main::xestiascan_presmodule->addhiddendata("username_original", xestiascan_utf8convert($username));
1169
1170         # Process the user information.
1171
1172         $main::xestiascan_presmodule->addboldtext($main::xestiascan_lang{users}{userdetails});
1173
1174         $main::xestiascan_presmodule->addlinebreak();
1175         $main::xestiascan_presmodule->addlinebreak();
1176
1177         $main::xestiascan_presmodule->starttable("", { CellPadding => "5", CellSpacing => "0" });
1178         $main::xestiascan_presmodule->startheader();
1179         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{common}{setting}, { Style => "tablecellheader" });
1180         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{common}{value}, { Style => "tablecellheader" });
1181         $main::xestiascan_presmodule->endheader();
1182
1183         $main::xestiascan_presmodule->startrow();
1184         $main::xestiascan_presmodule->addcell("tablecell1");
1185         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{username});
1186         $main::xestiascan_presmodule->endcell();
1187         $main::xestiascan_presmodule->addcell("tablecell1");
1188         $main::xestiascan_presmodule->addinputbox("username", { MaxLength => "64", Size => "32", Value => $userinfo{Username} });
1189         $main::xestiascan_presmodule->endcell();
1190         $main::xestiascan_presmodule->endrow();
1191
1192         $main::xestiascan_presmodule->startrow();
1193         $main::xestiascan_presmodule->addcell("tablecell2");
1194         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{name});
1195         $main::xestiascan_presmodule->endcell();
1196         $main::xestiascan_presmodule->addcell("tablecell2");
1197         $main::xestiascan_presmodule->addinputbox("name", { MaxLength => "128", Size => "32", Value => $userinfo{Name} });
1198         $main::xestiascan_presmodule->endcell();
1199         $main::xestiascan_presmodule->endrow();
1200
1201         $main::xestiascan_presmodule->startrow();
1202         $main::xestiascan_presmodule->addcell("tablecell1");
1203         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{adminprivs});
1204         $main::xestiascan_presmodule->endcell();
1205         $main::xestiascan_presmodule->addcell("tablecell1");
1206         $main::xestiascan_presmodule->addcheckbox("admin", { Checked => $userinfo{Admin} });
1207         $main::xestiascan_presmodule->endcell();
1208         $main::xestiascan_presmodule->endrow();
1209
1210         $main::xestiascan_presmodule->startrow();
1211         $main::xestiascan_presmodule->addcell("tablecell2");
1212         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{accountenabled});
1213         $main::xestiascan_presmodule->endcell();
1214         $main::xestiascan_presmodule->addcell("tablecell2");
1215         $main::xestiascan_presmodule->addcheckbox("enabled", { Checked => $userinfo{Enabled} });
1216         $main::xestiascan_presmodule->endcell();
1217         $main::xestiascan_presmodule->endrow();
1218
1219         $main::xestiascan_presmodule->startrow();
1220         $main::xestiascan_presmodule->addcell("tablecell1");
1221         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{newpassword});
1222         $main::xestiascan_presmodule->endcell();
1223         $main::xestiascan_presmodule->addcell("tablecell1");
1224         $main::xestiascan_presmodule->addinputbox("password", { MaxLength => "256", Size => "32", Password => 1 });
1225         $main::xestiascan_presmodule->endcell();
1226         $main::xestiascan_presmodule->endrow();
1227
1228         $main::xestiascan_presmodule->startrow();
1229         $main::xestiascan_presmodule->addcell("tablecell2");
1230         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{confirmnewpassword});
1231         $main::xestiascan_presmodule->endcell();
1232         $main::xestiascan_presmodule->addcell("tablecell2");
1233         $main::xestiascan_presmodule->addinputbox("confirmpassword", { MaxLength => "256", Size => "32", Password => 1 });
1234         $main::xestiascan_presmodule->endcell();
1235         $main::xestiascan_presmodule->endrow();
1236
1237         $main::xestiascan_presmodule->endtable();
1238
1239
1240         $main::xestiascan_presmodule->addlinebreak();
1241
1242         # Process the list of available scanners.
1243
1244         $main::xestiascan_presmodule->addboldtext($main::xestiascan_lang{users}{scannerlist});
1245         $main::xestiascan_presmodule->addlinebreak();
1246         $main::xestiascan_presmodule->addlinebreak();
1247
1248         $main::xestiascan_presmodule->starttable("", { CellPadding => "5", CellSpacing => "0" });
1249         $main::xestiascan_presmodule->startheader();
1250         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{scannername}, { Style => "tablecellheader" });
1251         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{allowaccess}, { Style => "tablecellheader" });
1252         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{connected}, { Style => "tablecellheader" });
1253         $main::xestiascan_presmodule->endheader();
1254
1255         my $scannername;
1256         my $cssname = "";
1257         my $cssstyle = 0;
1258         my @connectedscanners;
1259
1260         # Process the list of connected scanners.
1261
1262         foreach $scannername (keys %scannerlist){
1263
1264                 $main::xestiascan_presmodule->startrow();
1265
1266                 # Setup the styling for the row.
1267
1268                 if ($cssstyle eq 0){
1269
1270                         $cssname = "tablecell1";
1271                         $cssstyle = 1;
1272
1273                 } else {
1274
1275                         $cssname = "tablecell2";
1276                         $cssstyle = 0;
1277
1278                 }
1279
1280                 # Add the name of the scanner.
1281
1282                 $main::xestiascan_presmodule->addcell($cssname);
1283                 $main::xestiascan_presmodule->addboldtext($scannerlist{$scannername}{vendor} . " " . $scannerlist{$scannername}{model});
1284                 $main::xestiascan_presmodule->addlinebreak();
1285                 $main::xestiascan_presmodule->additalictext($scannerlist{$scannername}{name});
1286                 $main::xestiascan_presmodule->endcell();
1287
1288                 # See if it has permissions (or not) to use the scanner.
1289
1290                 $main::xestiascan_presmodule->addcell($cssname);
1291
1292                 if ($userscannerinfo{$scannername}){
1293
1294                         if ($userscannerinfo{$scannername} eq 1){
1295
1296                                 $main::xestiascan_presmodule->addcheckbox("scanner_" . $scannerlist{$scannername}{name}, { Checked => 1 });
1297
1298                         } else {
1299
1300                                 $main::xestiascan_presmodule->addcheckbox("scanner_" . $scannerlist{$scannername}{name}, { Checked => 0 });
1301
1302                         }
1303
1304                 } else {
1305
1306                         $main::xestiascan_presmodule->addcheckbox("scanner_" . $scannerlist{$scannername}{name}, { Checked => 0 });
1307
1308                 }
1309
1310                 $main::xestiascan_presmodule->endcell();
1311
1312                 # As we are dealing with the connected scanners first,
1313                 # Write 'Yes' for connected.
1314
1315                 $main::xestiascan_presmodule->addcell($cssname);
1316                 $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{devconnected});
1317                 $main::xestiascan_presmodule->endcell();
1318
1319                 push(@connectedscanners, $scannername);
1320
1321                 $main::xestiascan_presmodule->endrow();
1322
1323         }
1324
1325         # Process the list of disconnected scanners.
1326
1327         $scannername = "";
1328         my $duplicatescannername;
1329         my $duplicatescannerfound = 0;
1330
1331         foreach $scannername (keys %userscannerinfo){
1332
1333                 # Check the list of connected scanners and skip
1334                 # this bit if the scanner name matches this list.
1335
1336                 $duplicatescannerfound = 0;
1337
1338                 foreach $duplicatescannername (@connectedscanners){
1339
1340                         if ($duplicatescannername eq $scannername){
1341
1342                                 $duplicatescannerfound = 1;
1343
1344                         }
1345
1346                 }
1347
1348                 next if $duplicatescannerfound eq 1;
1349
1350                 # Setup the styling for the row.
1351
1352                 if ($cssstyle eq 0){
1353
1354                         $cssname = "tablecell1";
1355                         $cssstyle = 1;
1356
1357                 } else {
1358
1359                         $cssname = "tablecell2";
1360                         $cssstyle = 0;
1361
1362                 }
1363
1364                 # Add the name of the scanner.
1365
1366                 $main::xestiascan_presmodule->addcell($cssname);
1367                 $main::xestiascan_presmodule->addboldtext($scannerlist{$scannername}{vendor} . " " . $scannerlist{$scannername}{model});
1368                 $main::xestiascan_presmodule->addlinebreak();
1369                 $main::xestiascan_presmodule->additalictext($scannerlist{$scannername}{name});
1370                 $main::xestiascan_presmodule->endcell();
1371
1372                 # See if it has permissions (or not) to use the scanner.
1373
1374                 $main::xestiascan_presmodule->addcell($cssname);
1375
1376                 if ($userscannerinfo{$scannername}){
1377
1378                         if ($userscannerinfo{$scannername} eq 1){
1379
1380                                 $main::xestiascan_presmodule->addcheckbox("scanner_" . $scannerlist{$scannername}{name}, { Checked => 1 });
1381
1382                         } else {
1383
1384                                 $main::xestiascan_presmodule->addcheckbox("scanner_" . $scannerlist{$scannername}{name}, { Checked => 0 });
1385
1386                         }
1387
1388                 } else {
1389
1390                         $main::xestiascan_presmodule->addcheckbox("scanner_" . $scannerlist{$scannername}{name}, { Checked => 0 });
1391
1392                 }
1393
1394                 $main::xestiascan_presmodule->endcell();
1395
1396                 # As we are dealing with the connected scanners first,
1397                 # Write 'Yes' for connected.
1398
1399                 $main::xestiascan_presmodule->addcell($cssname);
1400                 $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{devdisconnected});
1401                 $main::xestiascan_presmodule->endcell();
1402
1403                 $main::xestiascan_presmodule->endrow();
1404
1405         }
1406
1407         $main::xestiascan_presmodule->endtable();
1408
1409         $main::xestiascan_presmodule->addlinebreak();
1410
1411         $main::xestiascan_presmodule->addboldtext($main::xestiascan_lang{users}{outputmodulelist});
1412         $main::xestiascan_presmodule->addlinebreak();
1413         $main::xestiascan_presmodule->addlinebreak();
1414
1415         $main::xestiascan_presmodule->starttable("", { CellPadding => "5", CellSpacing => "0" });
1416         $main::xestiascan_presmodule->startheader();
1417         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{modulename}, { Style => "tablecellheader" });
1418         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{allowaccess}, { Style => "tablecellheader" });
1419         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{available}, { Style => "tablecellheader" });
1420         $main::xestiascan_presmodule->endheader();
1421
1422         my $outputmodulename;
1423         my $outputmoduleavailable = 0;
1424         my $outputmoduleavailname;
1425         $cssstyle = 0;
1426
1427         # Process the list of available user output modules.
1428
1429         foreach $outputmodulename (@availableoutputmodules){
1430
1431                 # Check if the module is in the list of available
1432                 # output modules, otherwise mark as not available.
1433
1434                 # Setup the styling for the row.
1435
1436                 if ($cssstyle eq 0){
1437
1438                         $cssname = "tablecell1";
1439                         $cssstyle = 1;
1440
1441                 } else {
1442
1443                         $cssname = "tablecell2";
1444                         $cssstyle = 0;
1445
1446                 }
1447
1448                 $main::xestiascan_presmodule->addcell($cssname);
1449                 $main::xestiascan_presmodule->addtext($outputmodulename);
1450                 $main::xestiascan_presmodule->endcell();
1451
1452                 $main::xestiascan_presmodule->addcell($cssname);
1453
1454                 if ($useroutputinfo{$outputmodulename}){
1455
1456                         if ($useroutputinfo{$outputmodulename} eq 1){
1457
1458                                 $main::xestiascan_presmodule->addcheckbox("outputmodule_" . $outputmodulename, { Checked => 1 });
1459
1460                         } else {
1461
1462                                 $main::xestiascan_presmodule->addcheckbox("outputmodule_" . $outputmodulename, { Checked => 0 });
1463
1464                         }
1465
1466                 } else {
1467
1468                         $main::xestiascan_presmodule->addcheckbox("outputmodule_" . $outputmodulename, { Checked => 0 });
1469
1470                 }
1471
1472                 $main::xestiascan_presmodule->endcell();
1473
1474                 $main::xestiascan_presmodule->addcell($cssname);
1475                 $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{modavailable});
1476                 $main::xestiascan_presmodule->endcell();
1477
1478                 $main::xestiascan_presmodule->endrow();
1479
1480         }
1481
1482         # Process the list of not available output modules.
1483
1484         $outputmodulename = "";
1485         my $duplicateoutputmodulename = "";
1486         my $duplicateoutputmodulefound = 0;
1487
1488         foreach $outputmodulename (keys %useroutputinfo){
1489
1490                 # Check the list of available output modules and skip
1491                 # this bit if the output module name matches this list.
1492
1493                 $duplicateoutputmodulefound = 0;
1494
1495                 foreach $duplicateoutputmodulename (@availableoutputmodules){
1496
1497                         if ($duplicateoutputmodulename eq $outputmodulename){
1498
1499                                 $duplicateoutputmodulefound = 1;
1500
1501                         }
1502
1503                 }
1504
1505                 next if $duplicateoutputmodulefound eq 1;
1506
1507                 # Setup the styling for the row.
1508
1509                 if ($cssstyle eq 0){
1510
1511                         $cssname = "tablecell1";
1512                         $cssstyle = 1;
1513
1514                 } else {
1515
1516                         $cssname = "tablecell2";
1517                         $cssstyle = 0;
1518
1519                 }
1520
1521                 $main::xestiascan_presmodule->addcell($cssname);
1522                 $main::xestiascan_presmodule->addtext($outputmodulename);
1523                 $main::xestiascan_presmodule->endcell();
1524
1525                 $main::xestiascan_presmodule->addcell($cssname);
1526
1527                 if ($useroutputinfo{$outputmodulename}){
1528
1529                         if ($useroutputinfo{$outputmodulename} eq 1){
1530
1531                                 $main::xestiascan_presmodule->addcheckbox("outputmodule_" . $outputmodulename, { Checked => 1 });
1532
1533                         } else {
1534
1535                                 $main::xestiascan_presmodule->addcheckbox("outputmodule_" . $outputmodulename, { Checked => 0 });
1536
1537                         }
1538
1539                 } else {
1540
1541                         $main::xestiascan_presmodule->addcheckbox("outputmodule_" . $outputmodulename, { Checked => 0 });
1542
1543                 }
1544
1545                 $main::xestiascan_presmodule->endcell();
1546
1547                 $main::xestiascan_presmodule->addcell($cssname);
1548                 $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{modunavailable});
1549                 $main::xestiascan_presmodule->endcell();
1550
1551                 $main::xestiascan_presmodule->endrow();
1552
1553         }
1554
1555         $main::xestiascan_presmodule->endtable();
1556
1557         $main::xestiascan_presmodule->addlinebreak();
1558
1559         $main::xestiascan_presmodule->addboldtext($main::xestiascan_lang{users}{exportmodulelist});
1560         $main::xestiascan_presmodule->addlinebreak();
1561         $main::xestiascan_presmodule->addlinebreak();
1562
1563         $main::xestiascan_presmodule->starttable("", { CellPadding => "5", CellSpacing => "0" });
1564         $main::xestiascan_presmodule->startheader();
1565         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{modulename}, { Style => "tablecellheader" });
1566         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{allowaccess}, { Style => "tablecellheader" });
1567         $main::xestiascan_presmodule->addheader($main::xestiascan_lang{users}{available}, { Style => "tablecellheader" });
1568         $main::xestiascan_presmodule->endheader();
1569
1570         my $exportmodulename;
1571         my $exportmoduleavailable = 0;
1572         my $exportmoduleavailname;
1573         $cssstyle = 0;
1574
1575         # Process the list of available user export modules.
1576
1577         foreach $exportmodulename (@availableexportmodules){
1578
1579                 # Setup the styling for the row.
1580
1581                 if ($cssstyle eq 0){
1582
1583                         $cssname = "tablecell1";
1584                         $cssstyle = 1;
1585
1586                 } else {
1587
1588                         $cssname = "tablecell2";
1589                         $cssstyle = 0;
1590
1591                 }
1592
1593                 $main::xestiascan_presmodule->addcell($cssname);
1594                 $main::xestiascan_presmodule->addtext($exportmodulename);
1595                 $main::xestiascan_presmodule->endcell();
1596
1597                 $main::xestiascan_presmodule->addcell($cssname);
1598
1599                 if ($userexportinfo{$exportmodulename}){
1600
1601                         if ($userexportinfo{$exportmodulename} eq 1){
1602
1603                                 $main::xestiascan_presmodule->addcheckbox("exportmodule_" . $exportmodulename, { Checked => 1 });
1604
1605                         } else {
1606
1607                                 $main::xestiascan_presmodule->addcheckbox("exportmodule_" . $exportmodulename, { Checked => 0 });
1608
1609                         }
1610
1611                 } else {
1612
1613                         $main::xestiascan_presmodule->addcheckbox("exportmodule_" . $exportmodulename, { Checked => 0 });
1614
1615                 }
1616
1617                 $main::xestiascan_presmodule->endcell();
1618
1619                 $main::xestiascan_presmodule->addcell($cssname);
1620                 $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{modavailable});
1621                 $main::xestiascan_presmodule->endcell();
1622
1623                 $main::xestiascan_presmodule->endrow();
1624
1625         }
1626
1627         # Process the list of not available user export modules.
1628
1629         $exportmodulename = "";
1630         my $duplicateexportmodulename = "";
1631         my $duplicateexportmodulefound = 0;
1632
1633         foreach $exportmodulename (keys %userexportinfo){
1634
1635                 # Check the list of available output modules and skip
1636                 # this bit if the output module name matches this list.
1637
1638                 $duplicateexportmodulefound = 0;
1639
1640                 foreach $duplicateexportmodulename (@availableexportmodules){
1641
1642                         if ($duplicateexportmodulename eq $exportmodulename){
1643
1644                                 $duplicateexportmodulefound = 1;
1645
1646                         }
1647
1648                 }
1649
1650                 next if $duplicateexportmodulefound eq 1;
1651
1652                 # Setup the styling for the row.
1653
1654                 if ($cssstyle eq 0){
1655
1656                         $cssname = "tablecell1";
1657                         $cssstyle = 1;
1658
1659                 } else {
1660
1661                         $cssname = "tablecell2";
1662                         $cssstyle = 0;
1663
1664                 }
1665
1666                 $main::xestiascan_presmodule->addcell($cssname);
1667                 $main::xestiascan_presmodule->addtext($exportmodulename);
1668                 $main::xestiascan_presmodule->endcell();
1669
1670                 $main::xestiascan_presmodule->addcell($cssname);
1671
1672                 if ($userexportinfo{$outputmodulename}){
1673
1674                         if ($userexportinfo{$outputmodulename} eq 1){
1675
1676                                 $main::xestiascan_presmodule->addcheckbox("exportmodule_" . $exportmodulename, { Checked => 1 });
1677
1678                         } else {
1679
1680                                 $main::xestiascan_presmodule->addcheckbox("exportmodule_" . $exportmodulename, { Checked => 0 });
1681
1682                         }
1683
1684                 } else {
1685
1686                         $main::xestiascan_presmodule->addcheckbox("exportmodule_" . $exportmodulename, { Checked => 0 });
1687
1688                 }
1689
1690                 $main::xestiascan_presmodule->endcell();
1691
1692                 $main::xestiascan_presmodule->addcell($cssname);
1693                 $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{modunavailable});
1694                 $main::xestiascan_presmodule->endcell();
1695
1696                 $main::xestiascan_presmodule->endrow();
1697
1698         }
1699
1700         $main::xestiascan_presmodule->endtable();
1701
1702         $main::xestiascan_presmodule->addlinebreak();
1703
1704         # User Information table.
1705
1706         $main::xestiascan_presmodule->addsubmit($main::xestiascan_lang{users}{edituserbutton});
1707         $main::xestiascan_presmodule->addtext(" | ");
1708         $main::xestiascan_presmodule->addreset($main::xestiascan_lang{common}{clearvalues});
1709
1710         $main::xestiascan_presmodule->endform();
1711
1712         $main::xestiascan_presmodule->endbox();
1713         $main::xestiascan_presmodule->endbox();
1714
1715         return $main::xestiascan_presmodule->grab();
1716
1717 }
1718
1719 sub xestiascan_users_delete{
1720 #################################################################################
1721 # xestiascan_users_delete: Delete a user in the user list.                      #
1722 #                                                                               #
1723 # Usage:                                                                        #
1724 #                                                                               #
1725 # xestiascan_users_delete(username, confirm);                                   #
1726 #                                                                               #
1727 # username      Specifies the user to delete.                                   #
1728 # confirm       Confirms if the user should be deleted.                         #
1729 #################################################################################
1730
1731         my $username = shift;
1732         my $confirm = shift;
1733
1734         if (!$confirm){
1735
1736                 $confirm = 0;
1737
1738         }
1739
1740         if (!$username){
1741
1742                 # The username is blank so return an error.
1743
1744                 xestiascan_error("usernameblank");
1745
1746         }
1747
1748         # Connect to the database server.
1749
1750         $main::xestiascan_authmodule->connect();
1751
1752         # Check if any errors occured while connecting to the database server.
1753
1754         if ($main::xestiascan_authmodule->geterror eq "AuthConnectionError"){
1755
1756                 # A database connection error has occured so return
1757                 # an error.
1758
1759                 xestiascan_error("authconnectionerror", $main::xestiascan_authmodule->geterror(1));
1760
1761         }
1762
1763         # Check to see if the user has permission to manage users.
1764
1765         my $access_userlist = $main::xestiascan_authmodule->getpermissions({ Username => $main::loggedin_user, PermissionType => "Admin" });
1766
1767         if ($main::xestiascan_authmodule->geterror eq "DatabaseError"){
1768
1769                 # A database error has occured so return an error with
1770                 # the extended error information.
1771
1772                 xestiascan_error("autherror", $main::xestiascan_authmodule->geterror(1));
1773
1774         }
1775
1776         if ($access_userlist ne 1){
1777
1778                 # User not allowed to access the user list so return an error.
1779                 xestiascan_error("notpermitted");
1780
1781         }
1782
1783         # Check the user name to see if it is valid.
1784
1785         xestiascan_variablecheck($username, "utf8", 0, 0);
1786
1787         my $username_maxlength_check = xestiascan_variablecheck(xestiascan_utf8convert($username), "maxlength", 32, 1);
1788
1789         if ($username_maxlength_check eq 1){
1790
1791                 # Username is too long so return an error.
1792
1793                 xestiascan_error("usernametoolong");
1794
1795         }
1796
1797         # Check to see if the user exists.
1798
1799         $main::xestiascan_authmodule->getpermissions({ Username => $username, PermissionType => "Enabled" });
1800
1801         if ($main::xestiascan_authmodule->geterror eq "DatabaseError"){
1802
1803                 # A database error has occured so return an error with
1804                 # the extended error information.
1805
1806                 xestiascan_error("autherror", $main::xestiascan_authmodule->geterror(1));
1807
1808         }
1809
1810
1811
1812         if ($main::xestiascan_authmodule->geterror eq "UserDoesNotExist"){
1813
1814                 xestiascan_error("usernameinvalid");
1815
1816         }
1817
1818         if ($confirm eq 1){
1819
1820                 # The action to delete the user has been confirmed.
1821
1822                 $main::xestiascan_authmodule->deleteuser($username);
1823
1824                 if ($main::xestiascan_authmodule->geterror eq "DatabaseError"){
1825
1826                         # A database error has occured so return an error with
1827                         # the extended error information.
1828
1829                         xestiascan_error("autherror", $main::xestiascan_authmodule->geterror(1));
1830
1831                 }
1832
1833                 if ($main::xestiascan_authmodule->geterror eq "UserDoesNotExist"){
1834
1835                         xestiascan_error("usernameinvalid");
1836
1837                 }
1838
1839                 # Disconnect from the database server.
1840
1841                 $main::xestiascan_authmodule->disconnect();
1842
1843                 $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{userdeleted}, { Style => "pageheader" });
1844                 $main::xestiascan_presmodule->addlinebreak();
1845                 $main::xestiascan_presmodule->addlinebreak();
1846                 $main::xestiascan_presmodule->addtext(xestiascan_language($main::xestiascan_lang{users}{userdeletedsuccess}, xestiascan_utf8convert($username)));
1847                 $main::xestiascan_presmodule->addlinebreak();
1848                 $main::xestiascan_presmodule->addlinebreak();
1849                 $main::xestiascan_presmodule->addlink($main::xestiascan_env{"script_filename"} . "?mode=users", { Text => $main::xestiascan_lang{users}{returnuserlist} });
1850
1851                 return $main::xestiascan_presmodule->grab();
1852
1853         }
1854
1855         # Disconnect from the database server.
1856
1857         $main::xestiascan_authmodule->disconnect();
1858
1859         # The action to delete the user has not been confirmed so
1860         # write out a form asking the user to confirm it.
1861
1862         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{deleteuser}, { Style => "pageheader" });
1863         $main::xestiascan_presmodule->addlinebreak();
1864         $main::xestiascan_presmodule->addlinebreak();
1865         $main::xestiascan_presmodule->addtext(xestiascan_language($main::xestiascan_lang{users}{deleteuserareyousure}, xestiascan_utf8convert($username)));
1866         $main::xestiascan_presmodule->addlinebreak();
1867         $main::xestiascan_presmodule->addlinebreak();
1868
1869         $main::xestiascan_presmodule->startform($main::xestiascan_env{"script_filename"}, "POST");
1870         $main::xestiascan_presmodule->addhiddendata("mode", "users");
1871         $main::xestiascan_presmodule->addhiddendata("action", "delete");
1872         $main::xestiascan_presmodule->addhiddendata("confirm", "1");
1873         $main::xestiascan_presmodule->addhiddendata("user", xestiascan_utf8convert($username));
1874         $main::xestiascan_presmodule->addsubmit($main::xestiascan_lang{users}{deleteuserbutton});
1875         $main::xestiascan_presmodule->addtext(" | ");
1876         $main::xestiascan_presmodule->addlink($main::xestiascan_env{"script_filename"}  . "?mode=users", { Text => $main::xestiascan_lang{users}{noreturnuserlist} });
1877         $main::xestiascan_presmodule->endform();
1878
1879         return $main::xestiascan_presmodule->grab();
1880
1881 }
1882
1883 sub xestiascan_users_flush{
1884 #################################################################################
1885 # xestiascan_users_flush: Flush the users out of the sessions table.            #
1886 #                                                                               #
1887 # Usage:                                                                        #
1888 #                                                                               #
1889 # xestiascan_users_flush(confirm);                                              #
1890 #                                                                               #
1891 # confirm       Confirms the actions to flush the users out of the sessions     #
1892 #               table.                                                          #
1893 #################################################################################
1894
1895         my $confirm = shift;
1896
1897         if (!$confirm){
1898
1899                 $confirm = 0;
1900
1901         }
1902
1903         # Connect to the database server.
1904
1905         $main::xestiascan_authmodule->connect();
1906
1907         # Check if any errors occured while connecting to the database server.
1908
1909         if ($main::xestiascan_authmodule->geterror eq "AuthConnectionError"){
1910
1911                 # A database connection error has occured so return
1912                 # an error.
1913
1914                 xestiascan_error("authconnectionerror", $main::xestiascan_authmodule->geterror(1));
1915
1916         }
1917
1918         # Check to see if the user has permission to manage users.
1919
1920         my $access_userlist = $main::xestiascan_authmodule->getpermissions({ Username => $main::loggedin_user, PermissionType => "Admin" });
1921
1922         if ($main::xestiascan_authmodule->geterror eq "DatabaseError"){
1923
1924                 # A database error has occured so return an error with
1925                 # the extended error information.
1926
1927                 xestiascan_error("autherror", $main::xestiascan_authmodule->geterror(1));
1928
1929         }
1930
1931         if ($access_userlist ne 1){
1932
1933                 # User not allowed to access the user list so return an error.
1934                 xestiascan_error("notpermitted");
1935
1936                 if ($main::xestiascan_authmodule->geterror eq "DatabaseError"){
1937
1938                         # A database error has occured so return an error with
1939                         # the extended error information.
1940
1941                         xestiascan_error("autherror", $main::xestiascan_authmodule->geterror(1));
1942
1943                 }
1944
1945         }
1946
1947         # Check to see if the action to flush the users from session
1948         # table has been confirmed.
1949
1950         if ($confirm eq 1){
1951
1952                 # Action confirmed, so flush the users table.
1953
1954                 $main::xestiascan_authmodule->flushusers();
1955
1956                 # Check to see if an error occured while flushing the users out of the session table.
1957
1958                 if ($main::xestiascan_authmodule->geterror eq "DatabaseError"){
1959
1960                         # A database error has occured so return an error with
1961                         # the extended error information.
1962
1963                         xestiascan_error("autherror", $main::xestiascan_authmodule->geterror(1));
1964
1965                 }
1966
1967                 $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{logoutallusers}, {Style => "pageheader" });
1968                 $main::xestiascan_presmodule->addlinebreak();
1969                 $main::xestiascan_presmodule->addlinebreak();
1970                 $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{logoutallsuccess});
1971                 $main::xestiascan_presmodule->addlinebreak();
1972                 $main::xestiascan_presmodule->addlinebreak();
1973                 $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{logoutallloginagain});
1974                 $main::xestiascan_presmodule->addlinebreak();
1975                 $main::xestiascan_presmodule->addlinebreak();
1976                 $main::xestiascan_presmodule->addlink($main::xestiascan_env{"script_filename"}, { Text => $main::xestiascan_lang{users}{logoutallcontinue} });
1977
1978                 return $main::xestiascan_presmodule->grab();
1979
1980         }
1981
1982         # Disconnect from server.
1983
1984         $main::xestiascan_authmodule->disconnect();
1985
1986         # The action to flush the users from the session tables has not
1987         # been confirmed so write a message asking for confiramation.
1988
1989         # $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{deleteuser}, { Style => "pageheader" });
1990         # $main::xestiascan_presmodule->addlinebreak();
1991         # $main::xestiascan_presmodule->addlinebreak();
1992         # $main::xestiascan_presmodule->addtext(xestiascan_language($main::xestiascan_lang{users}{deleteuserareyousure}, $username));
1993         # $main::xestiascan_presmodule->addlinebreak();
1994         # $main::xestiascan_presmodule->addlinebreak();
1995
1996         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{logoutallusers}, {Style => "pageheader" });
1997         $main::xestiascan_presmodule->addlinebreak();
1998         $main::xestiascan_presmodule->addlinebreak();
1999         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{logoutallquestion});
2000         $main::xestiascan_presmodule->addlinebreak();
2001         $main::xestiascan_presmodule->addlinebreak();
2002         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{users}{logoutallwarning});
2003         $main::xestiascan_presmodule->addlinebreak();
2004         $main::xestiascan_presmodule->addlinebreak();
2005
2006         $main::xestiascan_presmodule->startform($main::xestiascan_env{"script_filename"}, "POST");
2007         $main::xestiascan_presmodule->addhiddendata("mode", "users");
2008         $main::xestiascan_presmodule->addhiddendata("action", "flush");
2009         $main::xestiascan_presmodule->addhiddendata("confirm", "1");
2010         $main::xestiascan_presmodule->addsubmit($main::xestiascan_lang{users}{logoutallbutton});
2011         $main::xestiascan_presmodule->addtext(" | ");
2012         $main::xestiascan_presmodule->addlink($main::xestiascan_env{"script_filename"}  . "?mode=users", { Text => $main::xestiascan_lang{users}{noreturnuserlist} });
2013         $main::xestiascan_presmodule->endform();
2014
2015         return $main::xestiascan_presmodule->grab();
2016
2017 }