cgi-files/kiriwrite.cgi

   1 #!/usr/bin/perl -Tw
   2
   3 #################################################################################
   4 # Kiriwrite (kiriwrite.cgi)                                                     #
   5 # Main program script                                                           #
   6 #                                                                               #
   7 # Version: 0.1.0                                                                #
   8 #                                                                               #
   9 # Copyright (C) 2005-2007 Steve Brokenshire <sbrokenshire@xestia.co.uk>         #
  10 #                                                                               #
  11 # This program is free software; you can redistribute it and/or modify it under #
  12 # the terms of the GNU General Public License as published by the Free          #
  13 # Software Foundation; as version 2 of the License.                             #
  14 #                                                                               #
  15 # This program is distributed in the hope that it will be useful, but WITHOUT   #
  16 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS #
  17 # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.#
  18 #                                                                               #
  19 # You should have received a copy of the GNU General Public License along with  #
  20 # this program; if not, write to the Free Software Foundation, Inc., 51         #
  21 # Franklin St, Fifth Floor, Boston, MA 02110-1301 USA                           #
  22 #################################################################################
  23
  24 use strict;                             # Throw errors if there's something wrong.
  25 use warnings;                           # Write warnings to the HTTP Server Log file.
  26
  27 use utf8;
  28 use CGI::Lite;
  29 use Tie::IxHash;
  30
  31 # This is commented out because it uses a fair bit of CPU usage.
  32
  33 #use CGI::Carp('fatalsToBrowser');      # Output errors to the browser.
  34
  35 # Declare global variables for Kiriwrite settings and languages.
  36
  37 our ($kiriwrite_config, %kiriwrite_config, %kiriwrite_lang, $kiriwrite_lang, $kiriwrite_version, %kiriwrite_version, $kiriwrite_env, %kiriwrite_env, $kiriwrite_presmodule, $kiriwrite_dbmodule, $form_data);
  38
  39 # Setup the version information for Kiriwrite.
  40
  41 %kiriwrite_version = (
  42         "major"         => 0,
  43         "minor"         => 2,
  44         "revision"      => 0
  45 );
  46
  47 sub BEGIN{
  48 #################################################################################
  49 # BEGIN: Get the enviroment stuff                                               #
  50 #################################################################################
  51
  52         # Get the script filename.
  53
  54         my $env_script_name = $ENV{'SCRIPT_NAME'};
  55
  56         # Process the script filename until there is only the
  57         # filename itself.
  58
  59         my $env_script_name_length = length($env_script_name);
  60         my $filename_seek = 0;
  61         my $filename_char = "";
  62         my $filename_last = 0;
  63
  64         do {
  65                 $filename_char = substr($env_script_name, $filename_seek, 1);
  66                 if ($filename_char eq "/"){
  67                         $filename_last = $filename_seek + 1;
  68                 }
  69                 $filename_seek++;
  70         } until ($filename_seek eq $env_script_name_length || $env_script_name_length eq 0);
  71
  72         my $env_script_name_finallength = $env_script_name_length - $filename_last;
  73         my $script_filename = substr($env_script_name, $filename_last, $env_script_name_finallength);
  74
  75         # Setup the needed enviroment variables for Kiriwrite.
  76
  77         %kiriwrite_env = (
  78                 "script_filename" => $script_filename,
  79         );
  80
  81 }
  82
  83 #################################################################################
  84 # Begin listing the functions needed.                                           #
  85 #################################################################################
  86
  87 sub kiriwrite_selectedlist{
  88 #################################################################################
  89 # kiriwrite_page_selectedlist: Get the list of selected pages to use.           #
  90 #                                                                               #
  91 # Usage:                                                                        #
  92 #                                                                               #
  93 # kiriwrite_page_selectedlist();                                                #
  94 #################################################################################
  95
  96         my $count       = $form_data->{'count'};
  97
  98         # Check if the list of files has a value and if not set it 0.
  99
 100         if (!$count){
 101
 102                 $count = 0;
 103
 104         }
 105
 106         # Define some values for later.
 107
 108         my @filename_list;
 109         my @selected_list;
 110         my @final_list;
 111
 112         my $filename;
 113         my $selected;
 114
 115         my $final_count = 0;
 116         my $seek = 0;
 117
 118         # Get the list of filenames.
 119
 120         do {
 121
 122                 # Get the values from id[]
 123
 124                 $seek++;
 125
 126                 $filename               = $form_data->{'id[' . $seek . ']'};
 127                 $filename_list[$seek]   = $filename;
 128
 129         } until ($seek eq $count || $count eq 0);
 130
 131         # Get the list of selected filenames.
 132
 133         $seek = 0;
 134
 135         do {
 136
 137                 # Get the values from name[]
 138
 139                 $seek++;
 140
 141                 $selected       = $form_data->{'name[' . $seek . ']'};
 142
 143                 if (!$selected){
 144
 145                         $selected = 'off';
 146
 147                 }
 148
 149                 $selected_list[$seek]   = $selected;
 150
 151         } until ($seek eq $count || $count eq 0);
 152
 153         # Create a final list of filenames to be used for
 154         # processing.
 155
 156         $seek = 0;
 157
 158         do {
 159
 160                 # Check if the selected value is on and include
 161                 # the filename in the final list.
 162
 163                 $seek++;
 164
 165                 $selected       = $selected_list[$seek];
 166
 167                 if ($selected eq "on"){
 168
 169                         $filename       = $filename_list[$seek];
 170                         $final_list[$final_count] = $filename;
 171                         $final_count++;
 172
 173                 }
 174
 175         } until ($seek eq $count || $count eq 0);
 176
 177         return @final_list;
 178
 179 }
 180
 181 sub kiriwrite_settings_load{
 182 #################################################################################
 183 # kiriwrite_settings_load: Load the configuration settings into the global      #
 184 # variables.                                                                    #
 185 #                                                                               #
 186 # Usage:                                                                        #
 187 #                                                                               #
 188 # kiriwrite_settings_load();                                                    #
 189 #################################################################################
 190
 191         # Load the required Perl modules.
 192
 193         use Config::Auto;
 194
 195         # Check if the Kiriwrite configuration file exists before using it and
 196         # return an critical error if it doesn't exist.
 197
 198         my $kiriwrite_conf_exist = kiriwrite_fileexists("kiriwrite.cfg");
 199
 200         if ($kiriwrite_conf_exist eq 1){
 201
 202                 # The configuration really does not exist so return an critical error.
 203
 204                 kiriwrite_critical("configfilemissing");
 205
 206         }
 207
 208         # Check if the Kiriwrite configuration file has valid permission settings
 209         # before using it and return an critical error if it doesn't have the
 210         # valid permission settings.
 211
 212         my $kiriwrite_conf_permissions = kiriwrite_filepermissions("kiriwrite.cfg", 1, 0);
 213
 214         if ($kiriwrite_conf_permissions eq 1){
 215
 216                 # The permission settings for the Kiriwrite configuration file are
 217                 # invalid, so return an critical error.
 218
 219                 kiriwrite_critical("configfileinvalidpermissions");
 220
 221         }
 222
 223         # Converts the XML file into meaningful data for later on in this subroutine.
 224
 225         my $kiriwrite_conf_file = 'kiriwrite.cfg';
 226         my $config = Config::Auto::parse($kiriwrite_conf_file, format => "ini");
 227
 228         # Go and fetch the settings and place them into a hash (that is global).
 229
 230         %kiriwrite_config = (
 231
 232                 "directory_data_db"             => $config->{config}{directory_data_db},
 233                 "directory_data_output"         => $config->{config}{directory_data_output},
 234                 "directory_noncgi_images"       => $config->{config}{directory_noncgi_images},
 235
 236                 "system_language"               => $config->{config}{system_language},
 237                 "system_presmodule"             => $config->{config}{system_presmodule},
 238                 "system_dbmodule"               => $config->{config}{system_dbmodule},
 239                 "system_datetime"               => $config->{config}{system_datetime},
 240
 241                 "display_textarearows"          => $config->{config}{display_textarearows},
 242                 "display_textareacols"          => $config->{config}{display_textareacols},
 243
 244                 "database_server"               => $config->{config}{database_server},
 245                 "database_port"                 => $config->{config}{database_port},
 246                 "database_protocol"             => $config->{config}{database_protocol},
 247                 "database_sqldatabase"          => $config->{config}{database_sqldatabase},
 248                 "database_username"             => $config->{config}{database_username},
 249                 "database_password"             => $config->{config}{database_password},
 250                 "database_tableprefix"          => $config->{config}{database_tableprefix}
 251
 252         );
 253
 254         # Do a validation check on all of the variables that were loaded into the global configuration hash.
 255
 256         kiriwrite_variablecheck($kiriwrite_config{"directory_data_db"}, "maxlength", 64, 0);
 257         kiriwrite_variablecheck($kiriwrite_config{"directory_data_output"}, "maxlength", 64, 0);
 258         kiriwrite_variablecheck($kiriwrite_config{"directory_noncgi_images"}, "maxlength", 512, 0);
 259         kiriwrite_variablecheck($kiriwrite_config{"directory_data_template"}, "maxlength", 64, 0);
 260
 261         my $kiriwrite_config_language_filename = kiriwrite_variablecheck($kiriwrite_config{"system_language"}, "language_filename", "", 1);
 262         my $kiriwrite_config_presmodule_filename = kiriwrite_variablecheck($kiriwrite_config{"system_presmodule"}, "module", 0, 1);
 263         my $kiriwrite_config_dbmodule_filename = kiriwrite_variablecheck($kiriwrite_config{"system_dbmodule"}, "module", 0, 1);
 264
 265         my $kiriwrite_config_textarearows_maxlength = kiriwrite_variablecheck($kiriwrite_config{"display_textarearows"}, "maxlength", 3, 1);
 266         my $kiriwrite_config_textarearows_number = kiriwrite_variablecheck($kiriwrite_config{"display_textareacols"}, "numbers", 0, 1);
 267         my $kiriwrite_config_textareacols_maxlength = kiriwrite_variablecheck($kiriwrite_config{"display_textareacols"}, "maxlength", 3, 1);
 268         my $kiriwrite_config_textareacols_number = kiriwrite_variablecheck($kiriwrite_config{"display_textareacols"}, "numbers", 0, 1);
 269
 270         # Check if the language filename is valid and return an critical error if
 271         # they aren't.
 272
 273         if ($kiriwrite_config_language_filename eq 1){
 274
 275                 # The language filename is blank so return an critical error.
 276
 277                 kiriwrite_critical("languagefilenameblank");
 278
 279         } elsif ($kiriwrite_config_language_filename eq 2){
 280
 281                 # The language filename is invalid so return an critical error.
 282
 283                 kiriwrite_critical("languagefilenameinvalid");
 284
 285         }
 286
 287         # Check if the presentation and database module names are valid and return a critical
 288         # error if they aren't.
 289
 290         if ($kiriwrite_config_presmodule_filename eq 1){
 291
 292                 # The presentation module filename given is blank so return an
 293                 # critical error.
 294
 295                 kiriwrite_critical("presmoduleblank");
 296
 297         }
 298
 299         if ($kiriwrite_config_presmodule_filename eq 2){
 300
 301                 # The presentation module filename is invalid so return an
 302                 # critical error.
 303
 304                 kiriwrite_critical("presmoduleinvalid");
 305
 306         }
 307
 308         if ($kiriwrite_config_dbmodule_filename eq 1){
 309
 310                 # The database module filename given is blank so return an
 311                 # critical error.
 312
 313                 kiriwrite_critical("dbmoduleblank");
 314
 315         }
 316
 317         if ($kiriwrite_config_dbmodule_filename eq 2){
 318
 319                 # The database module filename given is invalid so return
 320                 # an critical error.
 321
 322                 kiriwrite_critical("dbmoduleinvalid");
 323
 324         }
 325
 326         # Check if the text area column and row values are blank and return a critical
 327         # error if they are.
 328
 329         if (!$kiriwrite_config{"display_textarearows"}){
 330
 331                 # The text area row value is blank so return
 332                 # a critical error.
 333
 334                 kiriwrite_critical("textarearowblank");
 335
 336         }
 337
 338         if (!$kiriwrite_config{"display_textareacols"}){
 339
 340                 # The text area column value is blank so return
 341                 # a critical error.
 342
 343                 kiriwrite_critical("textareacolblank");
 344
 345         }
 346
 347         # Check if the text area column and row values to see if they are valid and return
 348         # a critical error if they aren't.
 349
 350         if ($kiriwrite_config_textarearows_maxlength eq 1){
 351
 352                 # The text area row value is too long so return an
 353                 # critical error.
 354
 355                 kiriwrite_critical("textarearowtoolong");
 356
 357         }
 358
 359         if ($kiriwrite_config_textarearows_number eq 1){
 360
 361                 # The text area row value is invalid so return an
 362                 # critical error.
 363
 364                 kiriwrite_critical("textarearowinvalid");
 365
 366         }
 367
 368         if ($kiriwrite_config_textareacols_maxlength eq 1){
 369
 370                 # The text area column value is too long so return
 371                 # an critical error.
 372
 373                 kiriwrite_critical("textareacoltoolong");
 374
 375         }
 376
 377         if ($kiriwrite_config_textareacols_number eq 1){
 378
 379                 # The text area column value is invalid so return
 380                 # an critical error.
 381
 382                 kiriwrite_critical("textareacolinvalid");
 383
 384         }
 385
 386         # Check if the language file does exist before loading it and return an critical error
 387         # if it does not exist.
 388
 389         my $kiriwrite_config_language_fileexists = kiriwrite_fileexists("lang/" . $kiriwrite_config{"system_language"} . ".lang");
 390
 391         if ($kiriwrite_config_language_fileexists eq 1){
 392
 393                 # Language file does not exist so return an critical error.
 394
 395                 kiriwrite_critical("languagefilemissing");
 396
 397         }
 398
 399         # Check if the language file has valid permission settings and return an critical error if
 400         # the language file has invalid permissions settings.
 401
 402         my $kiriwrite_config_language_filepermissions = kiriwrite_filepermissions("lang/" . $kiriwrite_config{"system_language"} . ".lang", 1, 0);
 403
 404         if ($kiriwrite_config_language_filepermissions eq 1){
 405
 406                 # Language file contains invalid permissions so return an critical error.
 407
 408                 kiriwrite_critical("languagefilenameinvalidpermissions");
 409
 410         }
 411
 412         # Load the language file.
 413
 414         $kiriwrite_lang = Config::Auto::parse("lang/" . $kiriwrite_config{"system_language"} . ".lang", format => "ini");
 415
 416         # Check if the presentation module does exist before loading it and return an critical error
 417         # if the presentation module does not exist.
 418
 419         my $kiriwrite_config_presmodule_fileexists = kiriwrite_fileexists("Modules/Presentation/" . $kiriwrite_config{"system_presmodule"} . ".pm");
 420
 421         if ($kiriwrite_config_presmodule_fileexists eq 1){
 422
 423                 # Presentation module does not exist so return an critical error.
 424
 425                 kiriwrite_critical("presmodulemissing");
 426
 427         }
 428
 429         # Check if the presentation module does have the valid permission settings and return a
 430         # critical error if the presentation module contains invalid permission settings.
 431
 432         my $kiriwrite_config_presmodule_permissions = kiriwrite_filepermissions("Modules/Presentation/" . $kiriwrite_config{"system_presmodule"} . ".pm", 1, 0);
 433
 434         if ($kiriwrite_config_presmodule_permissions eq 1){
 435
 436                 # Presentation module contains invalid permissions so return an critical error.
 437
 438                 kiriwrite_critical("presmoduleinvalidpermissions");
 439
 440         }
 441
 442         # Check if the database module does exist before loading it and return an critical error
 443         # if the database module does not exist.
 444
 445         my $kiriwrite_config_dbmodule_fileexists = kiriwrite_fileexists("Modules/Database/" . $kiriwrite_config{"system_dbmodule"} . ".pm");
 446
 447         if ($kiriwrite_config_dbmodule_fileexists eq 1){
 448
 449                 # Database module does not exist so return an critical error.
 450
 451                 kiriwrite_critical("dbmodulemissing");
 452
 453         }
 454
 455         # Check if the database module does have the valid permission settings and return an
 456         # critical error if the database module contains invalid permission settings.
 457
 458         my $kiriwrite_config_dbmodule_permissions = kiriwrite_filepermissions("Modules/Database/" . $kiriwrite_config{"system_dbmodule"} . ".pm", 1, 0);
 459
 460         if ($kiriwrite_config_dbmodule_permissions eq 1){
 461
 462                 # Presentation module contains invalid permissions so return an critical error.
 463
 464                 kiriwrite_critical("dbmoduleinvalidpermissions");
 465
 466         }
 467
 468         # Include the Modules directory.
 469
 470         use lib "Modules/";
 471
 472         # Load the presentation module.
 473
 474         my $presmodulename = "Presentation::" . $kiriwrite_config{"system_presmodule"};
 475         ($presmodulename) = $presmodulename =~ m/^(.*)$/g;
 476         eval "use " . $presmodulename;
 477         $presmodulename = "Kiriwrite::Presentation::" . $kiriwrite_config{"system_presmodule"};
 478         $kiriwrite_presmodule = $presmodulename->new();
 479
 480         # Load the database module.
 481
 482         my $dbmodulename = "Database::" . $kiriwrite_config{"system_dbmodule"};
 483         ($dbmodulename) = $dbmodulename =~ m/^(.*)$/g;
 484         eval "use " . $dbmodulename;
 485         $dbmodulename = "Kiriwrite::Database::" . $kiriwrite_config{"system_dbmodule"};
 486         $kiriwrite_dbmodule = $dbmodulename->new();
 487
 488         # Load the following settings to the database module.
 489
 490         $kiriwrite_dbmodule->loadsettings({ Directory => $kiriwrite_config{"directory_data_db"}, DateTime => $kiriwrite_config{"system_datetime"}, Server => $kiriwrite_config{"database_server"}, Port => $kiriwrite_config{"database_port"}, Protocol => $kiriwrite_config{"database_protocol"}, Database => $kiriwrite_config{"database_sqldatabase"}, Username => $kiriwrite_config{"database_username"}, Password => $kiriwrite_config{"database_password"}, TablePrefix => $kiriwrite_config{"database_tableprefix"} });
 491
 492         return;
 493
 494 }
 495
 496 sub kiriwrite_variablecheck{
 497 #################################################################################
 498 # kiriwrite_variablecheck: Checks the variables for any invalid characters.     #
 499 #                                                                               #
 500 # Usage:                                                                        #
 501 #                                                                               #
 502 # kiriwrite_variablecheck(variable, type, length, noerror);                     #
 503 #                                                                               #
 504 # variable      Specifies the variable to be checked.                           #
 505 # type          Specifies what type the variable is.                            #
 506 # option        Specifies the maximum/minimum length of the variable            #
 507 #               (if minlength/maxlength is used) or if the filename should be   #
 508 #               checked to see if it is blank.                                  #
 509 # noerror       Specifies if Kiriwrite should return an error or not on         #
 510 #               certain values.                                                 #
 511 #################################################################################
 512
 513         # Get the values that were passed to the subroutine.
 514
 515         my ($variable_data, $variable_type, $variable_option, $variable_noerror) = @_;
 516
 517         if ($variable_type eq "numbers"){
 518
 519                 # Check for numbers and return an error if there is anything else than numebrs.
 520
 521                 my $variable_data_validated = $variable_data;   # Copy the variable_data to variable_data_validated.
 522                 $variable_data_validated =~ tr/0-9//d;          # Take away all of the numbers and from the variable.
 523                                                                 # If it only contains numbers then it should be blank.
 524
 525                 if ($variable_data_validated eq ""){
 526                         # The validated variable is blank. So continue to the end of this section where the return function should be.
 527                 } else {
 528                         # The variable is not blank, so check if the no error value is set
 529                         # to 1 or not.
 530
 531                         if ($variable_noerror eq 1){
 532
 533                                 # The validated variable is not blank and the noerror
 534                                 # value is set to 1. So return an value of 1.
 535                                 # (meaning that the data is invalid).
 536
 537                                 return 1;
 538
 539                         } elsif ($variable_noerror eq 0) {
 540
 541                                 # The validated variable is not blank and the noerror
 542                                 # value is set to 0.
 543
 544                                 kiriwrite_error("invalidvariable");
 545
 546                         } else {
 547
 548                                 # The variable noerror value is something else
 549                                 # pther than 1 or 0. So return an error.
 550
 551                                 kiriwrite_error("invalidvariable");
 552
 553                         }
 554
 555                 }
 556
 557                 return 0;
 558
 559         } elsif ($variable_type eq "lettersnumbers"){
 560
 561                 # Check for letters and numbers and return an error if there is anything else other
 562                 # than letters and numbers.
 563
 564                 my $variable_data_validated = $variable_data;   # Copy the variable_data to variable_data_validated
 565                 $variable_data_validated =~ tr/a-zA-Z0-9.//d;
 566                 $variable_data_validated =~ s/\s//g;
 567
 568                 if ($variable_data_validated eq ""){
 569                         # The validated variable is blank. So continue to the end of this section where the return function should be.
 570                 } else {
 571                         # The variable is not blank, so check if the no error value is set
 572                         # to 1 or not.
 573
 574                         if ($variable_noerror eq 1){
 575
 576                                 # The validated variable is not blank and the noerror
 577                                 # value is set to 1. So return an value of 1.
 578                                 # (meaning that the data is invalid).
 579
 580                                 return 1;
 581
 582                         } elsif ($variable_noerror eq 0) {
 583
 584                                 # The validated variable is not blank and the noerror
 585                                 # value is set to 0.
 586
 587                                 kiriwrite_error("invalidvariable");
 588
 589                         } else {
 590
 591                                 # The variable noerror value is something else
 592                                 # pther than 1 or 0. So return an error.
 593
 594                                 kiriwrite_error("invalidvariable");
 595
 596                         }
 597
 598                 }
 599
 600                 return 0;
 601
 602         } elsif ($variable_type eq "maxlength"){
 603                 # Check for the length of the variable, return an error if it is longer than the length specified.
 604
 605                 # Check if the variable_data string is blank, if it is then set the variable_data_length
 606                 # to '0'.
 607
 608                 my $variable_data_length = 0;
 609
 610                 if (!$variable_data){
 611
 612                         # Set variable_data_length to '0'.
 613                         $variable_data_length = 0;
 614
 615                 } else {
 616
 617                         # Get the length of the variable recieved.
 618                         $variable_data_length = length($variable_data);
 619
 620                 }
 621
 622
 623
 624                 if ($variable_data_length > $variable_option){
 625
 626                         # The variable length is longer than it should be so check if
 627                         # the no error value is set 1.
 628
 629                         if ($variable_noerror eq 1){
 630
 631                                 # The no error value is set to 1, so return an
 632                                 # value of 1 (meaning tha the variable is
 633                                 # too long to be used).
 634
 635                                 return 1;
 636
 637                         } elsif ($variable_noerror eq 0){
 638
 639                                 # The no error value is set to 0, so return
 640                                 # an error.
 641
 642                                 kiriwrite_error("variabletoolong");
 643
 644                         } else {
 645
 646                                 # The no error value is something else other
 647                                 # than 0 or 1, so return an error.
 648
 649                                 kiriwrite_error("variabletoolong");
 650
 651                         }
 652
 653                 } else {
 654
 655                         # The variable length is exactly or shorter than specified, so continue to end of this section where
 656                         # the return function should be.
 657
 658                 }
 659
 660                 return 0;
 661
 662         } elsif ($variable_type eq "blank"){
 663                 # Check if the variable is blank and if it is blank, then return an error.
 664
 665                 if (!$variable_data){
 666
 667                         # The variable data really is blank, so check what
 668                         # the no error value is set.
 669
 670                         if ($variable_noerror eq 1){
 671
 672                                 # The no error value is set to 1, so return
 673                                 # a value of 1 (saying that the variable was
 674                                 # blank).
 675
 676                                 return 1;
 677
 678                         } elsif ($variable_noerror eq 0){
 679
 680                                 # The no error value is set to 0, so return
 681                                 # an error.
 682
 683                                 kiriwrite_error("blankvariable");
 684
 685                         } else {
 686
 687                                 # The no error value is something else other
 688                                 # than 0 or 1, so return an error.
 689
 690                                 kiriwrite_error("invalidvariable");
 691
 692                         }
 693
 694                 }
 695
 696                 return 0;
 697
 698         } elsif ($variable_type eq "filename"){
 699                 # Check for letters and numbers, if anything else than letters and numbers is there (including spaces) return
 700                 # an error.
 701
 702                 # Check if the filename passed is blank, if it is then return with an error.
 703
 704                 if ($variable_data eq ""){
 705
 706                         # The filename specified is blank, so check what the
 707                         # noerror value is set.
 708
 709                         if ($variable_noerror eq 1){
 710
 711                                 # The no error value is set to 1 so return
 712                                 # a value of 1 (meaning that the filename
 713                                 # was blank).
 714
 715                                 return 1;
 716
 717                         } elsif ($variable_noerror eq 0){
 718
 719                                 # The no error value is set to 1 so return
 720                                 # an error.
 721
 722                                 kiriwrite_error("blankfilename");
 723
 724                         } else {
 725
 726                                 # The no error value is something else other
 727                                 # than 0 or 1, so return an error.
 728
 729                                 kiriwrite_error("invalidvariable");
 730
 731                         }
 732
 733                 } else {
 734
 735
 736                 }
 737
 738                 my $variable_data_validated = $variable_data;
 739                 $variable_data_validated =~ tr/a-zA-Z0-9\.//d;
 740
 741                 # Check if the validated data variable is blank, if it is
 742                 # then continue to the end of this section where the return
 743                 # function should be, otherwise return an error.
 744
 745                 if ($variable_data_validated eq ""){
 746
 747                         # The validated data variable is blank, meaning that
 748                         # it only contained letters and numbers.
 749
 750                 } else {
 751
 752                         # The validated data variable is not blank, meaning
 753                         # that it contains something else, so return an error
 754                         # (or a value).
 755
 756                         if ($variable_noerror eq 1){
 757
 758                                 # The no error value is set to 1 so return
 759                                 # an value of 2. (meaning that the filename
 760                                 # is invalid).
 761
 762
 763                                 return 2;
 764
 765                         } elsif ($variable_noerror eq 0){
 766
 767                                 # The no error value is set to 0 so return
 768                                 # an error.
 769
 770                                 kiriwrite_error("invalidfilename");
 771
 772                         } else {
 773
 774                                 # The no error value is something else other
 775                                 # than 0 or 1 so return an error.
 776
 777                                 kiriwrite_error("invalidvariable");
 778
 779                         }
 780
 781                 }
 782
 783                 return 0;
 784
 785         } elsif ($variable_type eq "filenameindir"){
 786                 # Check if the filename is in the directory and return an
 787                 # error if it isn't.
 788
 789                 if ($variable_data eq ""){
 790
 791                         # The filename specified is blank, so check what the
 792                         # noerror value is set.
 793
 794                         if ($variable_noerror eq 1){
 795
 796                                 # The no error value is set to 1 so return
 797                                 # a value of 1 (meaning that the filename
 798                                 # was blank).
 799
 800                                 return 1;
 801
 802                         } elsif ($variable_noerror eq 0){
 803
 804                                 # The no error value is set to 1 so return
 805                                 # an error.
 806
 807                                 kiriwrite_error("blankfilename");
 808
 809                         } else {
 810
 811                                 # The no error value is something else other
 812                                 # than 0 or 1, so return an error.
 813
 814                                 kiriwrite_error("invalidvariable");
 815
 816                         }
 817
 818                 } else {
 819
 820
 821                 }
 822
 823                 # Set the following variables for later on.
 824
 825                 my $variable_data_length = 0;
 826                 my $variable_data_char = "";
 827                 my $variable_data_validated = "";
 828                 my $variable_data_seek = 0;
 829                 my $variable_database_list = "";
 830                 my $variable_database_listcurrent = "";
 831                 my $variable_data_firstlevel = 1;
 832
 833                 # Get the length of the variable recieved.
 834
 835                 $variable_data_length = length($variable_data);
 836
 837                 # Check if the database filename contains the directory command
 838                 # for up a directory level and if it is, return an error
 839                 # or return with a number.
 840
 841                 do {
 842
 843                         # Get a character from the filename passed to this subroutine.
 844
 845                         $variable_data_char = substr($variable_data, $variable_data_seek, 1);
 846
 847                         # Check if the current character is the forward slash character.
 848
 849                         if ($variable_data_char eq "/"){
 850
 851                                 # Check if the current directory is blank (and on the first level), or if the
 852                                 # current directory contains two dots or one dot, if it does return an error.
 853
 854                                 if ($variable_database_listcurrent eq "" && $variable_data_firstlevel eq 1 || $variable_database_listcurrent eq ".." || $variable_database_listcurrent eq "."){
 855
 856                                         # Check if the noerror value is set to 1, if it is return an
 857                                         # number, else return an proper error.
 858
 859                                         if ($variable_noerror eq 1){
 860
 861                                                 # Page filename contains invalid characters and
 862                                                 # the no error value is set to 1 so return a
 863                                                 # value of 2 (meaning that the page filename
 864                                                 # is invalid).
 865
 866                                                 return 2;
 867
 868                                         } elsif ($variable_noerror eq 0) {
 869
 870                                                 # Page filename contains invalid characters and
 871                                                 # the no error value is set to 0 so return an
 872                                                 # error.
 873
 874                                                 kiriwrite_error("invalidfilename");
 875
 876                                         } else {
 877
 878                                                 # The no error value is something else other
 879                                                 # than 0 or 1 so return an error.
 880
 881                                                 kiriwrite_error("invalidvariable");
 882
 883                                         }
 884
 885                                 }
 886
 887                                 # Append the forward slash, clear the current directory name and set
 888                                 # the first directory level value to 0.
 889
 890                                 $variable_database_list = $variable_database_list . $variable_data_char;
 891                                 $variable_database_listcurrent = "";
 892                                 $variable_data_firstlevel = 0;
 893
 894                         } else {
 895
 896                                 # Append the current character to the directory name and to the current
 897                                 # directory name.
 898
 899                                 $variable_database_list = $variable_database_list . $variable_data_char;
 900                                 $variable_database_listcurrent = $variable_database_listcurrent . $variable_data_char;
 901
 902                         }
 903
 904                         # Increment the seek counter.
 905
 906                         $variable_data_seek++;
 907
 908                 } until ($variable_data_seek eq $variable_data_length);
 909
 910                 return 0;
 911
 912         } elsif ($variable_type eq "datetime"){
 913                 # Check if the date and time setting format is valid.
 914
 915                 if ($variable_data eq ""){
 916
 917                         if ($variable_noerror eq 1){
 918
 919                                 # The no error value is set to 1 so return
 920                                 # a value of 1 (meaning that the date and
 921                                 # time format was blank).
 922
 923                                 return 1;
 924
 925                         } elsif ($variable_noerror eq 0){
 926
 927                                 # The no error value is set to 1 so return
 928                                 # an error.
 929
 930                                 kiriwrite_error("blankdatetimeformat");
 931
 932                         } else {
 933
 934                                 # The no error value is something else other
 935                                 # than 0 or 1, so return an error.
 936
 937                                 kiriwrite_error("invalidvariable");
 938
 939                         }
 940
 941                 }
 942
 943                 my $variable_data_validated = $variable_data;
 944                 $variable_data_validated =~ tr|dDmMyYhms/():[ ]||d;
 945
 946                 if ($variable_data_validated eq ""){
 947
 948                         # The date and time format is valid. So
 949                         # skip this bit.
 950
 951                 } else {
 952
 953                         # The validated data variable is not blank, meaning
 954                         # that it contains something else, so return an error
 955                         # (or a value).
 956
 957                         if ($variable_noerror eq 1){
 958
 959                                 # The no error value is set to 1 so return
 960                                 # an value of 2. (meaning that the date and
 961                                 # time format was invalid).
 962
 963                                 return 2;
 964
 965                         } elsif ($variable_noerror eq 0){
 966
 967                                 # The no error value is set to 0 so return
 968                                 # an error.
 969
 970                                 kiriwrite_error("invaliddatetimeformat");
 971
 972                         } else {
 973
 974                                 # The no error value is something else other
 975                                 # than 0 or 1 so return an error.
 976
 977                                 kiriwrite_error("invalidvariable");
 978
 979                         }
 980
 981                 }
 982
 983                 return 0;
 984
 985         } elsif ($variable_type eq "directory"){
 986                 # Check if the directory only contains letters and numbers and
 987                 # return an error if anything else appears.
 988
 989                 my $variable_data_validated = $variable_data;
 990                 $variable_data_validated =~ tr/a-zA-Z0-9//d;
 991
 992                 if ($variable_data eq ""){
 993
 994                         if ($variable_noerror eq 1){
 995
 996                                 # The no error value is set to 1 so return
 997                                 # a value of 1 (meaning that the directory
 998                                 # name was blank).
 999
1000                                 return 1;
1001
1002                         } elsif ($variable_noerror eq 0){
1003
1004                                 # The no error value is set to 1 so return
1005                                 # an error.
1006
1007                                 kiriwrite_error("blankdirectory");
1008
1009                         } else {
1010
1011                                 # The no error value is something else other
1012                                 # than 0 or 1, so return an error.
1013
1014                                 kiriwrite_error("invalidvariable");
1015
1016                         }
1017
1018                 }
1019
1020                 if ($variable_data_validated eq ""){
1021
1022                         # The validated data variable is blank, meaning that
1023                         # it only contains letters and numbers.
1024
1025                 } else {
1026
1027                         # The validated data variable is not blank, meaning
1028                         # that it contains something else, so return an error
1029                         # (or a value).
1030
1031                         if ($variable_noerror eq 1){
1032
1033                                 # The no error value is set to 1 so return
1034                                 # an value of 2. (meaning that the directory
1035                                 # name is invalid).
1036
1037                                 return 2;
1038
1039                         } elsif ($variable_noerror eq 0){
1040
1041                                 # The no error value is set to 0 so return
1042                                 # an error.
1043
1044                                 kiriwrite_error("invaliddirectory");
1045
1046                         } else {
1047
1048                                 # The no error value is something else other
1049                                 # than 0 or 1 so return an error.
1050
1051                                 kiriwrite_error("invalidvariable");
1052
1053                         }
1054
1055                 }
1056
1057                 return 0;
1058
1059         } elsif ($variable_type eq "language_filename"){
1060
1061                 # The variable type is a language filename type.
1062                 # Check if the language file name is blank and
1063                 # if it is then return an error (or value).
1064
1065                 if ($variable_data eq ""){
1066
1067                         # The language filename is blank so check the
1068                         # no error value and return an error (or value).
1069
1070                         if ($variable_noerror eq 1){
1071
1072                                 # Language filename is blank and the no error value
1073                                 # is set as 1, so return a value of 1 (saying that
1074                                 # the language filename is blank).
1075
1076                                 return 1;
1077
1078                         } elsif ($variable_noerror eq 0) {
1079
1080                                 # Language filename is blank and the no error value
1081                                 # is not set as 1, so return an error.
1082
1083                                 kiriwrite_critical("languagefilenameblank");
1084
1085                         } else {
1086
1087                                 # The noerror value is something else other
1088                                 # than 0 or 1 so return an error.
1089
1090                                 kiriwrite_error("invalidvariable");
1091
1092                         }
1093
1094                 }
1095
1096                 # Set the following variables for later on.
1097
1098                 my $variable_data_length = 0;
1099                 my $variable_data_char = "";
1100                 my $variable_data_seek = 0;
1101
1102                 # Get the length of the language file name.
1103
1104                 $variable_data_length = length($variable_data);
1105
1106                 do {
1107
1108                         # Get a character from the language filename passed to this
1109                         # subroutine and the character the seek counter value is set
1110                         # to.
1111
1112                         $variable_data_char = substr($variable_data, $variable_data_seek, 1);
1113
1114                         # Check if the language filename contains a forward slash or a dot,
1115                         # if the selected character is a forward slash then return an error
1116                         # (or value).
1117
1118                         if ($variable_data_char eq "/" || $variable_data_char eq "."){
1119
1120                                 # The language filename contains a forward slash or
1121                                 # a dot so depending on the no error value, return
1122                                 # an error or a value.
1123
1124                                 if ($variable_noerror eq 1){
1125
1126                                         # Language filename contains a forward slash or a dot
1127                                         # and the no error value has been set to 1, so return
1128                                         # an value of 2 (saying that the language file name is
1129                                         # invalid).
1130
1131                                         return 2;
1132
1133                                 } elsif ($variable_noerror eq 0) {
1134
1135                                         # Language filename contains a forward slash and the no
1136                                         # error value has not been set to 1, so return an error.
1137
1138                                         kiriwrite_critical("languagefilenameinvalid");
1139
1140                                 } else {
1141
1142                                         # The noerror value is something else other than
1143                                         # 1 or 0 so return an error.
1144
1145                                         kiriwrite_error("invalidvariable");
1146
1147                                 }
1148
1149                         }
1150
1151                         # Increment the seek counter.
1152
1153                         $variable_data_seek++;
1154
1155                 } until ($variable_data_seek eq $variable_data_length);
1156
1157                 return 0;
1158
1159         } elsif ($variable_type eq "pagesetting"){
1160
1161                 # The variable type is a page setting, so check if the page
1162                 # setting has one of the valid options.
1163
1164                 if ($variable_data eq 0 || $variable_data eq 1 || $variable_data eq 2 || $variable_data eq 3){
1165
1166                         # The variable is one of the options above, so continue
1167                         # to the end of this section.
1168
1169                 } else {
1170
1171                         # The variable is not one of the options above, so check
1172                         # and see if a error or a value should be returned.
1173
1174                         if ($variable_noerror eq 1){
1175
1176                                 # The page setting is invalid and the no error
1177                                 # value is set 1, so return a value of 1
1178                                 # (saying that the page setting value is
1179                                 # invalid).
1180
1181                                 return 1;
1182
1183                         } elsif ($variable_noerror eq 0) {
1184
1185                                 # Page setting is invalid and the no error value
1186                                 # is not 1, so return an error.
1187
1188                                 kiriwrite_error("invalidvariable");
1189
1190                         } else {
1191
1192                                 # The no error value is something else other
1193                                 # than 0 or 1 so return an error.
1194
1195                                 kiriwrite_error("invalidvariable");
1196
1197                         }
1198
1199                 }
1200
1201                 return 0;
1202
1203         } elsif ($variable_type eq "page_filename"){
1204
1205                 # The variable type is a page filename type. Check
1206                 # if the data is empty and if it is then return an
1207                 # error (or value).
1208
1209                 if ($variable_data eq ""){
1210
1211                         # The filename is blank so check the no error
1212                         # value and depending on it return an value
1213                         # or an error.
1214
1215                         if ($variable_noerror eq 1){
1216
1217                                 # Page filename is blank and the no error value
1218                                 # is set as 1, so return a value of 1 (saying
1219                                 # the filename is blank).
1220
1221                                 return 1;
1222
1223                         } elsif ($variable_noerror eq 0) {
1224
1225                                 # Page filename is blank and the no error value
1226                                 # is not 1, so return an error.
1227
1228                                 kiriwrite_error("emptypagefilename");
1229
1230                         } else {
1231
1232                                 # The no error value is something else other
1233                                 # than 0 or 1 so return an error.
1234
1235                                 kiriwrite_error("invalidvariable");
1236
1237                         }
1238                 }
1239
1240                 # Set the following variables for later on.
1241
1242
1243                 my $variable_data_length = 0;
1244                 my $variable_data_slash = 0;
1245                 my $variable_data_char = "";
1246                 my $variable_data_validated = "";
1247                 my $variable_data_seek = 0;
1248                 my $variable_database_list = "";
1249                 my $variable_database_listcurrent = "";
1250                 my $variable_data_firstlevel = 1;
1251
1252                 # Get the length of the filename.
1253
1254                 $variable_data_length = length($variable_data);
1255
1256                 # Check that only valid characters should be appearing in
1257                 # the filename.
1258
1259                 $variable_data_validated = $variable_data;
1260                 $variable_data_validated =~ tr|a-zA-Z0-9\.\/\-_||d;
1261
1262                 if ($variable_data_validated ne ""){
1263
1264                         # The validated variable is not blank, meaning the
1265                         # variable contains invalid characters, so return
1266                         # an error.
1267
1268                         if ($variable_noerror eq 1){
1269
1270                                 # Page filename contains invalid characters and
1271                                 # the no error value is set to 1 so return a
1272                                 # value of 2 (meaning that the page filename
1273                                 # is invalid).
1274
1275                                 return 2;
1276
1277                         } elsif ($variable_noerror eq 0) {
1278
1279                                 # Page filename contains invalid characters and
1280                                 # the no error value is set to 0 so return an
1281                                 # error.
1282
1283                                 kiriwrite_error("invalidfilename");
1284
1285                         } else {
1286
1287                                 # The no error value is something else other
1288                                 # than 0 or 1 so return an error.
1289
1290                                 kiriwrite_error("invalidvariable");
1291
1292                         }
1293
1294                 }
1295
1296                 # Check if the page filename contains the directory command
1297                 # for up a directory level and if it is, return an error
1298                 # or return with a number.
1299
1300                 do {
1301
1302                         # Get a character from the filename passed to this subroutine.
1303
1304                         $variable_data_char = substr($variable_data, $variable_data_seek, 1);
1305
1306                         # Check if the current character is the forward slash character.
1307
1308                         if ($variable_data_char eq "/"){
1309
1310                                 # Check if the current directory is blank (and on the first level), or if the
1311                                 # current directory contains two dots or one dot, if it does return an error.
1312
1313                                 $variable_data_slash = 1;
1314
1315                                 if ($variable_database_listcurrent eq "" && $variable_data_firstlevel eq 1 || $variable_database_listcurrent eq ".." || $variable_database_listcurrent eq "."){
1316
1317                                         # Check if the noerror value is set to 1, if it is return an
1318                                         # number, else return an proper error.
1319
1320                                         if ($variable_noerror eq 1){
1321
1322                                                 # Page filename contains invalid characters and
1323                                                 # the no error value is set to 1 so return a
1324                                                 # value of 2 (meaning that the page filename
1325                                                 # is invalid).
1326
1327                                                 return 2;
1328
1329                                         } elsif ($variable_noerror eq 0) {
1330
1331                                                 # Page filename contains invalid characters and
1332                                                 # the no error value is set to 0 so return an
1333                                                 # error.
1334
1335                                                 kiriwrite_error("invalidfilename");
1336
1337                                         } else {
1338
1339                                                 # The no error value is something else other
1340                                                 # than 0 or 1 so return an error.
1341
1342                                                 kiriwrite_error("invalidvariable");
1343
1344                                         }
1345
1346                                 }
1347
1348                                 # Append the forward slash, clear the current directory name and set
1349                                 # the first directory level value to 0.
1350
1351                                 $variable_database_list = $variable_database_list . $variable_data_char;
1352                                 $variable_database_listcurrent = "";
1353                                 $variable_data_firstlevel = 0;
1354
1355                         } else {
1356
1357                                 # Append the current character to the directory name and to the current
1358                                 # directory name.
1359
1360                                 $variable_data_slash = 0;
1361
1362                                 $variable_database_list = $variable_database_list . $variable_data_char;
1363                                 $variable_database_listcurrent = $variable_database_listcurrent . $variable_data_char;
1364
1365                         }
1366
1367                         # Increment the seek counter.
1368
1369                         $variable_data_seek++;
1370
1371                 } until ($variable_data_seek eq $variable_data_length);
1372
1373                 # Check if the last character is a slash and return an
1374                 # error if it is.
1375
1376                 if ($variable_data_slash eq 1){
1377
1378                         if ($variable_noerror eq 1){
1379
1380                                 # Last character is a slash and the no error
1381                                 # value is set to 1 so return a value of 2
1382                                 # (meaning that the page filename is invalid).
1383
1384                                 return 2;
1385
1386                         } elsif ($variable_noerror eq 0) {
1387
1388                                 # Page filename contains a slash for the last
1389                                 # character and the no error value is set to 0
1390                                 # so return an error.
1391
1392                                 kiriwrite_error("invalidfilename");
1393
1394                         } else {
1395
1396                                 # The no error value is something else other
1397                                 # than 0 or 1 so return an error.
1398
1399                                 kiriwrite_error("invalidvariable");
1400
1401                         }
1402
1403                 }
1404
1405                 return 0;
1406
1407         } elsif ($variable_type eq "module"){
1408
1409                 # The variable type is a presentation module filename.
1410
1411                 # Check if the variable_data is blank and if it is
1412                 # return an error.
1413
1414                 if ($variable_data eq ""){
1415
1416                         # The presentation module is blank so check if an error
1417                         # value should be returned or a number should be
1418                         # returned.
1419
1420                         if ($variable_noerror eq 1){
1421
1422                                 # Module name is blank and the no error value
1423                                 # is set to 1 so return a value of 2 (meaning
1424                                 # that the page filename is blank).
1425
1426                                 return 1;
1427
1428                         } elsif ($variable_noerror eq 0) {
1429
1430                                 # Module name contains is blank and the no error
1431                                 # value is set to 0 so return an error.
1432
1433                                 kiriwrite_critical("moduleblank");
1434
1435                         } else {
1436
1437                                 # The no error value is something else other
1438                                 # than 0 or 1 so return an error.
1439
1440                                 kiriwrite_critical("invalidvalue");
1441
1442                         }
1443
1444                 } else {
1445
1446                 }
1447
1448                 my $variable_data_validated = $variable_data;
1449                 $variable_data_validated =~ tr/a-zA-Z0-9//d;
1450
1451                 if ($variable_data_validated eq ""){
1452
1453                 } else {
1454
1455                         if ($variable_noerror eq 1){
1456
1457                                 # Module name contains invalid characters and
1458                                 # the no error value is set to 1 so return a
1459                                 # value of 2 (meaning that the page filename
1460                                 # is invalid).
1461
1462                                 return 2;
1463
1464                         } elsif ($variable_noerror eq 0) {
1465
1466                                 # Module name contains invalid characters and
1467                                 # the no error value is set to 0 so return an
1468                                 # error.
1469
1470                                 kiriwrite_critical("moduleinvalid");
1471
1472                         } else {
1473
1474                                 # The no error value is something else other
1475                                 # than 0 or 1 so return an error.
1476
1477                                 kiriwrite_error("invalidvalue");
1478
1479                         }
1480
1481                 }
1482
1483                 return 0;
1484
1485         } elsif ($variable_type eq "utf8"){
1486
1487                 # The variable type is a UTF8 string.
1488
1489                 if (!$variable_data){
1490
1491                         $variable_data = "";
1492
1493                 }
1494
1495                 my $chunk = 0;
1496                 my $process = 8192;
1497                 my $length = 0;
1498                 my $chunkdata = "";
1499
1500                 while ($chunk < $length){
1501
1502                         $chunkdata = substr($variable_data, $chunk, $process);
1503
1504                         if ($chunkdata =~ m/\A(
1505                                 [\x09\x0A\x0D\x20-\x7E]            # ASCII
1506                                 | [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
1507                                 |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
1508                                 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
1509                                 |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
1510                                 |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
1511                                 | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
1512                                 |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
1513                         )*\z/x){
1514
1515                                 # The UTF-8 string is valid.
1516
1517                         } else {
1518
1519                                 # The UTF-8 string is not valid, check if the no error
1520                                 # value is set to 1 and return an error if it isn't.
1521
1522                                 if ($variable_noerror eq 1){
1523
1524                                         # The no error value has been set to 1, so return
1525                                         # a value of 1 (meaning that the UTF-8 string is
1526                                         # invalid).
1527
1528                                         return 1;
1529
1530                                 } elsif ($variable_noerror eq 0) {
1531
1532                                         # The no error value has been set to 0, so return
1533                                         # an error.
1534
1535                                         kiriwrite_error("invalidutf8");
1536
1537                                 } else {
1538
1539                                         # The no error value is something else other than 0
1540                                         # or 1, so return an error.
1541
1542                                         kiriwrite_error("invalidoption");
1543
1544                                 }
1545
1546                         }
1547
1548
1549                         $chunk = $chunk + $process;
1550
1551                 }
1552
1553 #               # Check if the string is a valid UTF8 string.
1554 #
1555 #               if ($variable_data =~ m/^(
1556 #                       [\x09\x0A\x0D\x20-\x7E]              # ASCII
1557 #                       | [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
1558 #                       |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
1559 #                       | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
1560 #                       |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
1561 #                       |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
1562 #                       | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
1563 #                       |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
1564 #               )*$/x){
1565 #
1566 #                       # The UTF-8 string is valid.
1567 #
1568 #               } else {
1569 #
1570 #                       # The UTF-8 string is not valid, check if the no error
1571 #                       # value is set to 1 and return an error if it isn't.
1572 #
1573 #                       if ($variable_noerror eq 1){
1574 #
1575 #                               # The no error value has been set to 1, so return
1576 #                               # a value of 1 (meaning that the UTF-8 string is
1577 #                               # invalid).
1578 #
1579 #                               return 1;
1580 #
1581 #                       } elsif ($variable_noerror eq 0) {
1582 #
1583 #                               # The no error value has been set to 0, so return
1584 #                               # an error.
1585 #
1586 #                               kiriwrite_error("invalidutf8");
1587 #
1588 #                       } else {
1589 #
1590 #                               # The no error value is something else other than 0
1591 #                               # or 1, so return an error.
1592 #
1593 #                               kiriwrite_error("invalidoption");
1594 #
1595 #                       }
1596 #
1597 #               }
1598
1599                 return 0;
1600
1601         } elsif ($variable_type eq "serverprotocol"){
1602
1603                 # Check if the server protocol is TCP or UDP and return
1604                 # an error if it isn't.
1605
1606                 if ($variable_data ne "tcp" && $variable_data ne "udp"){
1607
1608                         # The protocol given is not valid, check if the no
1609                         # error value is set to 1 and return an error if it isn't.
1610
1611                         if ($variable_noerror eq 1){
1612
1613                                 # The no error value has been set to 1, so return a
1614                                 # value of 1 (meaning that the server protocol is
1615                                 # invalid).
1616
1617                                 return 1;
1618
1619                         } elsif ($variable_noerror eq 0){
1620
1621                                 # The no error value has been set to 0, so return
1622                                 # an error.
1623
1624                                 kiriwrite_error("serverprotocolinvalid");
1625
1626                         } else {
1627
1628                                 # The no error value is something else other than 0
1629                                 # or 1, so return an error.
1630
1631                                 kiriwrite_error("invalidoption");
1632
1633                         }
1634
1635                 }
1636
1637                 return 0;
1638
1639         } elsif ($variable_type eq "port"){
1640
1641                 # Check if the port number given is less than 0 or more than 65535
1642                 # and return an error if it is.
1643
1644                 if ($variable_data < 0 || $variable_data > 65535){
1645
1646                         # The port number is less than 0 and more than 65535 so
1647                         # check if the no error value is set to 1 and return an
1648                         # error if it isn't.
1649
1650                         if ($variable_noerror eq 1){
1651
1652                                 # The no error value has been set to 1, so return a
1653                                 # value of 1 (meaning that the port number is invalid).
1654
1655                                 return 1;
1656
1657                         } elsif ($variable_noerror eq 0){
1658
1659                                 # The no error value has been set to 0, so return
1660                                 # an error.
1661
1662                                 kiriwrite_error("serverportnumberinvalid");
1663
1664                         } else {
1665
1666                                 # The no error value is something else other than 0
1667                                 # or 1, so return an error.
1668
1669                                 kiriwrite_error("invalidoption");
1670
1671                         }
1672
1673                 }
1674
1675                 return 0;
1676
1677         }
1678
1679         # Another type than the valid ones above has been specified so return an error specifying an invalid option.
1680         kiriwrite_error("invalidoption");
1681
1682 }
1683
1684 sub kiriwrite_output_header{
1685 #################################################################################
1686 # kiriwrite_output_header: Outputs the header to the browser/stdout/console.    #
1687 #                                                                               #
1688 # Usage:                                                                        #
1689 #                                                                               #
1690 # kiriwrite_output_header();                                                    #
1691 #################################################################################
1692
1693         # Print a header saying that the page expires immediately since the
1694         # date is set in the past.
1695
1696         print "Expires: Sun, 01 Jan 2006 00:00:00 GMT\r\n";
1697         print "Content-Type: text/html; charset=utf-8;\r\n\r\n";
1698         return;
1699 }
1700
1701 sub kiriwrite_processfilename{
1702 #################################################################################
1703 # kiriwrite_processfilename: Processes a name and turns it into a filename that #
1704 # can be used by Kiriwrite.                                                     #
1705 #                                                                               #
1706 # Usage:                                                                        #
1707 #                                                                               #
1708 # kiriwrite_processfilename(text);                                              #
1709 #                                                                               #
1710 # text          Specifies the text to be used in the process for creating a new #
1711 #               filename.                                                       #
1712 #################################################################################
1713
1714         # Get the values that have been passed to the subroutine.
1715
1716         my ($process_text) = @_;
1717
1718         # Define some variables that will be used later on.
1719
1720         my $processed_stageone  = "";
1721         my $processed_stagetwo  = "";
1722         my $processed_length    = "";
1723         my $processed_char      = "";
1724         my $processed_seek      = 0;
1725         my $processed_filename  = "";
1726
1727         # Set the first stage value of the processed filename to the
1728         # process filename and then filter it out to only contain
1729         # numbers and letters (no spaces) and then convert the
1730         # capitals to small letters.
1731
1732         $processed_stageone = $process_text;
1733         $processed_stageone =~ tr#a-zA-Z0-9##cd;
1734         $processed_stageone =~ tr/A-Z/a-z/;
1735
1736         # Now set the second stage value of the processed filename
1737         # to the first stage value of the processed filename and
1738         # then limit the filename down to 32 characters.
1739
1740         $processed_stagetwo = $processed_stageone;
1741         $processed_length = length($processed_stagetwo);
1742
1743         # Process the second stage filename into the final
1744         # filename and do so until the seek counter is 32
1745         # or reaches the length of the second stage filename.
1746
1747         do {
1748
1749                 # Get the character that is the seek counter
1750                 # is set at.
1751
1752                 $processed_char = substr($processed_stagetwo, $processed_seek, 1);
1753
1754                 # Append to the final processed filename.
1755
1756                 $processed_filename = $processed_filename . $processed_char;
1757
1758                 # Increment the seek counter.
1759
1760                 $processed_seek++;
1761
1762         } until ($processed_seek eq 32 || $processed_seek eq $processed_length);
1763
1764         return $processed_filename;
1765
1766 }
1767
1768 sub kiriwrite_language{
1769 #################################################################################
1770 # kiriwrite_language: Process language strings that needs certain text inserted.#
1771 #                                                                               #
1772 # Usage:                                                                        #
1773 #                                                                               #
1774 # kiriwrite_language(string, [text, text, ...]);                                #
1775 #                                                                               #
1776 # string        Specifies the string to process.                                #
1777 # text          Specifies the text to pass to the string (can be repeated many  #
1778 #               times).                                                         #
1779 #################################################################################
1780
1781         my $string = shift;
1782         my $item;
1783
1784         foreach $item (@_){
1785
1786                 $string =~ s/%s/$item/;
1787
1788         }
1789
1790         return $string;
1791
1792 }
1793
1794 sub kiriwrite_error{
1795 #################################################################################
1796 # kiriwrite_error: Prints out an error message.                                 #
1797 #                                                                               #
1798 # Usage:                                                                        #
1799 #                                                                               #
1800 # kiriwrite_error(errortype, errorext);                                         #
1801 #                                                                               #
1802 # errortype     Specifies the type of error that occured.                       #
1803 # errorext      Specifies the extended error information.                       #
1804 #################################################################################
1805
1806         # Get the error type from the subroutine.
1807
1808         my ($error_type, $error_extended) = @_;
1809
1810         # Disconnect from the database server.
1811
1812         if ($kiriwrite_dbmodule){
1813                 $kiriwrite_dbmodule->disconnect();
1814         }
1815
1816         # Load the list of error messages.
1817
1818         my @kiriwrite_error = (
1819
1820                 # Catch all error message.
1821                 "generic",
1822
1823                 # Standard error messages.
1824                 "blankfilename", "blankvariable", "fileexists", "internalerror", "invalidoption", "invalidaction", "invalidfilename", "invalidmode", "invalidutf8", "invalidvariable", "variabletoolong",
1825
1826                 # Specific error messages.
1827                 "blankcompiletype", "blankdatabasepageadd", "blankdirectory", "blankfindfilter", "blankdatetimeformat", "browsenumbertoolong", "browsenumberinvalid",  "databaseconnectionerror", "databasecategoriestoolong", "databasecopysame", "databasealreadyexists", "datadirectorymissing", "datadirectoryinvalidpermissions", "databasedescriptiontoolong", "databasefilenameinvalid", "databasefilenametoolong", "databaseerror", "databaseinvalidpermissions", "databasenameinvalid", "databasenametoolong", "databasenameblank", "databasemissingfile", "databasemovemissingfile", "databasenorename", "databasemovesame", "dbmoduleblank", "dbmoduleinvalid", "dbdirectoryblank", "dbdirectoryinvalid", "dbmodulemissing", "filtersdatabasenotcreated", "filtersdbdatabaseerror", "filtersdbpermissions", "filtersdbmissing", "filteridblank", "filterdoesnotexist", "filteridinvalid", "filteridtoolong", "findfiltertoolong", "filterpriorityinvalid", "filterpriorityinvalidchars", "filterprioritytoolong", "invalidcompiletype", "invalidpagenumber", "nopagesselected",      "invaliddirectory", "invaliddatetimeformat", "invalidlanguagefilename", "languagefilenamemissing", "moduleblank", "moduleinvalid",      "newcopydatabasedatabaseerror", "newcopydatabasedoesnotexist", "newcopydatabasefileinvalidpermissions", "newmovedatabasedatabaseerror", "newmovedatabasedoesnotexist", "newmovedatabasefileinvalidpermissions", "nodatabasesavailable", "nodatabaseselected", "noeditvaluesselected", "oldcopydatabasedatabaseerror", "oldcopydatabasedoesnotexist", "oldcopydatabasefileinvalidpermissions", "oldmovedatabasedatabaseerror",   "oldmovedatabasedoesnotexist", "oldmovedatabasefileinvalidpermissions", "outputdirectoryblank", "outputdirectoryinvalid", "outputdirectorymissing", "outputdirectoryinvalidpermissions", "overridetemplatevalueinvalid", "overridetemplatetoolong", "overridetemplateinvalid",  "presmoduleblank", "presmoduleinvalid", "presmodulemissing", "pagefilenamedoesnotexist", "pagefilenameexists", "pagefilenameinvalid", "pagefilenametoolong", "pagefilenameblank", "pagetitletoolong", "pagedescriptiontoolong", "pagesectiontoolong", "pagedatabasefilenametoolong", "pagesettingstoolong", "pagesettingsinvalid", "pagetemplatefilenametoolong", "replacefiltertoolong", "servernameinvalid", "servernametoolong", "serverdatabasenameinvalid", "serverdatabasenametoolong", "serverdatabaseusernameinvalid", "serverdatabaseusernametoolong", "serverdatabasepasswordtoolong", "serverdatabasetableprefixinvalid", "serverdatabasetableprefixtoolong", "serverportnumberinvalid", "serverportnumberinvalidcharacters", "serverportnumbertoolong", "serverprotocolnametoolong", "serverprotocolinvalid", "templatenameblank", "templatefilenameexists", "templatefilenameinvalid", "templatedatabaseerror", "templatedatabaseinvalidpermissions", "templatedatabaseinvalidformat", "templatedirectoryblank", "templatedirectoryinvalid", "templatedatabasenotcreated", "templatefilenametoolong", "templatenametoolong", "templatedescriptiontoolong", "templatedatabasemissing", "templatedoesnotexist", "templatefilenameblank", "textarearowblank", "textarearowtoolong", "textarearowinvalid", "textareacolblank", "textareacoltoolong", "textareacolinvalid"
1828
1829         );
1830
1831         # Check if the error message name is a valid error message name
1832         # and return the generic error message if it isn't.
1833
1834         my $error_string = "";
1835
1836         if (grep /^$error_type$/, @kiriwrite_error){
1837
1838                 # The error type is valid so get the error language string
1839                 # associated with this error messsage name.
1840
1841                 $error_string = $kiriwrite_lang->{error}->{$error_type};
1842
1843         } else {
1844
1845                 # The error type is invalid so set the error language
1846                 # string using the generic error message name.
1847
1848                 $error_string = $kiriwrite_lang->{error}->{generic};
1849
1850         }
1851
1852         $kiriwrite_presmodule->clear();
1853
1854         $kiriwrite_presmodule->startbox("errorbox");
1855         $kiriwrite_presmodule->addtext($kiriwrite_lang->{error}->{error}, { Style => "errorheader" });
1856         $kiriwrite_presmodule->addlinebreak();
1857         $kiriwrite_presmodule->addtext($error_string, { Style => "errortext" });
1858
1859         # Check to see if extended error information was passed.
1860
1861         if ($error_extended){
1862
1863                 # Write the extended error information.
1864
1865                 $kiriwrite_presmodule->addlinebreak();
1866                 $kiriwrite_presmodule->addlinebreak();
1867                 $kiriwrite_presmodule->addtext($kiriwrite_lang->{error}->{extendederror});
1868                 $kiriwrite_presmodule->addlinebreak();
1869                 $kiriwrite_presmodule->addlinebreak();
1870                 $kiriwrite_presmodule->startbox("datalist");
1871                 $kiriwrite_presmodule->addtext($error_extended);
1872                 $kiriwrite_presmodule->endbox();
1873
1874         }
1875
1876         $kiriwrite_presmodule->endbox();
1877
1878         kiriwrite_output_header;
1879         kiriwrite_output_page($kiriwrite_lang->{error}->{error}, $kiriwrite_presmodule->grab(), "none");
1880
1881         exit;
1882
1883 }
1884
1885 sub kiriwrite_fileexists{
1886 #################################################################################
1887 # kiriwrite_fileexists: Check if a file exists and returns a value depending on #
1888 # if the file exists or not.                                                    #
1889 #                                                                               #
1890 # Usage:                                                                        #
1891 #                                                                               #
1892 # kiriwrite_fileexists(filename);                                               #
1893 #                                                                               #
1894 # filename      Specifies the file name to check if it exists or not.           #
1895 #################################################################################
1896
1897         # Get the value that was passed to the subroutine.
1898
1899         my ($filename) = @_;
1900
1901         # Check if the filename exists, if it does, return a value of 0, else
1902         # return a value of 1, meaning that the file was not found.
1903
1904         if (-e $filename){
1905
1906                 # Specified file does exist so return a value of 0.
1907
1908                 return 0;
1909
1910         } else {
1911
1912                 # Specified file does not exist so return a value of 1.
1913
1914                 return 1;
1915
1916         }
1917
1918 }
1919
1920 sub kiriwrite_filepermissions{
1921 #################################################################################
1922 # kiriwrite_filepermissions: Check if the file permissions of a file and return #
1923 # either a 1 saying that the permissions are valid or return a 0 saying that    #
1924 # the permissions are invalid.                                                  #
1925 #                                                                               #
1926 # Usage:                                                                        #
1927 #                                                                               #
1928 # kiriwrite_filepermissions(filename, [read], [write], [filemissingskip]);      #
1929 #                                                                               #
1930 # filename              Specifies the filename to check for permissions.        #
1931 # read                  Preform check that the file is readable.                #
1932 # write                 Preform check that the file is writeable.               #
1933 # filemissingskip       Skip the check of seeing if it can read or write if the #
1934 #                       file is missing.                                        #
1935 #################################################################################
1936
1937         # Get the values that was passed to the subroutine.
1938
1939         my ($filename, $readpermission, $writepermission, $ignorechecks) = @_;
1940
1941         # Check to make sure that the read permission and write permission values
1942         # are only 1 character long.
1943
1944         kiriwrite_variablecheck($readpermission, "maxlength", 1, 0);
1945         kiriwrite_variablecheck($writepermission, "maxlength", 1, 0);
1946         kiriwrite_variablecheck($ignorechecks, "maxlength", 1, 0);
1947
1948         my $ignorechecks_result = 0;
1949
1950         # Check if the file should be ignored for read and write checking if
1951         # it doesn't exist.
1952
1953         if ($ignorechecks){
1954
1955                 if (-e $filename){
1956
1957                         # The file exists so the checks are to be done.
1958
1959                         $ignorechecks_result = 0;
1960
1961                 } else {
1962
1963                         # The file does not exist so the checks don't need to
1964                         # be done to prevent false positives.
1965
1966                         $ignorechecks_result = 1;
1967
1968                 }
1969
1970         } else {
1971
1972                 $ignorechecks_result = 0;
1973
1974         }
1975
1976         # Check if the file should be checked to see if it can be read.
1977
1978         if ($readpermission && $ignorechecks_result eq 0){
1979
1980                 # The file should be checked to see if it does contain read permissions
1981                 # and return a 0 if it is invalid.
1982
1983                 if (-r $filename){
1984
1985                         # The file is readable, so do nothing.
1986
1987                 } else {
1988
1989                         # The file is not readable, so return 1.
1990
1991                         return 1;
1992
1993                 }
1994
1995         }
1996
1997         # Check if the file should be checked to see if it can be written.
1998
1999         if ($writepermission && $ignorechecks_result eq 0){
2000
2001                 # The file should be checked to see if it does contain write permissions
2002                 # and return a 0 if it is invalid.
2003
2004                 if (-w $filename){
2005
2006                         # The file is writeable, so do nothing.
2007
2008                 } else {
2009
2010                         # The file is not writeable, so return 1.
2011
2012                         return 1;
2013
2014                 }
2015
2016         }
2017
2018         # No problems have occured, so return 0.
2019
2020         return 0;
2021
2022 }
2023
2024 sub kiriwrite_utf8convert{
2025 #################################################################################
2026 # kiriwrite_utf8convert: Properly converts values into UTF-8 values.            #
2027 #                                                                               #
2028 # Usage:                                                                        #
2029 #                                                                               #
2030 # utfstring     # The UTF-8 string to convert.                                  #
2031 #################################################################################
2032
2033         # Get the values passed to the subroutine.
2034
2035         my ($utfstring) = @_;
2036
2037         # Load the Encode perl module.
2038
2039         use Encode qw(decode_utf8);
2040
2041         # Convert the string.
2042
2043         my $finalutf8 = Encode::decode_utf8( $utfstring );
2044
2045         return $finalutf8;
2046
2047 }
2048
2049 sub kiriwrite_critical{
2050 #################################################################################
2051 # kiriwrite_critical: Displays an critical error message that cannot be         #
2052 # normally by the kiriwrite_error subroutine.                                   #
2053 #                                                                               #
2054 # Usage:                                                                        #
2055 #                                                                               #
2056 # errortype     Specifies the type of critical error that has occured.          #
2057 #################################################################################
2058
2059         # Get the value that was passed to the subroutine.
2060
2061         my ($error_type) = @_;
2062
2063         my %error_list;
2064
2065         # Get the error type from the errortype string.
2066
2067         %error_list = (
2068
2069                 # Generic critical error message.
2070
2071                 "generic"                       => "A critical error has occured but the error is not known to Kiriwrite.",
2072
2073                 # Specific critical error messages.
2074
2075                 "configfilemissing"             => "The Kiriwrite configuration file is missing! Running the installer script for Kiriwrite is recommended.",
2076                 "configfileinvalidpermissions"  => "The Kiriwrite configuration file has invalid permission settings set! Please set the valid permission settings for the configuration file.",
2077                 "dbmodulemissing"               => "The database module is missing! Running the installer script for Kiriwrite is recommended.",
2078                 "dbmoduleinvalidpermissions"    => "The database module cannot be used as it has invalid permission settings set! Please set the valid permission settings for the configuration file.",
2079                 "dbmoduleinvalid"               => "The database module name given is invalid. Running the installer script for Kiriwrite is recommended.",
2080                 "invalidvalue"                  => "An invalid value was passed.",
2081                 "languagefilenameblank"         => "The language filename given is blank! Running the installer script for Kiriwrite is recommended.",
2082                 "languagefilenameinvalid"       => "The language filename given is invalid! Running the installer script for Kiriwrite is recommended.",
2083                 "languagefilemissing"   => "The language filename given does not exist. Running the installer script for Kiriwrite is recommended.",
2084                 "languagefilenameinvalidpermissions"    => "The language file with the filename given has invalid permissions set. Please set the valid permission settings for the language file.",
2085                 "presmodulemissing"             => "The presentation module is missing! Running the installer script for Kiriwrite is recommended.",
2086                 "presmoduleinvalidpermissions"  => "The presentation module cannot be used as it has invalid permission settings set! Please set the valid permission settings for the presentation module.",
2087                 "presmoduleinvalid"             => "The presentation module name given is invalid. Running the installer script for Kiriwrite is recommended.",
2088                 "textarearowblank"              => "The text area row value given is blank.",
2089                 "textarearowtoolong"            => "The text area row value is too long. Running the installer script for Kiriwrite is recommended.",
2090                 "textarearowinvalid"            => "The text area row value is invalid. Running the installer script for Kiriwrite is recommended.",
2091                 "textareacolblank"              => "The text area row value given is blank.",
2092                 "textareacoltoolong"            => "The text area column value is too long. Running the installer script for Kiriwrite is recommended.",
2093                 "textareacolinvalid"            => "The text area column value is invalid. Running the installer script for Kiriwrite is recommended.",
2094
2095         );
2096
2097         if (!$error_list{$error_type}){
2098
2099                 $error_type = "generic";
2100
2101         }
2102
2103         print "Expires: Sun, 01 Jan 2006 00:00:00 GMT\r\n";
2104         print "Content-Type: text/html; charset=utf-8;\r\n\r\n";
2105         print "Critical Error: " . $error_list{$error_type};
2106         exit;
2107
2108 }
2109
2110 sub kiriwrite_output_page{
2111 #################################################################################
2112 # kiriwrite_output_page: Outputs the page to the browser/stdout/console.        #
2113 #                                                                               #
2114 # Usage:                                                                        #
2115 #                                                                               #
2116 # kiriwrite_output_page(pagetitle, pagedata, menutype);                         #
2117 #                                                                               #
2118 # pagetitle     Specifies the page title.                                       #
2119 # pagedata      Specifies the page data.                                        #
2120 # menutype      Prints out which menu to use.                                   #
2121 #################################################################################
2122
2123         my ($pagetitle, $pagedata, $menutype) = @_;
2124
2125         # Open the script page template and load it into the scriptpage variable,
2126         # while declaring the variable.
2127
2128         open (my $filehandle_scriptpage, "<:utf8", 'page.html');
2129         my @scriptpage = <$filehandle_scriptpage>;
2130         binmode $filehandle_scriptpage, ':utf8';
2131         close ($filehandle_scriptpage);
2132
2133         # Define the variables required.
2134
2135         my $scriptpageline = "";
2136         my $pageoutput = "";
2137         my $menuoutput = "";
2138
2139         $kiriwrite_presmodule->clear();
2140
2141         # Print out the main menu for Kiriwrite.
2142
2143         $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=db", { Text => $kiriwrite_lang->{menu}->{viewdatabases} });
2144         $kiriwrite_presmodule->addtext(" | ");
2145         $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=page", { Text => $kiriwrite_lang->{menu}->{viewpages} });
2146         $kiriwrite_presmodule->addtext(" | ");
2147         $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=filter", { Text => $kiriwrite_lang->{menu}->{viewfilters} });
2148         $kiriwrite_presmodule->addtext(" | ");
2149         $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=template", { Text => $kiriwrite_lang->{menu}->{viewtemplates} });
2150         $kiriwrite_presmodule->addtext(" | ");
2151         $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=compile", { Text => $kiriwrite_lang->{menu}->{compilepages} });
2152         $kiriwrite_presmodule->addtext(" | ");
2153         $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=settings", { Text => $kiriwrite_lang->{menu}->{viewsettings} });
2154         $kiriwrite_presmodule->addlinebreak();
2155
2156         # Check what menu is going to be printed along with the default 'top' menu.
2157
2158         if ($menutype eq "database"){
2159
2160                 # If the menu type is database then print out the database sub-menu.
2161
2162                 $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=db", { Text => $kiriwrite_lang->{database}->{submenu_viewdatabases} });
2163                 $kiriwrite_presmodule->addtext(" | ");
2164                 $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=db&action=new", { Text => $kiriwrite_lang->{database}->{submenu_adddatabase} });
2165
2166         } elsif ($menutype eq "pages"){
2167                 # If the menu type is pages then print out the pages sub-menu.
2168
2169                 # First, fetch the database name from the HTTP query string.
2170
2171                 my $db_filename = $form_data->{'database'};
2172
2173                 # Check if a value has been placed in the db_filename string.
2174
2175                 if (!$db_filename){
2176
2177                         # As the database filename is blank, don't add an option to add a page.
2178
2179                 } else {
2180
2181                         # A database file has been specified so add an option to add a page to
2182                         # the selected database.
2183
2184                         $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=page&action=add&database="  . $db_filename, { Text => $kiriwrite_lang->{pages}->{submenu_addpage} });
2185
2186                 }
2187
2188         } elsif ($menutype eq "filter"){
2189
2190                 # If the menu type is filters then print out the filter sub-menu.
2191
2192                 $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=filter", { Text => $kiriwrite_lang->{filter}->{submenu_showfilters} });
2193                 $kiriwrite_presmodule->addtext(" | ");
2194                 $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=filter&action=add", { Text => $kiriwrite_lang->{filter}->{submenu_addfilter} });
2195
2196         } elsif ($menutype eq "settings"){
2197
2198                 # If the menu type is options then print out the options sub-menu.
2199
2200                 $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=settings", { Text => $kiriwrite_lang->{setting}->{submenu_viewsettings} });
2201                 $kiriwrite_presmodule->addtext(" | ");
2202                 $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=settings&action=edit", { Text => $kiriwrite_lang->{setting}->{submenu_editsettings} });
2203
2204         } elsif ($menutype eq "template"){
2205
2206                 # If the menu type is template then print out the template sub-menu.
2207
2208                 $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=template", { Text => $kiriwrite_lang->{template}->{submenu_showtemplates} });
2209                 $kiriwrite_presmodule->addtext(" | ");
2210                 $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=template&action=add", { Text => $kiriwrite_lang->{template}->{submenu_addtemplate} });
2211
2212         } elsif ($menutype eq "compile"){
2213
2214                 # If the menu type is compile then print out the compile sub-menu.
2215
2216                 $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=compile", { Text => $kiriwrite_lang->{compile}->{submenu_listdatabases} });
2217                 $kiriwrite_presmodule->addtext(" | ");
2218                 $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=compile&action=all", { Text => $kiriwrite_lang->{compile}->{submenu_compileall} });
2219                 $kiriwrite_presmodule->addtext(" | ");
2220                 $kiriwrite_presmodule->addlink($kiriwrite_env{'script_filename'} . "?mode=compile&action=clean", { Text => $kiriwrite_lang->{compile}->{submenu_cleanoutputdirectory} });
2221
2222         }
2223
2224         $menuoutput = $kiriwrite_presmodule->grab();
2225
2226         # Find <kiriwrite> tages and replace with the apporiate variables.
2227
2228         foreach $scriptpageline (@scriptpage){
2229
2230                 $scriptpageline =~ s/<kiriwrite:menu>/$menuoutput/g;
2231                 $scriptpageline =~ s/<kiriwrite:imagespath>/$kiriwrite_config{"directory_noncgi_images"}/g;
2232                 $scriptpageline =~ s/<kiriwrite:pagedata>/$pagedata/g;
2233
2234                 # Check if page title specified is blank, otherwise add a page title
2235                 # to the title.
2236
2237                 if ($pagetitle eq ""){
2238                         $scriptpageline =~ s/<kiriwrite:title>//g;
2239                 } else {
2240                         $scriptpageline =~ s/<kiriwrite:title>/ ($pagetitle)/g;
2241                 }
2242
2243
2244
2245                 # Append processed line to the pageoutput variable.
2246
2247                 $pageoutput = $pageoutput . $scriptpageline;
2248
2249         }
2250
2251         binmode STDOUT, ':utf8';
2252
2253         print $pageoutput;
2254
2255         return;
2256
2257 }
2258
2259 #################################################################################
2260 # End listing the functions needed.                                             #
2261 #################################################################################
2262
2263 #################################################################################
2264 # Begin proper script execution.                                                #
2265 #################################################################################
2266
2267 kiriwrite_settings_load;        # Load the configuration options.
2268
2269 my $query_lite = new CGI::Lite;
2270
2271 # Check if a mode has been specified and if a mode has been specified, continue
2272 # and work out what mode has been specified.
2273
2274 $form_data = $query_lite->parse_form_data;
2275
2276 if ($form_data->{'mode'}){
2277         my $http_query_mode = $form_data->{'mode'};
2278
2279         if ($http_query_mode eq "db"){
2280
2281                 # If mode is 'db' (database), then load the database perl library and
2282                 # check what action is required.
2283
2284                 require "./lib/database.lib";
2285
2286         } elsif ($http_query_mode eq "page"){
2287
2288                 # If mode is 'page', load the page library and then check what
2289                 # action is required.
2290
2291                 require "./lib/page.lib";
2292
2293         } elsif ($http_query_mode eq "filter"){
2294
2295                 # Load the filter perl library and then check the
2296                 # value of the action HTTP query.
2297
2298                 require "./lib/filter.lib";
2299
2300         } elsif ($http_query_mode eq "template"){
2301
2302                 # Load the template perl library and check if an action has
2303                 # been specified in the HTTP query.
2304
2305                 require "./lib/template.lib";
2306
2307         } elsif ($http_query_mode eq "compile"){
2308
2309                 # Load the compile perl library.
2310
2311                 require "./lib/compile.lib";
2312
2313         } elsif ($http_query_mode eq "settings"){
2314
2315                 # Load the settings perl library.
2316
2317                 require "./lib/settings.lib";
2318
2319         } else {
2320                 # Another mode has been specified than the ones above, so return an error saying that
2321                 # an invalid option was specified.
2322
2323                 kiriwrite_error("invalidmode");
2324         }
2325
2326 } else {
2327
2328         # No mode has been specified, so print the default "first-run" view of the
2329         # database list.
2330
2331         require "./lib/database.lib";
2332
2333         my $pagedata = kiriwrite_database_list();
2334
2335         kiriwrite_output_header;                # Output the header to browser/console/stdout.
2336         kiriwrite_output_page("", $pagedata, "database");       # Output the page to browser/console/stdout.
2337         exit;                                   # End the script.
2338
2339 }
2340
2341 __END__
2342
2343 =head1 NAME
2344
2345 Kiriwrite
2346
2347 =head1 DESCRIPTION
2348
2349 Web-based webpage compiler.
2350
2351 =head1 AUTHOR
2352
2353 Steve Brokenshire <sbrokenshire@xestia.co.uk>
2354
2355 =head1 USAGE
2356
2357 This perl script is intended to be used on a web server which has CGI with Perl support or with mod_perl support.
2358
2359 =head1 DOCUMENTATION
2360
2361 For more information on how to use Kiriwrite, please see the documentation that was included with Kiriwrite.
2362
2363 - From the Xestia Documentation website: http://documentation.xestia.co.uk and click on the Kiriwrite link on the page.
2364
2365 - From the Documentation directory from the Kiriwrite source packages (.tar/.tar.gz/.tar.bz2).
2366
2367 - In the /usr/share/doc/kiriwrite directory if you installed the distribution-specific packages (and also have access to the server itself).