cgi-files/Modules/System/Common.pm

   1 #################################################################################
   2 # Xestia Scanner Server - Common System Module                                  #
   3 # Version 0.1.0                                                                 #
   4 #                                                                               #
   5 # Copyright (C) 2010-2011 Steve Brokenshire <sbrokenshire@xestia.co.uk>         #
   6 #                                                                               #
   7 # This module is licensed under the same license as Xestia Scanner Server which #
   8 # is licensed under the GPL version 3.                                          #
   9 #                                                                               #
  10 # This program is free software: you can redistribute it and/or modify          #
  11 # it under the terms of the GNU General Public License as published by          #
  12 # the Free Software Foundation, version 3 of the License.                       #
  13 #                                                                               #
  14 # This program is distributed in the hope that it will be useful,               #
  15 # but WITHOUT ANY WARRANTY; without even the implied warranty of                #
  16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                 #
  17 # GNU General Public License for more details.                                  #
  18 #                                                                               #
  19 # You should have received a copy of the GNU General Public License             #
  20 # along with this program.  If not, see <http://www.gnu.org/licenses/>.         #
  21 #################################################################################
  22
  23 package Modules::System::Common;
  24
  25 use strict;
  26 use warnings;
  27 use Exporter;
  28 use CGI::Lite;
  29 use MIME::Base64 qw(encode_base64url);
  30
  31 our @ISA = qw(Exporter);
  32 our @EXPORT = qw(xestiascan_initialise xestiascan_settings_load xestiascan_fileexists xestiascan_filepermissions xestiascan_output_header xestiascan_output_page xestiascan_variablecheck xestiascan_processconfig xestiascan_processfilename xestiascan_utf8convert xestiascan_language xestiascan_error);
  33
  34 sub xestiascan_initialise{
  35 #################################################################################
  36 # xestiascan_initialise: Get the enviroment stuff.                              #
  37 #################################################################################
  38
  39         # Get the script filename.
  40
  41         my $env_script_name = $ENV{'SCRIPT_NAME'};
  42
  43         # Process the script filename until there is only the
  44         # filename itself.
  45
  46         my $env_script_name_length = length($env_script_name);
  47         my $filename_seek = 0;
  48         my $filename_char = "";
  49         my $filename_last = 0;
  50
  51         do {
  52                 $filename_char = substr($env_script_name, $filename_seek, 1);
  53                 if ($filename_char eq "/"){
  54                         $filename_last = $filename_seek + 1;
  55                 }
  56                 $filename_seek++;
  57         } until ($filename_seek eq $env_script_name_length || $env_script_name_length eq 0);
  58
  59         my $env_script_name_finallength = $env_script_name_length - $filename_last;
  60         my $script_filename = substr($env_script_name, $filename_last, $env_script_name_finallength);
  61
  62         # Setup the needed enviroment variables for Xestia Scanner Server.
  63
  64         %main::xestiascan_env = (
  65                 "script_filename" => $script_filename,
  66         );
  67
  68 }
  69
  70 sub xestiascan_settings_load{
  71 #################################################################################
  72 # xestiascan_settings_load: Load the configuration settings into the global     #
  73 # variables.                                                                    #
  74 #                                                                               #
  75 # Usage:                                                                        #
  76 #                                                                               #
  77 # xestiascan_settings_load();                                                   #
  78 #################################################################################
  79
  80         # Check if the Xestia Scanner Server configuration file exists before
  81         # using it and return an critical error if it doesn't exist.
  82
  83         my ($xestiascan_settingsfilehandle, @config_data, %config, $config);
  84         my $xestiascan_conf_exist = xestiascan_fileexists("xsdss.cfg");
  85
  86         if ($xestiascan_conf_exist eq 1){
  87
  88                 # The configuration really does not exist so return an critical error.
  89
  90                 xestiascan_critical("configfilemissing");
  91
  92         }
  93
  94         # Check if the Xestia Scanner Server configuration file has valid permission
  95         # settings before using it and return an critical error if it doesn't have the
  96         # valid permission settings.
  97
  98         my $xestiascan_conf_permissions = xestiascan_filepermissions("xsdss.cfg", 1, 0);
  99
 100         if ($xestiascan_conf_permissions eq 1){
 101
 102                 # The permission settings for the Xestia Scanner Server configuration
 103                 # file are invalid, so return an critical error.
 104
 105                 xestiascan_critical("configfileinvalidpermissions");
 106
 107         }
 108
 109         # Converts the file into meaningful data for later on in this subroutine.
 110
 111         my $xestiascan_conf_file = 'xsdss.cfg';
 112
 113         open($xestiascan_settingsfilehandle, $xestiascan_conf_file);
 114         binmode $xestiascan_settingsfilehandle, ':utf8';
 115         @config_data = <$xestiascan_settingsfilehandle>;
 116         %config = xestiascan_processconfig(@config_data);
 117         close($xestiascan_settingsfilehandle);
 118
 119         # Go and fetch the settings and place them into a hash (that is global).
 120
 121         %main::xestiascan_config = (
 122
 123                 "directory_noncgi_images"       => $config{config}{directory_noncgi_images},
 124                 "directory_noncgi_scans"        => $config{config}{directory_noncgi_scans},
 125                 "directory_fs_scans"            => $config{config}{directory_fs_scans},
 126
 127                 "system_language"               => $config{config}{system_language},
 128                 "system_presmodule"             => $config{config}{system_presmodule},
 129                 "system_authmodule"             => $config{config}{system_authmodule},
 130                 "system_outputmodule"           => $config{config}{system_outputmodule},
 131                 "system_datetime"               => $config{config}{system_datetime},
 132
 133                 "database_server"               => $config{config}{database_server},
 134                 "database_port"                 => $config{config}{database_port},
 135                 "database_protocol"             => $config{config}{database_protocol},
 136                 "database_sqldatabase"          => $config{config}{database_sqldatabase},
 137                 "database_username"             => $config{config}{database_username},
 138                 "database_password"             => $config{config}{database_password},
 139                 "database_tableprefix"          => $config{config}{database_tableprefix}
 140
 141         );
 142
 143         # Do a validation check on all of the variables that were loaded into the global configuration hash.
 144
 145         xestiascan_variablecheck($main::xestiascan_config{"directory_noncgi_images"}, "maxlength", 512, 0);
 146         xestiascan_variablecheck($main::xestiascan_config{"directory_noncgi_scans"}, "maxlength", 512, 0);
 147
 148         xestiascan_variablecheck($main::xestiascan_config{"directory_fs_scans"}, "maxlength", 4096, 0);
 149
 150         my $xestiascan_config_language_filename = xestiascan_variablecheck($main::xestiascan_config{"system_language"}, "language_filename", "", 1);
 151         my $xestiascan_config_presmodule_filename = xestiascan_variablecheck($main::xestiascan_config{"system_presmodule"}, "module", 0, 1);
 152         my $xestiascan_config_authmodule_filename = xestiascan_variablecheck($main::xestiascan_config{"system_authmodule"}, "module", 0, 1);
 153         # Check if the language filename is valid and return an critical error if
 154         # they aren't.
 155
 156         if ($xestiascan_config_language_filename eq 1){
 157
 158                 # The language filename is blank so return an critical error.
 159
 160                 xestiascan_critical("languagefilenameblank");
 161
 162         } elsif ($xestiascan_config_language_filename eq 2){
 163
 164                 # The language filename is invalid so return an critical error.
 165
 166                 xestiascan_critical("languagefilenameinvalid");
 167
 168         }
 169
 170         # Check if the presentation and database module names are valid and return a critical
 171         # error if they aren't.
 172
 173         if ($xestiascan_config_presmodule_filename eq 1){
 174
 175                 # The presentation module filename given is blank so return an
 176                 # critical error.
 177
 178                 xestiascan_critical("presmoduleblank");
 179
 180         }
 181
 182         if ($xestiascan_config_presmodule_filename eq 2){
 183
 184                 # The presentation module filename is invalid so return an
 185                 # critical error.
 186
 187                 xestiascan_critical("presmoduleinvalid");
 188
 189         }
 190
 191         if ($xestiascan_config_authmodule_filename eq 1){
 192
 193                 # The database module filename given is blank so return an
 194                 # critical error.
 195
 196                 xestiascan_critical("authmoduleblank");
 197
 198         }
 199
 200         if ($xestiascan_config_authmodule_filename eq 2){
 201
 202                 # The database module filename given is invalid so return
 203                 # an critical error.
 204
 205                 xestiascan_critical("authmoduleinvalid");
 206
 207         }
 208
 209         # Check if the language file does exist before loading it and return an critical error
 210         # if it does not exist.
 211
 212         my $xestiascan_config_language_fileexists = xestiascan_fileexists("lang/" . $main::xestiascan_config{"system_language"} . ".lang");
 213
 214         if ($xestiascan_config_language_fileexists eq 1){
 215
 216                 # Language file does not exist so return an critical error.
 217
 218                 xestiascan_critical("languagefilemissing");
 219
 220         }
 221
 222         # Check if the language file has valid permission settings and return an critical error if
 223         # the language file has invalid permissions settings.
 224
 225         my $xestiascan_config_language_filepermissions = xestiascan_filepermissions("lang/" . $main::xestiascan_config{"system_language"} . ".lang", 1, 0);
 226
 227         if ($xestiascan_config_language_filepermissions eq 1){
 228
 229                 # Language file contains invalid permissions so return an critical error.
 230
 231                 xestiascan_critical("languagefilenameinvalidpermissions");
 232
 233         }
 234
 235         # Load the language file.
 236
 237         my ($xestiascan_languagefilehandle, @lang_data);
 238
 239         open($xestiascan_languagefilehandle, "lang/" . $main::xestiascan_config{"system_language"} . ".lang");
 240         @lang_data = <$xestiascan_languagefilehandle>;
 241         %main::xestiascan_lang = xestiascan_processconfig(@lang_data);
 242         close($xestiascan_languagefilehandle);
 243
 244         # Check if the presentation module does exist before loading it and return an critical error
 245         # if the presentation module does not exist.
 246
 247         my $xestiascan_config_presmodule_fileexists = xestiascan_fileexists("Modules/Presentation/" . $main::xestiascan_config{"system_presmodule"} . ".pm");
 248
 249         if ($xestiascan_config_presmodule_fileexists eq 1){
 250
 251                 # Presentation module does not exist so return an critical error.
 252
 253                 xestiascan_critical("presmodulemissing");
 254
 255         }
 256
 257         # Check if the presentation module does have the valid permission settings and return a
 258         # critical error if the presentation module contains invalid permission settings.
 259
 260         my $xestiascan_config_presmodule_permissions = xestiascan_filepermissions("Modules/Presentation/" . $main::xestiascan_config{"system_presmodule"} . ".pm", 1, 0);
 261
 262         if ($xestiascan_config_presmodule_permissions eq 1){
 263
 264                 # Presentation module contains invalid permissions so return an critical error.
 265
 266                 xestiascan_critical("presmoduleinvalidpermissions");
 267
 268         }
 269
 270         # Check if the database module does exist before loading it and return an critical error
 271         # if the database module does not exist.
 272
 273         my $xestiascan_config_authmodule_fileexists = xestiascan_fileexists("Modules/Auth/" . $main::xestiascan_config{"system_authmodule"} . ".pm");
 274
 275         if ($xestiascan_config_authmodule_fileexists eq 1){
 276
 277                 # Database module does not exist so return an critical error.
 278
 279                 xestiascan_critical("authmodulemissing");
 280
 281         }
 282
 283         # Check if the database module does have the valid permission settings and return an
 284         # critical error if the database module contains invalid permission settings.
 285
 286         my $xestiascan_config_authmodule_permissions = xestiascan_filepermissions("Modules/Auth/" . $main::xestiascan_config{"system_authmodule"} . ".pm", 1, 0);
 287
 288         if ($xestiascan_config_authmodule_permissions eq 1){
 289
 290                 # Presentation module contains invalid permissions so return an critical error.
 291
 292                 xestiascan_critical("authmoduleinvalidpermissions");
 293
 294         }
 295
 296         # Include the Modules directory.
 297
 298         use lib "Modules/";
 299
 300         # Load the presentation module.
 301
 302         my $presmodulename = "Presentation::" . $main::xestiascan_config{"system_presmodule"};
 303         ($presmodulename) = $presmodulename =~ m/^(.*)$/g; # CHECK THIS!!
 304         eval "use " . $presmodulename;
 305         $presmodulename = "Modules::Presentation::" . $main::xestiascan_config{"system_presmodule"};
 306         $main::xestiascan_presmodule = $presmodulename->new();
 307         $main::xestiascan_presmodule->clear();
 308
 309         # Load the database module.
 310
 311         my $dbmodulename = "Auth::" . $main::xestiascan_config{"system_authmodule"};
 312         ($dbmodulename) = $dbmodulename =~ m/^(.*)$/g; # CHECK THIS!!
 313         eval "use " . $dbmodulename;
 314         $dbmodulename = "Modules::Auth::" . $main::xestiascan_config{"system_authmodule"};
 315         $main::xestiascan_authmodule = $dbmodulename->new();
 316
 317         # Load the following settings to the database module.
 318
 319         $main::xestiascan_authmodule->loadsettings({ DateTime => $main::xestiascan_config{"system_datetime"}, Server => $main::xestiascan_config{"database_server"}, Port => $main::xestiascan_config{"database_port"}, Protocol => $main::xestiascan_config{"database_protocol"}, Database => $main::xestiascan_config{"database_sqldatabase"}, Username => $main::xestiascan_config{"database_username"}, Password => $main::xestiascan_config{"database_password"}, TablePrefix => $main::xestiascan_config{"database_tableprefix"} });
 320
 321         return;
 322
 323 }
 324
 325 sub xestiascan_language{
 326 #################################################################################
 327 # xestiascan_language: Process language strings that needs certain text         #
 328 #                       inserted.                                               #
 329 #                                                                               #
 330 # Usage:                                                                        #
 331 #                                                                               #
 332 # xestiascan_language(string, [text, text, ...]);                               #
 333 #                                                                               #
 334 # string        Specifies the string to process.                                #
 335 # text          Specifies the text to pass to the string (can be repeated many  #
 336 #               times).                                                         #
 337 #################################################################################
 338
 339         my $string = shift;
 340         my $item;
 341
 342         foreach $item (@_){
 343
 344                 $string =~ s/%s/$item/;
 345
 346         }
 347
 348         return $string;
 349
 350 }
 351
 352 sub xestiascan_error{
 353 #################################################################################
 354 # xestiascan_error: Prints out an error message.                                #
 355 #                                                                               #
 356 # Usage:                                                                        #
 357 #                                                                               #
 358 # xestiascan_error(errortype, errorext);                                        #
 359 #                                                                               #
 360 # errortype     Specifies the type of error that occured.                       #
 361 # errorext      Specifies the extended error information.                       #
 362 #################################################################################
 363
 364         # Get the error type from the subroutine.
 365
 366         my ($error_type, $error_extended) = @_;
 367
 368         # Disconnect from the database server.
 369
 370         if ($main::xestiascan_authmodule){
 371                 $main::xestiascan_authmodule->disconnect();
 372         }
 373
 374         # Load the list of error messages.
 375
 376         my @xestiascan_error = (
 377
 378                 # Catch all error message.
 379                 "generic",
 380
 381                 # Standard error messages.
 382                 "blankfilename", "blankvariable", "fileexists", "internalerror", "invalidoption", "invalidaction", "invalidfilename", "invalidmode", "invalidutf8", "invalidvariable", "variabletoolong",
 383
 384                 # Specific error messages.
 385                 "authconnectionerror", "autherror", "authmoduleblank", "authmoduleinvalid", "authmodulemissing",
 386                 "blankdatetimeformat", "blankdirectory", "blankpictureid", "bottomrightx",
 387                 "bottomrightxinvalidnumber", "bottomrighty", "bottomrightyinvalidnumber", "brightnessblank",
 388                 "brightnessinvalidnumber", "colourblank", "colourinvalidoption", "invaliddatetimeformat",
 389                 "invaliddirectory", "invalidpictureid", "languagefilenamemissing", "moduleinvalid",
 390                 "nametoolong", "notpermitted", "outputmoduleblank", "outputmoduleinvalid",
 391                 "passwordblank", "passwordsdonotmatch", "passwordtoolong", "permissiontypeblank", "presmoduleblank",
 392                 "presmoduleinvalid", "presmodulemissing", "resolutionblank", "resolutioninvalidnumber",
 393                 "rotateblank", "rotateinvalidoption", "scannererror", "serverdatabasenameinvalid",
 394                 "serverdatabasenametoolong", "serverdatabasepasswordtoolong", "serverdatabasetableprefixinvalid", "serverdatabasetableprefixtoolong",
 395                 "serverdatabaseusernameinvalid", "serverdatabaseusernametoolong", "servernameinvalid", "servernametoolong",
 396                 "serverportnumberinvalid", "serverportnumberinvalidcharacters", "serverportnumbertoolong", "serverprotocolinvalid",
 397                 "serverprotocolnametoolong", "topleftxblank", "topleftxinvalidnumber", "topleftyblank", "topleftyinvalidnumber",
 398                 "userexists", "usernameblank", "usernametoolong", "variabletoolong"
 399
 400         );
 401
 402         # Check if the error message name is a valid error message name
 403         # and return the generic error message if it isn't.
 404
 405         my $error_string = "";
 406
 407         if (grep /^$error_type$/, @xestiascan_error){
 408
 409                 # The error type is valid so get the error language string
 410                 # associated with this error messsage name.
 411
 412                 $error_string = $main::xestiascan_lang{error}{$error_type};
 413
 414         } else {
 415
 416                 # The error type is invalid so set the error language
 417                 # string using the generic error message name.
 418
 419                 $error_string = $main::xestiascan_lang{error}{generic};
 420
 421         }
 422
 423         $main::xestiascan_presmodule->clear();
 424
 425         $main::xestiascan_presmodule->startbox("errorbox");
 426         $main::xestiascan_presmodule->addtext($main::xestiascan_lang{error}{error}, { Style => "errorheader" });
 427         $main::xestiascan_presmodule->addlinebreak();
 428         $main::xestiascan_presmodule->addtext($error_string, { Style => "errortext" });
 429
 430         # Check to see if extended error information was passed.
 431
 432         if ($error_extended){
 433
 434                 # Write the extended error information.
 435
 436                 $main::xestiascan_presmodule->addlinebreak();
 437                 $main::xestiascan_presmodule->addlinebreak();
 438                 $main::xestiascan_presmodule->addtext($main::xestiascan_lang{error}{extendederror});
 439                 $main::xestiascan_presmodule->addlinebreak();
 440                 $main::xestiascan_presmodule->addlinebreak();
 441                 $main::xestiascan_presmodule->startbox("datalist");
 442                 $main::xestiascan_presmodule->addtext($error_extended);
 443                 $main::xestiascan_presmodule->endbox();
 444
 445         }
 446
 447         $main::xestiascan_presmodule->endbox();
 448
 449         my $menulist = "";
 450
 451         if ($main::successful_auth eq 1){
 452
 453                 $menulist = "standard";
 454
 455         } else {
 456
 457                 $menulist = "none";
 458
 459         }
 460
 461         &xestiascan_output_header;
 462         xestiascan_output_page($main::xestiascan_lang{error}{error}, $main::xestiascan_presmodule->grab(), $menulist);
 463
 464         exit;
 465
 466 }
 467
 468 sub xestiascan_fileexists{
 469 #################################################################################
 470 # xestiascan_fileexists: Check if a file exists and returns a value depending on #
 471 # if the file exists or not.                                                    #
 472 #                                                                               #
 473 # Usage:                                                                        #
 474 #                                                                               #
 475 # xestiascan_fileexists(filename);                                              #
 476 #                                                                               #
 477 # filename      Specifies the file name to check if it exists or not.           #
 478 #################################################################################
 479
 480         # Get the value that was passed to the subroutine.
 481
 482         my ($filename) = @_;
 483
 484         # Check if the filename exists, if it does, return a value of 0, else
 485         # return a value of 1, meaning that the file was not found.
 486
 487         if (-e $filename){
 488
 489                 # Specified file does exist so return a value of 0.
 490
 491                 return 0;
 492
 493         } else {
 494
 495                 # Specified file does not exist so return a value of 1.
 496
 497                 return 1;
 498
 499         }
 500
 501 }
 502
 503 sub xestiascan_filepermissions{
 504 #################################################################################
 505 # xestiascan_filepermissions: Check if the file permissions of a file and return #
 506 # either a 1 saying that the permissions are valid or return a 0 saying that    #
 507 # the permissions are invalid.                                                  #
 508 #                                                                               #
 509 # Usage:                                                                        #
 510 #                                                                               #
 511 # xestiascan_filepermissions(filename, [read], [write], [filemissingskip]);     #
 512 #                                                                               #
 513 # filename              Specifies the filename to check for permissions.        #
 514 # read                  Preform check that the file is readable.                #
 515 # write                 Preform check that the file is writeable.               #
 516 # filemissingskip       Skip the check of seeing if it can read or write if the #
 517 #                       file is missing.                                        #
 518 #################################################################################
 519
 520         # Get the values that was passed to the subroutine.
 521
 522         my ($filename, $readpermission, $writepermission, $ignorechecks) = @_;
 523
 524         # Check to make sure that the read permission and write permission values
 525         # are only 1 character long.
 526
 527         xestiascan_variablecheck($readpermission, "maxlength", 1, 0);
 528         xestiascan_variablecheck($writepermission, "maxlength", 1, 0);
 529         xestiascan_variablecheck($ignorechecks, "maxlength", 1, 0);
 530
 531         my $ignorechecks_result = 0;
 532
 533         # Check if the file should be ignored for read and write checking if
 534         # it doesn't exist.
 535
 536         if ($ignorechecks){
 537
 538                 if (-e $filename){
 539
 540                         # The file exists so the checks are to be done.
 541
 542                         $ignorechecks_result = 0;
 543
 544                 } else {
 545
 546                         # The file does not exist so the checks don't need to
 547                         # be done to prevent false positives.
 548
 549                         $ignorechecks_result = 1;
 550
 551                 }
 552
 553         } else {
 554
 555                 $ignorechecks_result = 0;
 556
 557         }
 558
 559         # Check if the file should be checked to see if it can be read.
 560
 561         if ($readpermission && $ignorechecks_result eq 0){
 562
 563                 # The file should be checked to see if it does contain read permissions
 564                 # and return a 0 if it is invalid.
 565
 566                 if (-r $filename){
 567
 568                         # The file is readable, so do nothing.
 569
 570                 } else {
 571
 572                         # The file is not readable, so return 1.
 573
 574                         return 1;
 575
 576                 }
 577
 578         }
 579
 580         # Check if the file should be checked to see if it can be written.
 581
 582         if ($writepermission && $ignorechecks_result eq 0){
 583
 584                 # The file should be checked to see if it does contain write permissions
 585                 # and return a 0 if it is invalid.
 586
 587                 if (-w $filename){
 588
 589                         # The file is writeable, so do nothing.
 590
 591                 } else {
 592
 593                         # The file is not writeable, so return 1.
 594
 595                         return 1;
 596
 597                 }
 598
 599         }
 600
 601         # No problems have occured, so return 0.
 602
 603         return 0;
 604
 605 }
 606
 607 sub xestiascan_utf8convert{
 608 #################################################################################
 609 # xestiascan_utf8convert: Properly converts values into UTF-8 values.           #
 610 #                                                                               #
 611 # Usage:                                                                        #
 612 #                                                                               #
 613 # utfstring     # The UTF-8 string to convert.                                  #
 614 #################################################################################
 615
 616         # Get the values passed to the subroutine.
 617
 618         my ($utfstring) = @_;
 619
 620         # Load the Encode perl module.
 621
 622         use Encode qw(decode_utf8 encode_utf8);
 623
 624         # Convert the string.
 625
 626         my $finalutf8 = Encode::decode_utf8( $utfstring );
 627
 628         return $finalutf8;
 629         #return $utfstring;
 630
 631 }
 632
 633 sub xestiascan_critical{
 634 #################################################################################
 635 # xestiascan_critical: Displays an critical error message that cannot be                #
 636 # normally by the xestiascan_error subroutine.                                  #
 637 #                                                                               #
 638 # Usage:                                                                        #
 639 #                                                                               #
 640 # errortype     Specifies the type of critical error that has occured.          #
 641 #################################################################################
 642
 643         # Get the value that was passed to the subroutine.
 644
 645         my ($error_type) = @_;
 646
 647         my %error_list;
 648
 649         # Get the error type from the errortype string.
 650
 651         %error_list = (
 652
 653                 # Generic critical error message.
 654
 655                 "generic"                       => "A critical error has occured but the error is not known to Xestia Scanner Server.",
 656
 657                 # Specific critical error messages.
 658
 659                 "configfilemissing"             => "The Xestia Scanner Server configuration file is missing! Running the installer script for Xestia Scanner Server is recommended.",
 660                 "configfileinvalidpermissions"  => "The Xestia Scanner Server configuration file has invalid permission settings set! Please set the valid permission settings for the configuration file.",
 661                 "authmoduleblank"               => "The authentication module name is blank! Running the installer script for Xestia Scanner Server is recommended.",
 662                 "authmodulemissing"             => "The authentication module is missing! Running the installer script for Xestia Scanner Server is recommended.",
 663                 "authmoduleinvalidpermissions"  => "The authentication module cannot be used as it has invalid permission settings set! Please set the valid permission settings for the configuration file.",
 664                 "authmoduleinvalid"             => "The authentication module name given is invalid. Running the installer script for Xestia Scanner Server is recommended.",
 665                 "invalidvalue"                  => "An invalid value was passed.",
 666                 "languagefilenameblank"         => "The language filename given is blank! Running the installer script for Xestia Scanner Server is recommended.",
 667                 "languagefilenameinvalid"       => "The language filename given is invalid! Running the installer script for Xestia Scanner Server is recommended.",
 668                 "languagefilemissing"   => "The language filename given does not exist. Running the installer script for Xestia Scanner Server is recommended.",
 669                 "languagefilenameinvalidpermissions"    => "The language file with the filename given has invalid permissions set. Please set the valid permission settings for the language file.",
 670                 "presmodulemissing"             => "The presentation module is missing! Running the installer script for Xestia Scanner Server is recommended.",
 671                 "presmoduleinvalidpermissions"  => "The presentation module cannot be used as it has invalid permission settings set! Please set the valid permission settings for the presentation module.",
 672                 "presmoduleinvalid"             => "The presentation module name given is invalid. Running the installer script for Xestia Scanner Server is recommended.",
 673                 "textarearowblank"              => "The text area row value given is blank. Running the installer script for Xestia Scanner Server is recommended.",
 674                 "textarearowtoolong"            => "The text area row value is too long. Running the installer script for Xestia Scanner Server is recommended.",
 675                 "textarearowinvalid"            => "The text area row value is invalid. Running the installer script for Xestia Scanner Server is recommended.",
 676                 "textareacolblank"              => "The text area row value given is blank. Running the installer script for Xestia Scanner Server is recommended.",
 677                 "textareacoltoolong"            => "The text area column value is too long. Running the installer script for Xestia Scanner Server is recommended.",
 678                 "textareacolinvalid"            => "The text area column value is invalid. Running the installer script for Xestia Scanner Server is recommended.",
 679                 "pagecountblank"                => "The page count value is blank. Running the installer script for Xestia Scanner Server is recommended.",
 680                 "templatecountblank"            => "The template count value is blank. Running the installer script for Xestia Scanner Server is recommended.",
 681                 "filtercountblank"              => "The filter count value is blank. Running the installer script for Xestia Scanner Server is recommended.",
 682                 "pagecounttoolong"              => "The page count value is too long. Running the installer script for Xestia Scanner Server is recommended.",
 683                 "templatecounttoolong"          => "The template count value is too long. Running the installer script for Xestia Scanner Server is recommended.",
 684                 "filtercounttoolong"            => "The filter count value is too long. Running the installer script for Xestia Scanner Server is recommended.",
 685                 "pagecountinvalid"              => "The page count value is invalid. Running the installer script for Xestia Scanner Server is recommended.",
 686                 "templatecountinvalid"          => "The template count value is invalid. Running the installer script for Xestia Scanner Server is recommended.",
 687                 "filtercountinvalid"            => "The filter count is invalid. Running the installer script for Xestia Scanner Server is recommended."
 688
 689         );
 690
 691         if (!$error_list{$error_type}){
 692
 693                 $error_type = "generic";
 694
 695         }
 696
 697         print "Content-Type: text/html; charset=utf-8;\r\n";
 698         print "Expires: Sun, 01 Jan 2008 00:00:00 GMT\r\n\r\n";
 699         print "Critical Error: " . $error_list{$error_type};
 700         exit;
 701
 702 }
 703
 704 sub xestiascan_variablecheck{
 705 #################################################################################
 706 # xestiascan_variablecheck: Checks the variables for any invalid characters.    #
 707 #                                                                               #
 708 # Usage:                                                                        #
 709 #                                                                               #
 710 # xestiascan_variablecheck(variable, type, length, noerror);                    #
 711 #                                                                               #
 712 # variable      Specifies the variable to be checked.                           #
 713 # type          Specifies what type the variable is.                            #
 714 # option        Specifies the maximum/minimum length of the variable            #
 715 #               (if minlength/maxlength is used) or if the filename should be   #
 716 #               checked to see if it is blank.                                  #
 717 # noerror       Specifies if Xestia Scanner Server should return an error       #
 718 #               or not on certain values.                                       #
 719 #################################################################################
 720
 721         # Get the values that were passed to the subroutine.
 722
 723         my ($variable_data, $variable_type, $variable_option, $variable_noerror) = @_;
 724
 725         if (!$variable_data){
 726                 $variable_data = "";
 727         }
 728
 729         if (!$variable_type){
 730                 $variable_type = "";
 731         }
 732
 733         if ($variable_type eq "numbers"){
 734
 735                 # Check for numbers and return an error if there is anything else than numebrs.
 736
 737                 my $variable_data_validated = $variable_data;   # Copy the variable_data to variable_data_validated.
 738                 $variable_data_validated =~ tr/0-9//d;          # Take away all of the numbers and from the variable.
 739                                                                 # If it only contains numbers then it should be blank.
 740
 741                 if ($variable_data_validated eq ""){
 742                         # The validated variable is blank. So continue to the end of this section where the return function should be.
 743                 } else {
 744                         # The variable is not blank, so check if the no error value is set
 745                         # to 1 or not.
 746
 747                         if ($variable_noerror eq 1){
 748
 749                                 # The validated variable is not blank and the noerror
 750                                 # value is set to 1. So return an value of 1.
 751                                 # (meaning that the data is invalid).
 752
 753                                 return 1;
 754
 755                         } elsif ($variable_noerror eq 0) {
 756
 757                                 # The validated variable is not blank and the noerror
 758                                 # value is set to 0.
 759
 760                                 xestiascan_error("invalidvariable");
 761
 762                         } else {
 763
 764                                 # The variable noerror value is something else
 765                                 # pther than 1 or 0. So return an error.
 766
 767                                 xestiascan_error("invalidvariable");
 768
 769                         }
 770
 771                 }
 772
 773                 return 0;
 774
 775         } elsif ($variable_type eq "decimal"){
 776
 777                 # Check for numbers and decimal and return an error if there is anything else than numebrs.
 778
 779                 my $variable_data_validated = $variable_data;   # Copy the variable_data to variable_data_validated.
 780                 $variable_data_validated =~ tr/0-9.//d;         # Take away all of the numbers and from the variable.
 781                 # If it only contains numbers then it should be blank.
 782
 783                 if ($variable_data_validated eq ""){
 784                         # The validated variable is blank. So continue to the end of this section where the return function should be.
 785                 } else {
 786                         # The variable is not blank, so check if the no error value is set
 787                         # to 1 or not.
 788
 789                         if ($variable_noerror eq 1){
 790
 791                                 # The validated variable is not blank and the noerror
 792                                 # value is set to 1. So return an value of 1.
 793                                 # (meaning that the data is invalid).
 794
 795                                 return 1;
 796
 797                         } elsif ($variable_noerror eq 0) {
 798
 799                                 # The validated variable is not blank and the noerror
 800                                 # value is set to 0.
 801
 802                                 xestiascan_error("invalidvariable");
 803
 804                         } else {
 805
 806                                 # The variable noerror value is something else
 807                                 # pther than 1 or 0. So return an error.
 808
 809                                 xestiascan_error("invalidvariable");
 810
 811                         }
 812
 813                 }
 814
 815                 return 0;
 816
 817         } elsif ($variable_type eq "lettersnumbers"){
 818
 819                 # Check for letters and numbers and return an error if there is anything else other
 820                 # than letters and numbers.
 821
 822                 my $variable_data_validated = $variable_data;   # Copy the variable_data to variable_data_validated
 823                 $variable_data_validated =~ tr/a-zA-Z0-9.//d;
 824                 $variable_data_validated =~ s/\s//g;
 825
 826                 if ($variable_data_validated eq ""){
 827                         # The validated variable is blank. So continue to the end of this section where the return function should be.
 828                 } else {
 829                         # The variable is not blank, so check if the no error value is set
 830                         # to 1 or not.
 831
 832                         if ($variable_noerror eq 1){
 833
 834                                 # The validated variable is not blank and the noerror
 835                                 # value is set to 1. So return an value of 1.
 836                                 # (meaning that the data is invalid).
 837
 838                                 return 1;
 839
 840                         } elsif ($variable_noerror eq 0) {
 841
 842                                 # The validated variable is not blank and the noerror
 843                                 # value is set to 0.
 844
 845                                 xestiascan_error("invalidvariable");
 846
 847                         } else {
 848
 849                                 # The variable noerror value is something else
 850                                 # pther than 1 or 0. So return an error.
 851
 852                                 xestiascan_error("invalidvariable");
 853
 854                         }
 855
 856                 }
 857
 858                 return 0;
 859
 860         } elsif ($variable_type eq "maxlength"){
 861                 # Check for the length of the variable, return an error if it is longer than the length specified.
 862
 863                 # Check if the variable_data string is blank, if it is then set the variable_data_length
 864                 # to '0'.
 865
 866                 my $variable_data_length = 0;
 867
 868                 if (!$variable_data){
 869
 870                         # Set variable_data_length to '0'.
 871                         $variable_data_length = 0;
 872
 873                 } else {
 874
 875                         # Get the length of the variable recieved.
 876                         $variable_data_length = length($variable_data);
 877
 878                 }
 879
 880
 881
 882                 if ($variable_data_length > $variable_option){
 883
 884                         # The variable length is longer than it should be so check if
 885                         # the no error value is set 1.
 886
 887                         if ($variable_noerror eq 1){
 888
 889                                 # The no error value is set to 1, so return an
 890                                 # value of 1 (meaning tha the variable is
 891                                 # too long to be used).
 892
 893                                 return 1;
 894
 895                         } elsif ($variable_noerror eq 0){
 896
 897                                 # The no error value is set to 0, so return
 898                                 # an error.
 899
 900                                 xestiascan_error("variabletoolong");
 901
 902                         } else {
 903
 904                                 # The no error value is something else other
 905                                 # than 0 or 1, so return an error.
 906
 907                                 xestiascan_error("variabletoolong");
 908
 909                         }
 910
 911                 } else {
 912
 913                         # The variable length is exactly or shorter than specified, so continue to end of this section where
 914                         # the return function should be.
 915
 916                 }
 917
 918                 return 0;
 919
 920         } elsif ($variable_type eq "blank"){
 921                 # Check if the variable is blank and if it is blank, then return an error.
 922
 923                 if (!$variable_data){
 924
 925                         # The variable data really is blank, so check what
 926                         # the no error value is set.
 927
 928                         if ($variable_noerror eq 1){
 929
 930                                 # The no error value is set to 1, so return
 931                                 # a value of 1 (saying that the variable was
 932                                 # blank).
 933
 934                                 return 1;
 935
 936                         } elsif ($variable_noerror eq 0){
 937
 938                                 # The no error value is set to 0, so return
 939                                 # an error.
 940
 941                                 xestiascan_error("blankvariable");
 942
 943                         } else {
 944
 945                                 # The no error value is something else other
 946                                 # than 0 or 1, so return an error.
 947
 948                                 xestiascan_error("invalidvariable");
 949
 950                         }
 951
 952                 }
 953
 954                 return 0;
 955
 956         } elsif ($variable_type eq "filename"){
 957                 # Check for letters and numbers, if anything else than letters and numbers is there (including spaces) return
 958                 # an error.
 959
 960                 # Check if the filename passed is blank, if it is then return with an error.
 961
 962                 if ($variable_data eq ""){
 963
 964                         # The filename specified is blank, so check what the
 965                         # noerror value is set.
 966
 967                         if ($variable_noerror eq 1){
 968
 969                                 # The no error value is set to 1 so return
 970                                 # a value of 1 (meaning that the filename
 971                                 # was blank).
 972
 973                                 return 1;
 974
 975                         } elsif ($variable_noerror eq 0){
 976
 977                                 # The no error value is set to 1 so return
 978                                 # an error.
 979
 980                                 xestiascan_error("blankfilename");
 981
 982                         } else {
 983
 984                                 # The no error value is something else other
 985                                 # than 0 or 1, so return an error.
 986
 987                                 xestiascan_error("invalidvariable");
 988
 989                         }
 990
 991                 } else {
 992
 993
 994                 }
 995
 996                 my $variable_data_validated = $variable_data;
 997                 $variable_data_validated =~ tr/a-zA-Z0-9\.//d;
 998
 999                 # Check if the validated data variable is blank, if it is
1000                 # then continue to the end of this section where the return
1001                 # function should be, otherwise return an error.
1002
1003                 if ($variable_data_validated eq ""){
1004
1005                         # The validated data variable is blank, meaning that
1006                         # it only contained letters and numbers.
1007
1008                 } else {
1009
1010                         # The validated data variable is not blank, meaning
1011                         # that it contains something else, so return an error
1012                         # (or a value).
1013
1014                         if ($variable_noerror eq 1){
1015
1016                                 # The no error value is set to 1 so return
1017                                 # an value of 2. (meaning that the filename
1018                                 # is invalid).
1019
1020
1021                                 return 2;
1022
1023                         } elsif ($variable_noerror eq 0){
1024
1025                                 # The no error value is set to 0 so return
1026                                 # an error.
1027
1028                                 xestiascan_error("invalidfilename");
1029
1030                         } else {
1031
1032                                 # The no error value is something else other
1033                                 # than 0 or 1 so return an error.
1034
1035                                 xestiascan_error("invalidvariable");
1036
1037                         }
1038
1039                 }
1040
1041                 return 0;
1042
1043         } elsif ($variable_type eq "filenameindir"){
1044                 # Check if the filename is in the directory and return an
1045                 # error if it isn't.
1046
1047                 if ($variable_data eq ""){
1048
1049                         # The filename specified is blank, so check what the
1050                         # noerror value is set.
1051
1052                         if ($variable_noerror eq 1){
1053
1054                                 # The no error value is set to 1 so return
1055                                 # a value of 1 (meaning that the filename
1056                                 # was blank).
1057
1058                                 return 1;
1059
1060                         } elsif ($variable_noerror eq 0){
1061
1062                                 # The no error value is set to 1 so return
1063                                 # an error.
1064
1065                                 xestiascan_error("blankfilename");
1066
1067                         } else {
1068
1069                                 # The no error value is something else other
1070                                 # than 0 or 1, so return an error.
1071
1072                                 xestiascan_error("invalidvariable");
1073
1074                         }
1075
1076                 } else {
1077
1078
1079                 }
1080
1081                 # Set the following variables for later on.
1082
1083                 my $variable_data_length = 0;
1084                 my $variable_data_char = "";
1085                 my $variable_data_validated = "";
1086                 my $variable_data_seek = 0;
1087                 my $variable_database_list = "";
1088                 my $variable_database_listcurrent = "";
1089                 my $variable_data_firstlevel = 1;
1090
1091                 # Get the length of the variable recieved.
1092
1093                 $variable_data_length = length($variable_data);
1094
1095                 # Check if the database filename contains the directory command
1096                 # for up a directory level and if it is, return an error
1097                 # or return with a number.
1098
1099                 do {
1100
1101                         # Get a character from the filename passed to this subroutine.
1102
1103                         $variable_data_char = substr($variable_data, $variable_data_seek, 1);
1104
1105                         # Check if the current character is the forward slash character.
1106
1107                         if ($variable_data_char eq "/"){
1108
1109                                 # Check if the current directory is blank (and on the first level), or if the
1110                                 # current directory contains two dots or one dot, if it does return an error.
1111
1112                                 if ($variable_database_listcurrent eq "" && $variable_data_firstlevel eq 1 || $variable_database_listcurrent eq ".." || $variable_database_listcurrent eq "."){
1113
1114                                         # Check if the noerror value is set to 1, if it is return an
1115                                         # number, else return an proper error.
1116
1117                                         if ($variable_noerror eq 1){
1118
1119                                                 # Page filename contains invalid characters and
1120                                                 # the no error value is set to 1 so return a
1121                                                 # value of 2 (meaning that the page filename
1122                                                 # is invalid).
1123
1124                                                 return 2;
1125
1126                                         } elsif ($variable_noerror eq 0) {
1127
1128                                                 # Page filename contains invalid characters and
1129                                                 # the no error value is set to 0 so return an
1130                                                 # error.
1131
1132                                                 xestiascan_error("invalidfilename");
1133
1134                                         } else {
1135
1136                                                 # The no error value is something else other
1137                                                 # than 0 or 1 so return an error.
1138
1139                                                 xestiascan_error("invalidvariable");
1140
1141                                         }
1142
1143                                 }
1144
1145                                 # Append the forward slash, clear the current directory name and set
1146                                 # the first directory level value to 0.
1147
1148                                 $variable_database_list = $variable_database_list . $variable_data_char;
1149                                 $variable_database_listcurrent = "";
1150                                 $variable_data_firstlevel = 0;
1151
1152                         } else {
1153
1154                                 # Append the current character to the directory name and to the current
1155                                 # directory name.
1156
1157                                 $variable_database_list = $variable_database_list . $variable_data_char;
1158                                 $variable_database_listcurrent = $variable_database_listcurrent . $variable_data_char;
1159
1160                         }
1161
1162                         # Increment the seek counter.
1163
1164                         $variable_data_seek++;
1165
1166                 } until ($variable_data_seek eq $variable_data_length);
1167
1168                 return 0;
1169
1170         } elsif ($variable_type eq "datetime"){
1171                 # Check if the date and time setting format is valid.
1172
1173                 if ($variable_data eq ""){
1174
1175                         if ($variable_noerror eq 1){
1176
1177                                 # The no error value is set to 1 so return
1178                                 # a value of 1 (meaning that the date and
1179                                 # time format was blank).
1180
1181                                 return 1;
1182
1183                         } elsif ($variable_noerror eq 0){
1184
1185                                 # The no error value is set to 1 so return
1186                                 # an error.
1187
1188                                 xestiascan_error("blankdatetimeformat");
1189
1190                         } else {
1191
1192                                 # The no error value is something else other
1193                                 # than 0 or 1, so return an error.
1194
1195                                 xestiascan_error("invalidvariable");
1196
1197                         }
1198
1199                 }
1200
1201                 my $variable_data_validated = $variable_data;
1202                 $variable_data_validated =~ tr|dDmMyYhms/():[ ]||d;
1203
1204                 if ($variable_data_validated eq ""){
1205
1206                         # The date and time format is valid. So
1207                         # skip this bit.
1208
1209                 } else {
1210
1211                         # The validated data variable is not blank, meaning
1212                         # that it contains something else, so return an error
1213                         # (or a value).
1214
1215                         if ($variable_noerror eq 1){
1216
1217                                 # The no error value is set to 1 so return
1218                                 # an value of 2. (meaning that the date and
1219                                 # time format was invalid).
1220
1221                                 return 2;
1222
1223                         } elsif ($variable_noerror eq 0){
1224
1225                                 # The no error value is set to 0 so return
1226                                 # an error.
1227
1228                                 xestiascan_error("invaliddatetimeformat");
1229
1230                         } else {
1231
1232                                 # The no error value is something else other
1233                                 # than 0 or 1 so return an error.
1234
1235                                 xestiascan_error("invalidvariable");
1236
1237                         }
1238
1239                 }
1240
1241                 return 0;
1242
1243         } elsif ($variable_type eq "directory"){
1244                 # Check if the directory only contains letters and numbers and
1245                 # return an error if anything else appears.
1246
1247                 my $variable_data_validated = $variable_data;
1248                 $variable_data_validated =~ tr/a-zA-Z0-9//d;
1249
1250                 if ($variable_data eq ""){
1251
1252                         if ($variable_noerror eq 1){
1253
1254                                 # The no error value is set to 1 so return
1255                                 # a value of 1 (meaning that the directory
1256                                 # name was blank).
1257
1258                                 return 1;
1259
1260                         } elsif ($variable_noerror eq 0){
1261
1262                                 # The no error value is set to 1 so return
1263                                 # an error.
1264
1265                                 xestiascan_error("blankdirectory");
1266
1267                         } else {
1268
1269                                 # The no error value is something else other
1270                                 # than 0 or 1, so return an error.
1271
1272                                 xestiascan_error("invalidvariable");
1273
1274                         }
1275
1276                 }
1277
1278                 if ($variable_data_validated eq ""){
1279
1280                         # The validated data variable is blank, meaning that
1281                         # it only contains letters and numbers.
1282
1283                 } else {
1284
1285                         # The validated data variable is not blank, meaning
1286                         # that it contains something else, so return an error
1287                         # (or a value).
1288
1289                         if ($variable_noerror eq 1){
1290
1291                                 # The no error value is set to 1 so return
1292                                 # an value of 2. (meaning that the directory
1293                                 # name is invalid).
1294
1295                                 return 2;
1296
1297                         } elsif ($variable_noerror eq 0){
1298
1299                                 # The no error value is set to 0 so return
1300                                 # an error.
1301
1302                                 xestiascan_error("invaliddirectory");
1303
1304                         } else {
1305
1306                                 # The no error value is something else other
1307                                 # than 0 or 1 so return an error.
1308
1309                                 xestiascan_error("invalidvariable");
1310
1311                         }
1312
1313                 }
1314
1315                 return 0;
1316
1317         } elsif ($variable_type eq "language_filename"){
1318
1319                 # The variable type is a language filename type.
1320                 # Check if the language file name is blank and
1321                 # if it is then return an error (or value).
1322
1323                 if ($variable_data eq ""){
1324
1325                         # The language filename is blank so check the
1326                         # no error value and return an error (or value).
1327
1328                         if ($variable_noerror eq 1){
1329
1330                                 # Language filename is blank and the no error value
1331                                 # is set as 1, so return a value of 1 (saying that
1332                                 # the language filename is blank).
1333
1334                                 return 1;
1335
1336                         } elsif ($variable_noerror eq 0) {
1337
1338                                 # Language filename is blank and the no error value
1339                                 # is not set as 1, so return an error.
1340
1341                                 xestiascan_critical("languagefilenameblank");
1342
1343                         } else {
1344
1345                                 # The noerror value is something else other
1346                                 # than 0 or 1 so return an error.
1347
1348                                 xestiascan_error("invalidvariable");
1349
1350                         }
1351
1352                 }
1353
1354                 # Set the following variables for later on.
1355
1356                 my $variable_data_length = 0;
1357                 my $variable_data_char = "";
1358                 my $variable_data_seek = 0;
1359
1360                 # Get the length of the language file name.
1361
1362                 $variable_data_length = length($variable_data);
1363
1364                 do {
1365
1366                         # Get a character from the language filename passed to this
1367                         # subroutine and the character the seek counter value is set
1368                         # to.
1369
1370                         $variable_data_char = substr($variable_data, $variable_data_seek, 1);
1371
1372                         # Check if the language filename contains a forward slash or a dot,
1373                         # if the selected character is a forward slash then return an error
1374                         # (or value).
1375
1376                         if ($variable_data_char eq "/" || $variable_data_char eq "."){
1377
1378                                 # The language filename contains a forward slash or
1379                                 # a dot so depending on the no error value, return
1380                                 # an error or a value.
1381
1382                                 if ($variable_noerror eq 1){
1383
1384                                         # Language filename contains a forward slash or a dot
1385                                         # and the no error value has been set to 1, so return
1386                                         # an value of 2 (saying that the language file name is
1387                                         # invalid).
1388
1389                                         return 2;
1390
1391                                 } elsif ($variable_noerror eq 0) {
1392
1393                                         # Language filename contains a forward slash and the no
1394                                         # error value has not been set to 1, so return an error.
1395
1396                                         xestiascan_critical("languagefilenameinvalid");
1397
1398                                 } else {
1399
1400                                         # The noerror value is something else other than
1401                                         # 1 or 0 so return an error.
1402
1403                                         xestiascan_error("invalidvariable");
1404
1405                                 }
1406
1407                         }
1408
1409                         # Increment the seek counter.
1410
1411                         $variable_data_seek++;
1412
1413                 } until ($variable_data_seek eq $variable_data_length);
1414
1415                 return 0;
1416
1417         } elsif ($variable_type eq "module"){
1418
1419                 # The variable type is a presentation module filename.
1420
1421                 # Check if the variable_data is blank and if it is
1422                 # return an error.
1423
1424                 if ($variable_data eq ""){
1425
1426                         # The presentation module is blank so check if an error
1427                         # value should be returned or a number should be
1428                         # returned.
1429
1430                         if ($variable_noerror eq 1){
1431
1432                                 # Module name is blank and the no error value
1433                                 # is set to 1 so return a value of 2 (meaning
1434                                 # that the page filename is blank).
1435
1436                                 return 1;
1437
1438                         } elsif ($variable_noerror eq 0) {
1439
1440                                 # Module name contains is blank and the no error
1441                                 # value is set to 0 so return an error.
1442
1443                                 xestiascan_critical("moduleblank");
1444
1445                         } else {
1446
1447                                 # The no error value is something else other
1448                                 # than 0 or 1 so return an error.
1449
1450                                 xestiascan_critical("invalidvalue");
1451
1452                         }
1453
1454                 } else {
1455
1456                 }
1457
1458                 my $variable_data_validated = $variable_data;
1459                 $variable_data_validated =~ tr/a-zA-Z0-9//d;
1460
1461                 if ($variable_data_validated eq ""){
1462
1463                 } else {
1464
1465                         if ($variable_noerror eq 1){
1466
1467                                 # Module name contains invalid characters and
1468                                 # the no error value is set to 1 so return a
1469                                 # value of 2 (meaning that the page filename
1470                                 # is invalid).
1471
1472                                 return 2;
1473
1474                         } elsif ($variable_noerror eq 0) {
1475
1476                                 # Module name contains invalid characters and
1477                                 # the no error value is set to 0 so return an
1478                                 # error.
1479
1480                                 xestiascan_critical("moduleinvalid");
1481
1482                         } else {
1483
1484                                 # The no error value is something else other
1485                                 # than 0 or 1 so return an error.
1486
1487                                 xestiascan_error("invalidvalue");
1488
1489                         }
1490
1491                 }
1492
1493                 return 0;
1494
1495         } elsif ($variable_type eq "utf8"){
1496
1497                 # The variable type is a UTF8 string.
1498
1499                 if (!$variable_data){
1500
1501                         $variable_data = "";
1502
1503                 }
1504
1505                 my $chunk = 0;
1506                 my $process = 8192;
1507                 my $length = 0;
1508                 my $chunkdata = "";
1509
1510                 while ($chunk < $length){
1511
1512                         $chunkdata = substr($variable_data, $chunk, $process);
1513
1514                         if ($chunkdata =~ m/\A(
1515                                 [\x09\x0A\x0D\x20-\x7E]            # ASCII
1516                                 | [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
1517                                 |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
1518                                 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
1519                                 |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
1520                                 |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
1521                                 | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
1522                                 |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
1523                         )*\z/x){
1524
1525                                 # The UTF-8 string is valid.
1526
1527                         } else {
1528
1529                                 # The UTF-8 string is not valid, check if the no error
1530                                 # value is set to 1 and return an error if it isn't.
1531
1532                                 if ($variable_noerror eq 1){
1533
1534                                         # The no error value has been set to 1, so return
1535                                         # a value of 1 (meaning that the UTF-8 string is
1536                                         # invalid).
1537
1538                                         return 1;
1539
1540                                 } elsif ($variable_noerror eq 0) {
1541
1542                                         # The no error value has been set to 0, so return
1543                                         # an error.
1544
1545                                         xestiascan_error("invalidutf8");
1546
1547                                 } else {
1548
1549                                         # The no error value is something else other than 0
1550                                         # or 1, so return an error.
1551
1552                                         xestiascan_error("invalidoption");
1553
1554                                 }
1555
1556                         }
1557
1558
1559                         $chunk = $chunk + $process;
1560
1561                 }
1562
1563 #               # Check if the string is a valid UTF8 string.
1564 #
1565 #               if ($variable_data =~ m/^(
1566 #                       [\x09\x0A\x0D\x20-\x7E]              # ASCII
1567 #                       | [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
1568 #                       |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
1569 #                       | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
1570 #                       |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
1571 #                       |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
1572 #                       | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
1573 #                       |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
1574 #               )*$/x){
1575 #
1576 #                       # The UTF-8 string is valid.
1577 #
1578 #               } else {
1579 #
1580 #                       # The UTF-8 string is not valid, check if the no error
1581 #                       # value is set to 1 and return an error if it isn't.
1582 #
1583 #                       if ($variable_noerror eq 1){
1584 #
1585 #                               # The no error value has been set to 1, so return
1586 #                               # a value of 1 (meaning that the UTF-8 string is
1587 #                               # invalid).
1588 #
1589 #                               return 1;
1590 #
1591 #                       } elsif ($variable_noerror eq 0) {
1592 #
1593 #                               # The no error value has been set to 0, so return
1594 #                               # an error.
1595 #
1596 #                               xestiascan_error("invalidutf8");
1597 #
1598 #                       } else {
1599 #
1600 #                               # The no error value is something else other than 0
1601 #                               # or 1, so return an error.
1602 #
1603 #                               xestiascan_error("invalidoption");
1604 #
1605 #                       }
1606 #
1607 #               }
1608
1609                 return 0;
1610
1611         } elsif ($variable_type eq "serverprotocol"){
1612
1613                 # Check if the server protocol is TCP or UDP and return
1614                 # an error if it isn't.
1615
1616                 if ($variable_data ne "tcp" && $variable_data ne "udp"){
1617
1618                         # The protocol given is not valid, check if the no
1619                         # error value is set to 1 and return an error if it isn't.
1620
1621                         if ($variable_noerror eq 1){
1622
1623                                 # The no error value has been set to 1, so return a
1624                                 # value of 1 (meaning that the server protocol is
1625                                 # invalid).
1626
1627                                 return 1;
1628
1629                         } elsif ($variable_noerror eq 0){
1630
1631                                 # The no error value has been set to 0, so return
1632                                 # an error.
1633
1634                                 xestiascan_error("serverprotocolinvalid");
1635
1636                         } else {
1637
1638                                 # The no error value is something else other than 0
1639                                 # or 1, so return an error.
1640
1641                                 xestiascan_error("invalidoption");
1642
1643                         }
1644
1645                 }
1646
1647                 return 0;
1648
1649         } elsif ($variable_type eq "port"){
1650
1651                 # Check if the port number given is less than 0 or more than 65535
1652                 # and return an error if it is.
1653
1654                 if ($variable_data < 0 || $variable_data > 65535){
1655
1656                         # The port number is less than 0 and more than 65535 so
1657                         # check if the no error value is set to 1 and return an
1658                         # error if it isn't.
1659
1660                         if ($variable_noerror eq 1){
1661
1662                                 # The no error value has been set to 1, so return a
1663                                 # value of 1 (meaning that the port number is invalid).
1664
1665                                 return 1;
1666
1667                         } elsif ($variable_noerror eq 0){
1668
1669                                 # The no error value has been set to 0, so return
1670                                 # an error.
1671
1672                                 xestiascan_error("serverportnumberinvalid");
1673
1674                         } else {
1675
1676                                 # The no error value is something else other than 0
1677                                 # or 1, so return an error.
1678
1679                                 xestiascan_error("invalidoption");
1680
1681                         }
1682
1683                 }
1684
1685                 return 0;
1686
1687         }
1688
1689         # Another type than the valid ones above has been specified so return an error specifying an invalid option.
1690         xestiascan_error("invalidoption");
1691
1692 }
1693
1694 sub xestiascan_output_header{
1695 #################################################################################
1696 # xestiascan_output_header: Outputs the header to the browser/stdout/console.   #
1697 #                                                                               #
1698 # Usage:                                                                        #
1699 #                                                                               #
1700 # xestiascan_output_header(username, seed, expires);                            #
1701 #################################################################################
1702
1703         my $headertype = shift;
1704
1705         # Print a header saying that the page expires immediately since the
1706         # date is set in the past.
1707
1708         $headertype = "none" if !$headertype;
1709
1710         if ($headertype eq "cookie"){
1711
1712                 my $username = shift;
1713                 my $seed = shift;
1714                 my $expires = shift;
1715
1716                 if (!$expires){
1717
1718                         $expires = 0;
1719
1720                 }
1721
1722                 # Get the date and time information.
1723
1724                 my ($exp_sec, $exp_min, $exp_hour, $exp_mday, $exp_mon, $exp_year, $exp_wday, $exp_yday, $exp_isdst) = localtime(time + $expires);
1725
1726                 my @month = qw(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec);
1727                 my @weekday = qw(Sun Mon Tue Wed Thu Fri Sat);
1728
1729                 $exp_sec        = "0" . $exp_sec if $exp_sec < 10;
1730                 $exp_min        = "0" . $exp_min if $exp_min < 10;
1731                 $exp_hour       = "0" . $exp_hour if $exp_hour < 10;
1732                 $exp_mday       = "0" . $exp_mday if $exp_mday < 10;
1733                 $exp_mon        = "0" . $exp_mon if $exp_mon < 10;
1734
1735                 my $expires_time = $weekday[$exp_wday] . ", " . $exp_mday . "-" . $month[$exp_mon]  . "-" . ($exp_year + 1900) . " " . $exp_hour . ":" . $exp_min . ":" . $exp_sec . " GMT";
1736
1737                 # Print out the cookies.
1738
1739                 print "Set-Cookie: " . $main::xestiascan_config{'database_tableprefix'} . "_auth_seed=" . $seed . "; expires="  . $expires_time ."\r\n";
1740                 print "Set-Cookie: " . $main::xestiascan_config{'database_tableprefix'} . "_auth_username=" . encode_base64url($username) . "; expires="  . $expires_time ."\r\n";
1741
1742         } elsif ($headertype eq "cookie_logout") {
1743
1744                 # Get the date and time information.
1745
1746                 my ($exp_sec, $exp_min, $exp_hour, $exp_mday, $exp_mon, $exp_year, $exp_wday, $exp_yday, $exp_isdst) = localtime(time - 100);
1747
1748                 my @month = qw(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec);
1749                 my @weekday = qw(Sun Mon Tue Wed Thu Fri Sat);
1750
1751                 $exp_sec        = "0" . $exp_sec if $exp_sec < 10;
1752                 $exp_min        = "0" . $exp_min if $exp_min < 10;
1753                 $exp_hour       = "0" . $exp_hour if $exp_hour < 10;
1754                 $exp_mday       = "0" . $exp_mday if $exp_mday < 10;
1755                 $exp_mon        = "0" . $exp_mon if $exp_mon < 10;
1756
1757                 my $expires_time = $weekday[$exp_wday] . ", " . $exp_mday . "-" . $month[$exp_mon]  . "-" . ($exp_year + 1900) . " " . $exp_hour . ":" . $exp_min . ":" . $exp_sec . " GMT";
1758
1759                 print "Set-Cookie: " . $main::xestiascan_config{'database_tableprefix'} . "_auth_seed=; expires="  . $expires_time ."\r\n";
1760                 print "Set-Cookie: " . $main::xestiascan_config{'database_tableprefix'} . "_auth_username=; expires="  . $expires_time ."\r\n";
1761
1762         }
1763
1764         #print "Set-Cookie: seed=$seed:username=" . $username . "; expires=" . $weekday[$exp_wday] . " " . $exp_mday . "-" . $month[$exp_mon] . "-" . ($exp_year + 1900) . " " . $exp_hour . ":" . $exp_min . ":" . $exp_sec . " GMT\r\n";
1765
1766         print "Content-Type: text/html; charset=utf-8\r\n";
1767         print "Expires: Sun, 01 Jan 2007 00:00:00 GMT\r\n\r\n";
1768
1769         return;
1770
1771 }
1772
1773 sub xestiascan_processfilename{
1774 #################################################################################
1775 # xestiascan_processfilename: Processes a name and turns it into a filename that#
1776 # can be used by Xestia Scanner Server.                                         #
1777 #                                                                               #
1778 # Usage:                                                                        #
1779 #                                                                               #
1780 # xestiascan_processfilename(text);                                             #
1781 #                                                                               #
1782 # text          Specifies the text to be used in the process for creating a new #
1783 #               filename.                                                       #
1784 #################################################################################
1785
1786         # Get the values that have been passed to the subroutine.
1787
1788         my ($process_text) = @_;
1789
1790         # Define some variables that will be used later on.
1791
1792         my $processed_stageone  = "";
1793         my $processed_stagetwo  = "";
1794         my $processed_length    = "";
1795         my $processed_char      = "";
1796         my $processed_seek      = 0;
1797         my $processed_filename  = "";
1798
1799         # Set the first stage value of the processed filename to the
1800         # process filename and then filter it out to only contain
1801         # numbers and letters (no spaces) and then convert the
1802         # capitals to small letters.
1803
1804         $processed_stageone = $process_text;
1805         $processed_stageone =~ tr#a-zA-Z0-9##cd;
1806         $processed_stageone =~ tr/A-Z/a-z/;
1807
1808         # Now set the second stage value of the processed filename
1809         # to the first stage value of the processed filename and
1810         # then limit the filename down to 32 characters.
1811
1812         $processed_stagetwo = $processed_stageone;
1813         $processed_length = length($processed_stagetwo);
1814
1815         # Process the second stage filename into the final
1816         # filename and do so until the seek counter is 32
1817         # or reaches the length of the second stage filename.
1818
1819         do {
1820
1821                 # Get the character that is the seek counter
1822                 # is set at.
1823
1824                 $processed_char = substr($processed_stagetwo, $processed_seek, 1);
1825
1826                 # Append to the final processed filename.
1827
1828                 $processed_filename = $processed_filename . $processed_char;
1829
1830                 # Increment the seek counter.
1831
1832                 $processed_seek++;
1833
1834         } until ($processed_seek eq 32 || $processed_seek eq $processed_length);
1835
1836         return $processed_filename;
1837
1838 }
1839
1840
1841 sub xestiascan_processconfig{
1842 #################################################################################
1843 # xestiascan_processconfig: Processes an INI style configuration file.          #
1844 #                                                                               #
1845 # Usage:                                                                        #
1846 #                                                                               #
1847 # xestiascan_processconfig(data);                                               #
1848 #                                                                               #
1849 # data  Specifies the data to process.                                          #
1850 #################################################################################
1851
1852         my (@settings) = @_;
1853
1854         my ($settings_line, %settings, $settings, $sectionname, $setting_name, $setting_value);
1855
1856         foreach $settings_line (@settings){
1857
1858                 next if !$settings_line;
1859
1860                 # Check if the first character is a bracket.
1861
1862                 if (substr($settings_line, 0, 1) eq "["){
1863                         $settings_line =~ s/\[//;
1864                         $settings_line =~ s/\](.*)//;
1865                         $settings_line =~ s/\n//;
1866                         $sectionname = $settings_line;
1867                         next;
1868                 }
1869
1870                 $setting_name  = $settings_line;
1871                 $setting_value = $settings_line;
1872                 $setting_name  =~ s/\=(.*)//;
1873                 $setting_name  =~ s/\n//;
1874                 $setting_value =~ s/(.*)\=//;
1875                 $setting_value =~ s/\n//;
1876
1877                 # Remove the spacing before and after the '=' sign.
1878
1879                 $setting_name =~ s/\s+$//;
1880                 $setting_value =~ s/^\s+//;
1881                 $setting_value =~ s/\r//;
1882
1883                 $settings{$sectionname}{$setting_name} = $setting_value;
1884
1885         }
1886
1887         return %settings;
1888
1889 }
1890
1891 sub xestiascan_output_page{
1892 #################################################################################
1893 # xestiascan_output_page: Outputs the page to the browser/stdout/console.       #
1894 #                                                                               #
1895 # Usage:                                                                        #
1896 #                                                                               #
1897 # xestiascan_output_page(pagetitle, pagedata, menutype);                        #
1898 #                                                                               #
1899 # pagetitle     Specifies the page title.                                       #
1900 # pagedata      Specifies the page data.                                        #
1901 # menutype      Prints out which menu to use.                                   #
1902 #################################################################################
1903
1904         my ($pagetitle, $pagedata, $menutype) = @_;
1905
1906         # Open the script page template and load it into the scriptpage variable,
1907         # while declaring the variable.
1908
1909         open (my $filehandle_scriptpage, "<:utf8", 'page.html');
1910         my @scriptpage = <$filehandle_scriptpage>;
1911         binmode $filehandle_scriptpage, ':utf8';
1912         close ($filehandle_scriptpage);
1913
1914         my $query_lite = new CGI::Lite;
1915         my $form_data = $query_lite->parse_form_data;
1916
1917         # Define the variables required.
1918
1919         my $scriptpageline = "";
1920         my $pageoutput = "";
1921
1922         $main::xestiascan_presmodule->clear();
1923
1924         # Print out the main menu for Xestia Scanner Server.
1925
1926         if ($menutype ne "none"){
1927
1928                 $main::xestiascan_presmodule->addlink($main::xestiascan_env{'script_filename'} . "?mode=scan", { Text => $main::xestiascan_lang{menu}{scanconfig} });
1929                 $main::xestiascan_presmodule->addtext(" | ");
1930                 $main::xestiascan_presmodule->addlink($main::xestiascan_env{'script_filename'} . "?mode=users", { Text => $main::xestiascan_lang{menu}{userconfig} });
1931                 $main::xestiascan_presmodule->addtext(" | ");
1932                 $main::xestiascan_presmodule->addlink($main::xestiascan_env{'script_filename'} . "?mode=settings", { Text => $main::xestiascan_lang{menu}{settingsconfig} });
1933                 $main::xestiascan_presmodule->addtext(" | ");
1934                 $main::xestiascan_presmodule->addlink($main::xestiascan_env{'script_filename'} . "?mode=logout", { Text => $main::xestiascan_lang{menu}{logout} });
1935
1936                 $main::xestiascan_presmodule->addlinebreak();
1937
1938         }
1939
1940         my $menuoutput = $main::xestiascan_presmodule->grab();
1941
1942         # Find <xestiascan> tages and replace with the apporiate variables.
1943
1944         foreach $scriptpageline (@scriptpage){
1945
1946                 $scriptpageline =~ s/<xestiascan:menu>/$menuoutput/g;
1947                 $scriptpageline =~ s/<xestiascan:imagespath>/$main::xestiascan_config{"directory_noncgi_images"}/g;
1948                 $scriptpageline =~ s/<xestiascan:pagedata>/$pagedata/g;
1949
1950                 # Check if page title specified is blank, otherwise add a page title
1951                 # to the title.
1952
1953                 if (!$pagetitle || $pagetitle eq ""){
1954                         $scriptpageline =~ s/<xestiascan:title>//g;
1955                 } else {
1956                         $scriptpageline =~ s/<xestiascan:title>/ ($pagetitle)/g;
1957                 }
1958
1959
1960
1961                 # Append processed line to the pageoutput variable.
1962
1963                 $pageoutput = $pageoutput . $scriptpageline;
1964
1965         }
1966
1967         print $pageoutput;
1968
1969         return;
1970
1971 }
1972
1973 1;