cgi-files/Modules/System/Common.pm

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