gosa-si/gosa-si-server

   1 #!/usr/bin/perl
   2 #===============================================================================
   3 #
   4 #         FILE:  gosa-sd
   5 #
   6 #        USAGE:  ./gosa-sd
   7 #
   8 #  DESCRIPTION:
   9 #
  10 #      OPTIONS:  ---
  11 # REQUIREMENTS:  libconfig-inifiles-perl libcrypt-rijndael-perl libxml-simple-perl
  12 #                libdata-dumper-simple-perl libdbd-sqlite3-perl libnet-ldap-perl
  13 #                libpoe-perl
  14 #         BUGS:  ---
  15 #        NOTES:
  16 #       AUTHOR:   (Andreas Rettenberger), <rettenberger@gonicus.de>
  17 #      COMPANY:
  18 #      VERSION:  1.0
  19 #      CREATED:  12.09.2007 08:54:41 CEST
  20 #     REVISION:  ---
  21 #===============================================================================
  22
  23
  24 use strict;
  25 use warnings;
  26 use Getopt::Long;
  27 use Config::IniFiles;
  28 use POSIX;
  29
  30 use Fcntl;
  31 use IO::Socket::INET;
  32 use IO::Handle;
  33 use IO::Select;
  34 use Symbol qw(qualify_to_ref);
  35 use Crypt::Rijndael;
  36 use MIME::Base64;
  37 use Digest::MD5  qw(md5 md5_hex md5_base64);
  38 use XML::Simple;
  39 use Data::Dumper;
  40 use Sys::Syslog qw( :DEFAULT setlogsock);
  41 use Cwd;
  42 use File::Spec;
  43 use File::Basename;
  44 use File::Find;
  45 use File::Copy;
  46 use File::Path;
  47 use GOSA::DBsqlite;
  48 use GOSA::GosaSupportDaemon;
  49 use POE qw(Component::Server::TCP Wheel::Run Filter::Reference);
  50 use Net::LDAP;
  51 use Net::LDAP::Util qw(:escape);
  52
  53 my $modules_path = "/usr/lib/gosa-si/modules";
  54 use lib "/usr/lib/gosa-si/modules";
  55
  56 # TODO es gibt eine globale funktion get_ldap_handle
  57 # - ist in einer session dieses ldap handle schon vorhanden, wird es zurückgegeben
  58 # - ist es nicht vorhanden, wird es erzeugt, im heap für spätere ldap anfragen gespeichert und zurückgegeben
  59 # - sessions die kein ldap handle brauchen, sollen auch keins haben
  60 # - wird eine session geschlossen, muss das ldap verbindung vorher beendet werden
  61 our $global_kernel;
  62
  63 my (%cfg_defaults, $foreground, $verbose, $ping_timeout);
  64 my ($bus_activ, $bus, $msg_to_bus, $bus_cipher);
  65 my ($server);
  66 my ($gosa_server, $job_queue_timeout, $job_queue_loop_delay);
  67 my ($messaging_db_loop_delay);
  68 my ($known_modules);
  69 my ($pid_file, $procid, $pid, $log_file);
  70 my ($arp_activ, $arp_fifo);
  71 my ($xml);
  72 my $sources_list;
  73 my $max_clients;
  74 my %repo_files=();
  75 my $repo_path;
  76 my %repo_dirs=();
  77 # variables declared in config file are always set to 'our'
  78 our (%cfg_defaults, $log_file, $pid_file,
  79     $server_ip, $server_port, $SIPackages_key,
  80     $arp_activ, $gosa_unit_tag,
  81     $GosaPackages_key, $gosa_ip, $gosa_port, $gosa_timeout,
  82 );
  83
  84 # additional variable which should be globaly accessable
  85 our $server_address;
  86 our $server_mac_address;
  87 our $bus_address;
  88 our $gosa_address;
  89 our $no_bus;
  90 our $no_arp;
  91 our $verbose;
  92 our $forground;
  93 our $cfg_file;
  94 #our ($ldap_handle, $ldap_uri, $ldap_base, $ldap_admin_dn, $ldap_admin_password, $ldap_server_dn);
  95 our ($ldap_uri, $ldap_base, $ldap_admin_dn, $ldap_admin_password, $ldap_server_dn);
  96
  97
  98 # specifies the verbosity of the daemon_log
  99 $verbose = 0 ;
 100
 101 # if foreground is not null, script will be not forked to background
 102 $foreground = 0 ;
 103
 104 # specifies the timeout seconds while checking the online status of a registrating client
 105 $ping_timeout = 5;
 106
 107 $no_bus = 0;
 108 $bus_activ = "true";
 109 $no_arp = 0;
 110 my $packages_list_under_construction = 0;
 111
 112 our $prg= basename($0);
 113
 114 # holds all gosa jobs
 115 our $job_db;
 116 our $job_queue_tn = 'jobs';
 117 my $job_queue_file_name;
 118 my @job_queue_col_names = ("id INTEGER PRIMARY KEY",
 119                 "timestamp DEFAULT 'none'",
 120                 "status DEFAULT 'none'",
 121                 "result DEFAULT 'none'",
 122                 "progress DEFAULT 'none'",
 123         "headertag DEFAULT 'none'",
 124                 "targettag DEFAULT 'none'",
 125                 "xmlmessage DEFAULT 'none'",
 126                 "macaddress DEFAULT 'none'",
 127                 "plainname DEFAULT 'none'",
 128                 );
 129
 130 # holds all other gosa-sd as well as the gosa-sd-bus
 131 our $known_server_db;
 132 our $known_server_tn = "known_server";
 133 my $known_server_file_name;
 134 my @known_server_col_names = ("hostname", "status", "hostkey", "timestamp");
 135
 136 # holds all registrated clients
 137 our $known_clients_db;
 138 our $known_clients_tn = "known_clients";
 139 my $known_clients_file_name;
 140 my @known_clients_col_names = ("hostname", "status", "hostkey", "timestamp", "macaddress", "events");
 141
 142 # holds all logged in user at each client
 143 our $login_users_db;
 144 our $login_users_tn = "login_users";
 145 my $login_users_file_name;
 146 my @login_users_col_names = ("client", "user", "timestamp");
 147
 148 # holds all fai server, the debian release and tag
 149 our $fai_server_db;
 150 our $fai_server_tn = "fai_server";
 151 my $fai_server_file_name;
 152 our @fai_server_col_names = ("timestamp", "server", "release", "sections", "tag");
 153
 154 our $fai_release_db;
 155 our $fai_release_tn = "fai_release";
 156 my $fai_release_file_name;
 157 our @fai_release_col_names = ("timestamp", "release", "class", "type", "state");
 158
 159 # holds all packages available from different repositories
 160 our $packages_list_db;
 161 our $packages_list_tn = "packages_list";
 162 my $packages_list_file_name;
 163 our @packages_list_col_names = ("distribution", "package", "version", "section", "description", "template", "timestamp");
 164 my $outdir = "/tmp/packages_list_db";
 165 my $arch = "i386";
 166
 167 # holds all messages which should be delivered to a user
 168 our $messaging_db;
 169 our $messaging_tn = "messaging";
 170 our @messaging_col_names = ("id INTEGER", "subject", "message_from", "message_to",
 171         "flag", "direction", "delivery_time", "message", "timestamp" );
 172 my $messaging_file_name;
 173
 174 # path to directory to store client install log files
 175 our $client_fai_log_dir = "/var/log/fai";
 176
 177 # queue which stores taskes until one of the $max_children children are ready to process the task
 178 my @tasks = qw();
 179 my $max_children = 2;
 180
 181
 182 %cfg_defaults = (
 183 "general" => {
 184     "log-file" => [\$log_file, "/var/run/".$prg.".log"],
 185     "pid-file" => [\$pid_file, "/var/run/".$prg.".pid"],
 186     },
 187 "bus" => {
 188     "activ" => [\$bus_activ, "true"],
 189     },
 190 "server" => {
 191     "port" => [\$server_port, "20081"],
 192     "known-clients" => [\$known_clients_file_name, '/var/lib/gosa-si/clients.db' ],
 193     "known-servers" => [\$known_server_file_name, '/var/lib/gosa-si/servers.db'],
 194     "login-users" => [\$login_users_file_name, '/var/lib/gosa-si/users.db'],
 195     "fai-server" => [\$fai_server_file_name, '/var/lib/gosa-si/fai_server.db'],
 196     "fai-release" => [\$fai_release_file_name, '/var/lib/gosa-si/fai_release.db'],
 197     "packages-list" => [\$packages_list_file_name, '/var/lib/gosa-si/packages.db'],
 198     "messaging" => [\$messaging_file_name, '/var/lib/gosa-si/messaging.db'],
 199     "source-list" => [\$sources_list, '/etc/apt/sources.list'],
 200     "repo-path" => [\$repo_path, '/srv/www/repository'],
 201     "ldap-uri" => [\$ldap_uri, ""],
 202     "ldap-base" => [\$ldap_base, ""],
 203     "ldap-admin-dn" => [\$ldap_admin_dn, ""],
 204     "ldap-admin-password" => [\$ldap_admin_password, ""],
 205     "gosa-unit-tag" => [\$gosa_unit_tag, ""],
 206     "max-clients" => [\$max_clients, 10],
 207     },
 208 "GOsaPackages" => {
 209     "ip" => [\$gosa_ip, "0.0.0.0"],
 210     "port" => [\$gosa_port, "20082"],
 211     "job-queue" => [\$job_queue_file_name, '/var/lib/gosa-si/jobs.db'],
 212     "job-queue-loop-delay" => [\$job_queue_loop_delay, 3],
 213     "messaging-db-loop-delay" => [\$messaging_db_loop_delay, 3],
 214     "key" => [\$GosaPackages_key, "none"],
 215     },
 216 "SIPackages" => {
 217     "key" => [\$SIPackages_key, "none"],
 218     },
 219 );
 220
 221
 222 #===  FUNCTION  ================================================================
 223 #         NAME:  usage
 224 #   PARAMETERS:  nothing
 225 #      RETURNS:  nothing
 226 #  DESCRIPTION:  print out usage text to STDERR
 227 #===============================================================================
 228 sub usage {
 229     print STDERR << "EOF" ;
 230 usage: $prg [-hvf] [-c config]
 231
 232            -h        : this (help) message
 233            -c <file> : config file
 234            -f        : foreground, process will not be forked to background
 235            -v        : be verbose (multiple to increase verbosity)
 236            -no-bus   : starts $prg without connection to bus
 237            -no-arp   : starts $prg without connection to arp module
 238
 239 EOF
 240     print "\n" ;
 241 }
 242
 243
 244 #===  FUNCTION  ================================================================
 245 #         NAME:  read_configfile
 246 #   PARAMETERS:  cfg_file - string -
 247 #      RETURNS:  nothing
 248 #  DESCRIPTION:  read cfg_file and set variables
 249 #===============================================================================
 250 sub read_configfile {
 251     my $cfg;
 252     if( defined( $cfg_file) && ( (-s $cfg_file) > 0 )) {
 253         if( -r $cfg_file ) {
 254             $cfg = Config::IniFiles->new( -file => $cfg_file );
 255         } else {
 256             print STDERR "Couldn't read config file!\n";
 257         }
 258     } else {
 259         $cfg = Config::IniFiles->new() ;
 260     }
 261     foreach my $section (keys %cfg_defaults) {
 262         foreach my $param (keys %{$cfg_defaults{ $section }}) {
 263             my $pinfo = $cfg_defaults{ $section }{ $param };
 264             ${@$pinfo[ 0 ]} = $cfg->val( $section, $param, @$pinfo[ 1 ] );
 265         }
 266     }
 267 }
 268
 269
 270 #===  FUNCTION  ================================================================
 271 #         NAME:  logging
 272 #   PARAMETERS:  level - string - default 'info'
 273 #                msg - string -
 274 #                facility - string - default 'LOG_DAEMON'
 275 #      RETURNS:  nothing
 276 #  DESCRIPTION:  function for logging
 277 #===============================================================================
 278 sub daemon_log {
 279     # log into log_file
 280     my( $msg, $level ) = @_;
 281     if(not defined $msg) { return }
 282     if(not defined $level) { $level = 1 }
 283     if(defined $log_file){
 284         open(LOG_HANDLE, ">>$log_file");
 285         if(not defined open( LOG_HANDLE, ">>$log_file" )) {
 286             print STDERR "cannot open $log_file: $!";
 287             return }
 288             chomp($msg);
 289                         $msg =~s/\n//g;   # no newlines are allowed in log messages, this is important for later log parsing
 290             if($level <= $verbose){
 291                 my ($seconds, $minutes, $hours, $monthday, $month,
 292                         $year, $weekday, $yearday, $sommertime) = localtime(time);
 293                 $hours = $hours < 10 ? $hours = "0".$hours : $hours;
 294                 $minutes = $minutes < 10 ? $minutes = "0".$minutes : $minutes;
 295                 $seconds = $seconds < 10 ? $seconds = "0".$seconds : $seconds;
 296                 my @monthnames = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
 297                 $month = $monthnames[$month];
 298                 $monthday = $monthday < 10 ? $monthday = "0".$monthday : $monthday;
 299                 $year+=1900;
 300                 my $name = $prg;
 301
 302                 my $log_msg = "$month $monthday $hours:$minutes:$seconds $name $msg\n";
 303                 print LOG_HANDLE $log_msg;
 304                 if( $foreground ) {
 305                     print STDERR $log_msg;
 306                 }
 307             }
 308         close( LOG_HANDLE );
 309     }
 310 }
 311
 312
 313 #===  FUNCTION  ================================================================
 314 #         NAME:  check_cmdline_param
 315 #   PARAMETERS:  nothing
 316 #      RETURNS:  nothing
 317 #  DESCRIPTION:  validates commandline parameter
 318 #===============================================================================
 319 sub check_cmdline_param () {
 320     my $err_config;
 321     my $err_counter = 0;
 322         if(not defined($cfg_file)) {
 323                 $cfg_file = "/etc/gosa-si/server.conf";
 324                 if(! -r $cfg_file) {
 325                         $err_config = "please specify a config file";
 326                         $err_counter += 1;
 327                 }
 328     }
 329     if( $err_counter > 0 ) {
 330         &usage( "", 1 );
 331         if( defined( $err_config)) { print STDERR "$err_config\n"}
 332         print STDERR "\n";
 333         exit( -1 );
 334     }
 335 }
 336
 337
 338 #===  FUNCTION  ================================================================
 339 #         NAME:  check_pid
 340 #   PARAMETERS:  nothing
 341 #      RETURNS:  nothing
 342 #  DESCRIPTION:  handels pid processing
 343 #===============================================================================
 344 sub check_pid {
 345     $pid = -1;
 346     # Check, if we are already running
 347     if( open(LOCK_FILE, "<$pid_file") ) {
 348         $pid = <LOCK_FILE>;
 349         if( defined $pid ) {
 350             chomp( $pid );
 351             if( -f "/proc/$pid/stat" ) {
 352                 my($stat) = `cat /proc/$pid/stat` =~ m/$pid \((.+)\).*/;
 353                 if( $stat ) {
 354                                         daemon_log("ERROR: Already running",1);
 355                     close( LOCK_FILE );
 356                     exit -1;
 357                 }
 358             }
 359         }
 360         close( LOCK_FILE );
 361         unlink( $pid_file );
 362     }
 363
 364     # create a syslog msg if it is not to possible to open PID file
 365     if (not sysopen(LOCK_FILE, $pid_file, O_WRONLY|O_CREAT|O_EXCL, 0644)) {
 366         my($msg) = "Couldn't obtain lockfile '$pid_file' ";
 367         if (open(LOCK_FILE, '<', $pid_file)
 368                 && ($pid = <LOCK_FILE>))
 369         {
 370             chomp($pid);
 371             $msg .= "(PID $pid)\n";
 372         } else {
 373             $msg .= "(unable to read PID)\n";
 374         }
 375         if( ! ($foreground) ) {
 376             openlog( $0, "cons,pid", "daemon" );
 377             syslog( "warning", $msg );
 378             closelog();
 379         }
 380         else {
 381             print( STDERR " $msg " );
 382         }
 383         exit( -1 );
 384     }
 385 }
 386
 387 #===  FUNCTION  ================================================================
 388 #         NAME:  import_modules
 389 #   PARAMETERS:  module_path - string - abs. path to the directory the modules
 390 #                are stored
 391 #      RETURNS:  nothing
 392 #  DESCRIPTION:  each file in module_path which ends with '.pm' and activation
 393 #                state is on is imported by "require 'file';"
 394 #===============================================================================
 395 sub import_modules {
 396     daemon_log(" ", 1);
 397
 398     if (not -e $modules_path) {
 399         daemon_log("ERROR: cannot find directory or directory is not readable: $modules_path", 1);
 400     }
 401
 402     opendir (DIR, $modules_path) or die "ERROR while loading modules from directory $modules_path : $!\n";
 403     while (defined (my $file = readdir (DIR))) {
 404         if (not $file =~ /(\S*?).pm$/) {
 405             next;
 406         }
 407                 my $mod_name = $1;
 408
 409         if( $file =~ /ArpHandler.pm/ ) {
 410             if( $no_arp > 0 ) {
 411                 next;
 412             }
 413         }
 414
 415         eval { require $file; };
 416         if ($@) {
 417             daemon_log("ERROR: gosa-si-server could not load module $file", 1);
 418             daemon_log("$@", 5);
 419                 } else {
 420                         my $info = eval($mod_name.'::get_module_info()');
 421                         # Only load module if get_module_info() returns a non-null object
 422                         if( $info ) {
 423                                 my ($input_address, $input_key, $input, $input_active, $input_type) = @{$info};
 424                                 $known_modules->{$mod_name} = $info;
 425                                 daemon_log("INFO: module $mod_name loaded", 5);
 426                         }
 427                 }
 428     }
 429     close (DIR);
 430 }
 431
 432
 433 #===  FUNCTION  ================================================================
 434 #         NAME:  sig_int_handler
 435 #   PARAMETERS:  signal - string - signal arose from system
 436 #      RETURNS:  noting
 437 #  DESCRIPTION:  handels tasks to be done befor signal becomes active
 438 #===============================================================================
 439 sub sig_int_handler {
 440     my ($signal) = @_;
 441
 442 #       if (defined($ldap_handle)) {
 443 #               $ldap_handle->disconnect;
 444 #       }
 445     # TODO alle verbliebenden ldap verbindungen aus allen heaps beenden
 446
 447
 448     daemon_log("shutting down gosa-si-server", 1);
 449     system("kill `ps -C gosa-si-server -o pid=`");
 450 }
 451 $SIG{INT} = \&sig_int_handler;
 452
 453
 454 sub check_key_and_xml_validity {
 455     my ($crypted_msg, $module_key, $session_id) = @_;
 456     my $msg;
 457     my $msg_hash;
 458     my $error_string;
 459     eval{
 460         $msg = &decrypt_msg($crypted_msg, $module_key);
 461
 462         if ($msg =~ /<xml>/i){
 463             $msg =~ s/\s+/ /g;  # just for better daemon_log
 464             daemon_log("$session_id DEBUG: decrypted_msg: \n$msg", 8);
 465             $msg_hash = $xml->XMLin($msg, ForceArray=>1);
 466
 467             ##############
 468             # check header
 469             if( not exists $msg_hash->{'header'} ) { die "no header specified"; }
 470             my $header_l = $msg_hash->{'header'};
 471             if( 1 > @{$header_l} ) { die 'empty header tag'; }
 472             if( 1 < @{$header_l} ) { die 'more than one header specified'; }
 473             my $header = @{$header_l}[0];
 474             if( 0 == length $header) { die 'empty string in header tag'; }
 475
 476             ##############
 477             # check source
 478             if( not exists $msg_hash->{'source'} ) { die "no source specified"; }
 479             my $source_l = $msg_hash->{'source'};
 480             if( 1 > @{$source_l} ) { die 'empty source tag'; }
 481             if( 1 < @{$source_l} ) { die 'more than one source specified'; }
 482             my $source = @{$source_l}[0];
 483             if( 0 == length $source) { die 'source error'; }
 484
 485             ##############
 486             # check target
 487             if( not exists $msg_hash->{'target'} ) { die "no target specified"; }
 488             my $target_l = $msg_hash->{'target'};
 489             if( 1 > @{$target_l} ) { die 'empty target tag'; }
 490         }
 491     };
 492     if($@) {
 493         daemon_log("$session_id DEBUG: do not understand the message: $@", 7);
 494         $msg = undef;
 495         $msg_hash = undef;
 496     }
 497
 498     return ($msg, $msg_hash);
 499 }
 500
 501
 502 sub check_outgoing_xml_validity {
 503     my ($msg) = @_;
 504
 505     my $msg_hash;
 506     eval{
 507         $msg_hash = $xml->XMLin($msg, ForceArray=>1);
 508
 509         ##############
 510         # check header
 511         my $header_l = $msg_hash->{'header'};
 512         if( 1 != @{$header_l} ) {
 513             die 'no or more than one headers specified';
 514         }
 515         my $header = @{$header_l}[0];
 516         if( 0 == length $header) {
 517             die 'header has length 0';
 518         }
 519
 520         ##############
 521         # check source
 522         my $source_l = $msg_hash->{'source'};
 523         if( 1 != @{$source_l} ) {
 524             die 'no or more than 1 sources specified';
 525         }
 526         my $source = @{$source_l}[0];
 527         if( 0 == length $source) {
 528             die 'source has length 0';
 529         }
 530         unless( $source =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+$/ ||
 531                 $source =~ /^GOSA$/i ) {
 532             die "source '$source' is neither a complete ip-address with port nor 'GOSA'";
 533         }
 534
 535         ##############
 536         # check target
 537         my $target_l = $msg_hash->{'target'};
 538         if( 0 == @{$target_l} ) {
 539             die "no targets specified";
 540         }
 541         foreach my $target (@$target_l) {
 542             if( 0 == length $target) {
 543                 die "target has length 0";
 544             }
 545             unless( $target =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+$/ ||
 546                     $target =~ /^GOSA$/i ||
 547                     $target =~ /^\*$/ ||
 548                     $target =~ /KNOWN_SERVER/i ||
 549                     $target =~ /JOBDB/i ||
 550                     $target =~ /^([0-9a-f]{2}:[0-9a-f]{2}:[0-9a-f]{2}:[0-9a-f]{2}:[0-9a-f]{2}:[0-9a-f]{2})$/i ){
 551                 die "target '$target' is not a complete ip-address with port or a valid target name or a mac-address";
 552             }
 553         }
 554     };
 555     if($@) {
 556         daemon_log("WARNING: outgoing msg is not gosa-si envelope conform", 5);
 557         daemon_log("$@ ".(defined($msg) && length($msg)>0)?$msg:"Empty Message", 8);
 558         $msg_hash = undef;
 559     }
 560
 561     return ($msg_hash);
 562 }
 563
 564
 565 sub input_from_known_server {
 566     my ($input, $remote_ip, $session_id) = @_ ;
 567     my ($msg, $msg_hash, $module);
 568
 569     my $sql_statement= "SELECT * FROM known_server";
 570     my $query_res = $known_server_db->select_dbentry( $sql_statement );
 571
 572     while( my ($hit_num, $hit) = each %{ $query_res } ) {
 573         my $host_name = $hit->{hostname};
 574         if( not $host_name =~ "^$remote_ip") {
 575             next;
 576         }
 577         my $host_key = $hit->{hostkey};
 578         daemon_log("$session_id DEBUG: input_from_known_server: host_name: $host_name", 7);
 579         daemon_log("DEBUG: input_from_known_server: host_key: $host_key", 7);
 580
 581         # check if module can open msg envelope with module key
 582         my ($tmp_msg, $tmp_msg_hash) = &check_key_and_xml_validity($input, $host_key, $session_id);
 583         if( (!$tmp_msg) || (!$tmp_msg_hash) ) {
 584             daemon_log("$session_id DEBUG: input_from_known_server: deciphering raise error", 7);
 585             daemon_log("$@", 8);
 586             next;
 587         }
 588         else {
 589             $msg = $tmp_msg;
 590             $msg_hash = $tmp_msg_hash;
 591             $module = "SIPackages";
 592             last;
 593         }
 594     }
 595
 596     if( (!$msg) || (!$msg_hash) || (!$module) ) {
 597         daemon_log("$session_id DEBUG: Incoming message is not from a known server", 7);
 598     }
 599
 600     return ($msg, $msg_hash, $module);
 601 }
 602
 603
 604 sub input_from_known_client {
 605     my ($input, $remote_ip, $session_id) = @_ ;
 606     my ($msg, $msg_hash, $module);
 607
 608     my $sql_statement= "SELECT * FROM known_clients";
 609     my $query_res = $known_clients_db->select_dbentry( $sql_statement );
 610     while( my ($hit_num, $hit) = each %{ $query_res } ) {
 611         my $host_name = $hit->{hostname};
 612         if( not $host_name =~ /^$remote_ip:\d*$/) {
 613                 next;
 614                 }
 615         my $host_key = $hit->{hostkey};
 616         &daemon_log("$session_id DEBUG: input_from_known_client: host_name: $host_name", 7);
 617         &daemon_log("$session_id DEBUG: input_from_known_client: host_key: $host_key", 7);
 618
 619         # check if module can open msg envelope with module key
 620         ($msg, $msg_hash) = &check_key_and_xml_validity($input, $host_key, $session_id);
 621
 622         if( (!$msg) || (!$msg_hash) ) {
 623             &daemon_log("$session_id DEGUG: input_from_known_client: deciphering raise error", 7);
 624             &daemon_log("$@", 8);
 625             next;
 626         }
 627         else {
 628             $module = "SIPackages";
 629             last;
 630         }
 631     }
 632
 633     if( (!$msg) || (!$msg_hash) || (!$module) ) {
 634         &daemon_log("$session_id DEBUG: Incoming message is not from a known client", 7);
 635     }
 636
 637     return ($msg, $msg_hash, $module);
 638 }
 639
 640
 641 sub input_from_unknown_host {
 642     no strict "refs";
 643     my ($input, $session_id) = @_ ;
 644     my ($msg, $msg_hash, $module);
 645     my $error_string;
 646
 647         my %act_modules = %$known_modules;
 648
 649         while( my ($mod, $info) = each(%act_modules)) {
 650
 651         # check a key exists for this module
 652         my $module_key = ${$mod."_key"};
 653         if( not defined $module_key ) {
 654             if( $mod eq 'ArpHandler' ) {
 655                 next;
 656             }
 657             daemon_log("$session_id ERROR: no key specified in config file for $mod", 1);
 658             next;
 659         }
 660         daemon_log("$session_id DEBUG: $mod: $module_key", 7);
 661
 662         # check if module can open msg envelope with module key
 663         ($msg, $msg_hash) = &check_key_and_xml_validity($input, $module_key, $session_id);
 664         if( (not defined $msg) || (not defined $msg_hash) ) {
 665             next;
 666         }
 667         else {
 668             $module = $mod;
 669             last;
 670         }
 671     }
 672
 673     if( (!$msg) || (!$msg_hash) || (!$module)) {
 674         daemon_log("$session_id DEBUG: Incoming message is not from an unknown host", 7);
 675     }
 676
 677     return ($msg, $msg_hash, $module);
 678 }
 679
 680
 681 sub create_ciphering {
 682     my ($passwd) = @_;
 683         if((!defined($passwd)) || length($passwd)==0) {
 684                 $passwd = "";
 685         }
 686     $passwd = substr(md5_hex("$passwd") x 32, 0, 32);
 687     my $iv = substr(md5_hex('GONICUS GmbH'),0, 16);
 688     my $my_cipher = Crypt::Rijndael->new($passwd , Crypt::Rijndael::MODE_CBC());
 689     $my_cipher->set_iv($iv);
 690     return $my_cipher;
 691 }
 692
 693
 694 sub encrypt_msg {
 695     my ($msg, $key) = @_;
 696     my $my_cipher = &create_ciphering($key);
 697     my $len;
 698     {
 699             use bytes;
 700             $len= 16-length($msg)%16;
 701     }
 702     $msg = "\0"x($len).$msg;
 703     $msg = $my_cipher->encrypt($msg);
 704     chomp($msg = &encode_base64($msg));
 705     # there are no newlines allowed inside msg
 706     $msg=~ s/\n//g;
 707     return $msg;
 708 }
 709
 710
 711 sub decrypt_msg {
 712
 713     my ($msg, $key) = @_ ;
 714     $msg = &decode_base64($msg);
 715     my $my_cipher = &create_ciphering($key);
 716     $msg = $my_cipher->decrypt($msg);
 717     $msg =~ s/\0*//g;
 718     return $msg;
 719 }
 720
 721
 722 sub get_encrypt_key {
 723     my ($target) = @_ ;
 724     my $encrypt_key;
 725     my $error = 0;
 726
 727     # target can be in known_server
 728     if( not defined $encrypt_key ) {
 729         my $sql_statement= "SELECT * FROM known_server WHERE hostname='$target'";
 730         my $query_res = $known_server_db->select_dbentry( $sql_statement );
 731         while( my ($hit_num, $hit) = each %{ $query_res } ) {
 732             my $host_name = $hit->{hostname};
 733             if( $host_name ne $target ) {
 734                 next;
 735             }
 736             $encrypt_key = $hit->{hostkey};
 737             last;
 738         }
 739     }
 740
 741     # target can be in known_client
 742     if( not defined $encrypt_key ) {
 743         my $sql_statement= "SELECT * FROM known_clients WHERE hostname='$target'";
 744         my $query_res = $known_clients_db->select_dbentry( $sql_statement );
 745         while( my ($hit_num, $hit) = each %{ $query_res } ) {
 746             my $host_name = $hit->{hostname};
 747             if( $host_name ne $target ) {
 748                 next;
 749             }
 750             $encrypt_key = $hit->{hostkey};
 751             last;
 752         }
 753     }
 754
 755     return $encrypt_key;
 756 }
 757
 758
 759 #===  FUNCTION  ================================================================
 760 #         NAME:  open_socket
 761 #   PARAMETERS:  PeerAddr string something like 192.168.1.1 or 192.168.1.1:10000
 762 #                [PeerPort] string necessary if port not appended by PeerAddr
 763 #      RETURNS:  socket IO::Socket::INET
 764 #  DESCRIPTION:  open a socket to PeerAddr
 765 #===============================================================================
 766 sub open_socket {
 767     my ($PeerAddr, $PeerPort) = @_ ;
 768     if(defined($PeerPort)){
 769         $PeerAddr = $PeerAddr.":".$PeerPort;
 770     }
 771     my $socket;
 772     $socket = new IO::Socket::INET(PeerAddr => $PeerAddr,
 773             Porto => "tcp",
 774             Type => SOCK_STREAM,
 775             Timeout => 5,
 776             );
 777     if(not defined $socket) {
 778         return;
 779     }
 780 #    &daemon_log("DEBUG: open_socket: $PeerAddr", 7);
 781     return $socket;
 782 }
 783
 784
 785 #===  FUNCTION  ================================================================
 786 #         NAME:  get_ip
 787 #   PARAMETERS:  interface name (i.e. eth0)
 788 #      RETURNS:  (ip address)
 789 #  DESCRIPTION:  Uses ioctl to get ip address directly from system.
 790 #===============================================================================
 791 sub get_ip {
 792         my $ifreq= shift;
 793         my $result= "";
 794         my $SIOCGIFADDR= 0x8915;       # man 2 ioctl_list
 795         my $proto= getprotobyname('ip');
 796
 797         socket SOCKET, PF_INET, SOCK_DGRAM, $proto
 798                 or die "socket: $!";
 799
 800         if(ioctl SOCKET, $SIOCGIFADDR, $ifreq) {
 801                 my ($if, $sin)    = unpack 'a16 a16', $ifreq;
 802                 my ($port, $addr) = sockaddr_in $sin;
 803                 my $ip            = inet_ntoa $addr;
 804
 805                 if ($ip && length($ip) > 0) {
 806                         $result = $ip;
 807                 }
 808         }
 809
 810         return $result;
 811 }
 812
 813
 814 sub get_local_ip_for_remote_ip {
 815         my $remote_ip= shift;
 816         my $result="0.0.0.0";
 817
 818         if($remote_ip =~ /^(\d\d?\d?\.){3}\d\d?\d?$/) {
 819                 if($remote_ip eq "127.0.0.1") {
 820                         $result = "127.0.0.1";
 821                 } else {
 822                         my $PROC_NET_ROUTE= ('/proc/net/route');
 823
 824                         open(PROC_NET_ROUTE, "<$PROC_NET_ROUTE")
 825                                 or die "Could not open $PROC_NET_ROUTE";
 826
 827                         my @ifs = <PROC_NET_ROUTE>;
 828
 829                         close(PROC_NET_ROUTE);
 830
 831                         # Eat header line
 832                         shift @ifs;
 833                         chomp @ifs;
 834                         foreach my $line(@ifs) {
 835                                 my ($Iface,$Destination,$Gateway,$Flags,$RefCnt,$Use,$Metric,$Mask,$MTU,$Window,$IRTT)=split(/\s/, $line);
 836                                 my $destination;
 837                                 my $mask;
 838                                 my ($d,$c,$b,$a)=unpack('a2 a2 a2 a2', $Destination);
 839                                 $destination= sprintf("%d.%d.%d.%d", hex($a), hex($b), hex($c), hex($d));
 840                                 ($d,$c,$b,$a)=unpack('a2 a2 a2 a2', $Mask);
 841                                 $mask= sprintf("%d.%d.%d.%d", hex($a), hex($b), hex($c), hex($d));
 842                                 if(new NetAddr::IP($remote_ip)->within(new NetAddr::IP($destination, $mask))) {
 843                                         # destination matches route, save mac and exit
 844                                         $result= &get_ip($Iface);
 845                                         last;
 846                                 }
 847                         }
 848                 }
 849         } else {
 850                 daemon_log("get_local_ip_for_remote_ip was called with a non-ip parameter: $remote_ip", 1);
 851         }
 852         return $result;
 853 }
 854
 855
 856 sub send_msg_to_target {
 857     my ($msg, $address, $encrypt_key, $msg_header, $session_id) = @_ ;
 858     my $error = 0;
 859     my $header;
 860     my $new_status;
 861     my $act_status;
 862     my ($sql_statement, $res);
 863
 864     if( $msg_header ) {
 865         $header = "'$msg_header'-";
 866     } else {
 867         $header = "";
 868     }
 869
 870         # Patch the source ip
 871         if($msg =~ /<source>0\.0\.0\.0:\d*?<\/source>/) {
 872                 my $remote_ip = &get_local_ip_for_remote_ip(sprintf("%s", $address =~ /^([0-9\.]*?):.*$/));
 873                 $msg =~ s/<source>(0\.0\.0\.0):(\d*?)<\/source>/<source>$remote_ip:$2<\/source>/s;
 874         }
 875
 876     # encrypt xml msg
 877     my $crypted_msg = &encrypt_msg($msg, $encrypt_key);
 878
 879     # opensocket
 880     my $socket = &open_socket($address);
 881     if( !$socket ) {
 882         daemon_log("$session_id ERROR: cannot send ".$header."msg to $address , host not reachable", 1);
 883         $error++;
 884     }
 885
 886     if( $error == 0 ) {
 887         # send xml msg
 888         print $socket $crypted_msg."\n";
 889
 890         daemon_log("$session_id INFO: send ".$header."msg to $address", 5);
 891         #daemon_log("DEBUG: message:\n$msg", 9);
 892
 893     }
 894
 895     # close socket in any case
 896     if( $socket ) {
 897         close $socket;
 898     }
 899
 900     if( $error > 0 ) { $new_status = "down"; }
 901     else { $new_status = $msg_header; }
 902
 903
 904     # known_clients
 905     $sql_statement = "SELECT * FROM known_clients WHERE hostname='$address'";
 906     $res = $known_clients_db->select_dbentry($sql_statement);
 907     if( keys(%$res) > 0) {
 908         $act_status = $res->{1}->{'status'};
 909         if( $act_status eq "down" ) {
 910             $sql_statement = "DELETE FROM known_clients WHERE hostname='$address'";
 911             $res = $known_clients_db->del_dbentry($sql_statement);
 912             daemon_log("$session_id WARNING: failed 2x to send msg to host '$address', delete host from known_clients", 3);
 913         } else {
 914             $sql_statement = "UPDATE known_clients SET status='$new_status' WHERE hostname='$address'";
 915             $res = $known_clients_db->update_dbentry($sql_statement);
 916             if($new_status eq "down"){
 917                 daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
 918             } else {
 919                 daemon_log("$session_id INFO: set '$address' from status '$act_status' to '$new_status'", 5);
 920             }
 921         }
 922     }
 923
 924     # known_server
 925     $sql_statement = "SELECT * FROM known_server WHERE hostname='$address'";
 926     $res = $known_server_db->select_dbentry($sql_statement);
 927     if( keys(%$res) > 0 ) {
 928         $act_status = $res->{1}->{'status'};
 929         if( $act_status eq "down" ) {
 930             $sql_statement = "DELETE FROM known_server WHERE hostname='$address'";
 931             $res = $known_server_db->del_dbentry($sql_statement);
 932             daemon_log("$session_id WARNING: failed 2x to a send msg to host '$address', delete host from known_server", 3);
 933         }
 934         else {
 935             $sql_statement = "UPDATE known_server SET status='$new_status' WHERE hostname='$address'";
 936             $res = $known_server_db->update_dbentry($sql_statement);
 937             if($new_status eq "down"){
 938                 daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
 939             }
 940             else {
 941                 daemon_log("$session_id INFO: set '$address' from status '$act_status' to '$new_status'", 5);
 942             }
 943         }
 944     }
 945     return $error;
 946 }
 947
 948
 949 sub update_jobdb_status_for_send_msgs {
 950     my ($answer, $error) = @_;
 951     if( $answer =~ /<jobdb_id>(\d+)<\/jobdb_id>/ ) {
 952         my $jobdb_id = $1;
 953
 954         # sending msg faild
 955         if( $error ) {
 956             if (not $answer =~ /<header>trigger_action_reinstall<\/header>/) {
 957                 my $sql_statement = "UPDATE $job_queue_tn ".
 958                     "SET status='error', result='can not deliver msg, please consult log file' ".
 959                     "WHERE id='$jobdb_id'";
 960                 my $res = $job_db->update_dbentry($sql_statement);
 961             }
 962
 963         # sending msg was successful
 964         } else {
 965             my $sql_statement = "UPDATE $job_queue_tn ".
 966                 "SET status='done' ".
 967                 "WHERE id='$jobdb_id' AND status='processed'";
 968             my $res = $job_db->update_dbentry($sql_statement);
 969         }
 970     }
 971 }
 972
 973 sub _start {
 974     my ($kernel) = $_[KERNEL];
 975     &trigger_db_loop($kernel);
 976     $global_kernel = $kernel;
 977         $kernel->yield('create_fai_server_db', $fai_server_tn );
 978         $kernel->yield('create_fai_release_db', $fai_release_tn );
 979         $kernel->sig(USR1 => "sig_handler");
 980         $kernel->sig(USR2 => "create_packages_list_db");
 981 }
 982
 983 sub sig_handler {
 984         my ($kernel, $signal) = @_[KERNEL, ARG0] ;
 985         daemon_log("0 INFO got signal '$signal'", 1);
 986         $kernel->sig_handled();
 987         return;
 988 }
 989
 990 sub next_task {
 991     my ($session, $heap) = @_[SESSION, HEAP];
 992
 993     while ( keys( %{ $heap->{task} } ) < $max_children ) {
 994         my $next_task = shift @tasks;
 995         last unless defined $next_task;
 996
 997         my $task = POE::Wheel::Run->new(
 998                 Program => sub { process_task($session, $heap, $next_task) },
 999                 StdioFilter => POE::Filter::Reference->new(),
1000                 StdoutEvent  => "task_result",
1001                 StderrEvent  => "task_debug",
1002                 CloseEvent   => "task_done",
1003                );
1004
1005         $heap->{task}->{ $task->ID } = $task;
1006     }
1007 }
1008
1009 sub handle_task_result {
1010     my ($kernel, $heap, $result) = @_[KERNEL, HEAP, ARG0];
1011     my $client_answer = $result->{'answer'};
1012     if( $client_answer =~ s/session_id=(\d+)$// ) {
1013         my $session_id = $1;
1014         if( defined $session_id ) {
1015             my $session_reference = $kernel->ID_id_to_session($session_id);
1016             if( defined $session_reference ) {
1017                 $heap = $session_reference->get_heap();
1018             }
1019         }
1020
1021         if(exists $heap->{'client'}) {
1022             $heap->{'client'}->put($client_answer);
1023         }
1024     }
1025     $kernel->sig(CHLD => "child_reap");
1026 }
1027
1028 sub handle_task_debug {
1029     my $result = $_[ARG0];
1030     print STDERR "$result\n";
1031 }
1032
1033 sub handle_task_done {
1034     my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
1035     delete $heap->{task}->{$task_id};
1036     $kernel->yield("next_task");
1037 }
1038
1039 sub process_task {
1040     no strict "refs";
1041     my ($session, $heap, $input) = @_;
1042     my $session_id = $session->ID;
1043     my ($msg, $msg_hash, $module);
1044     my $error = 0;
1045     my $answer_l;
1046     my ($answer_header, @answer_target_l, $answer_source);
1047     my $client_answer = "";
1048
1049     daemon_log("", 5);
1050     daemon_log("$session_id INFO: Incoming msg with session ID $session_id from '".$heap->{'remote_ip'}."'", 5);
1051     #daemon_log("$session_id DEBUG: Incoming msg:\n$input", 9);
1052
1053     ####################
1054     # check incoming msg
1055     # msg is from a new client or gosa
1056     ($msg, $msg_hash, $module) = &input_from_unknown_host($input, $session_id);
1057     # msg is from a gosa-si-server or gosa-si-bus
1058     if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1059         ($msg, $msg_hash, $module) = &input_from_known_server($input, $heap->{'remote_ip'}, $session_id);
1060     }
1061     # msg is from a gosa-si-client
1062     if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1063         ($msg, $msg_hash, $module) = &input_from_known_client($input, $heap->{'remote_ip'}, $session_id);
1064     }
1065     # an error occurred
1066     if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1067         # if an incoming msg could not be decrypted (maybe a wrong key), send client a ping. If the client
1068         # could not understand a msg from its server the client cause a re-registering process
1069         daemon_log("$session_id INFO cannot understand incoming msg, send 'ping'-msg to all host with ip '".$heap->{remote_ip}."' to cause a re-registering of the client if necessary", 5);
1070         my $sql_statement = "SELECT * FROM $main::known_clients_tn WHERE (hostname LIKE '".$heap->{'remote_ip'}."%')";
1071         my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1072         while( my ($hit_num, $hit) = each %{ $query_res } ) {
1073             my $host_name = $hit->{'hostname'};
1074             my $host_key = $hit->{'hostkey'};
1075             my $ping_msg = "<xml> <header>gosa_ping</header> <source>$server_address</source> <target>$host_name</target></xml>";
1076             my $error = &send_msg_to_target($ping_msg, $host_name, $host_key, "gosa_ping", $session_id);
1077             &update_jobdb_status_for_send_msgs($ping_msg, $error);
1078         }
1079         $error++;
1080     }
1081
1082     ######################
1083     # process incoming msg
1084     if( $error == 0) {
1085         daemon_log("$session_id INFO: Incoming msg with header '".@{$msg_hash->{'header'}}[0].
1086                                 "' from '".$heap->{'remote_ip'}."'", 5);
1087         daemon_log("$session_id DEBUG: Processing module ".$module, 7);
1088         $answer_l = &{ $module."::process_incoming_msg" }($msg, $msg_hash, $session_id);
1089
1090         if ( 0 < @{$answer_l} ) {
1091             my $answer_str = join("\n", @{$answer_l});
1092             daemon_log("$session_id DEBUG: $module: Got answer from module: \n".$answer_str,8);
1093         } else {
1094             daemon_log("$session_id DEBUG: $module: Got no answer from module!" ,8);
1095         }
1096
1097     }
1098     if( !$answer_l ) { $error++ };
1099
1100     ########
1101     # answer
1102     if( $error == 0 ) {
1103
1104         foreach my $answer ( @{$answer_l} ) {
1105             # for each answer in answer list
1106
1107             # check outgoing msg to xml validity
1108             my $answer_hash = &check_outgoing_xml_validity($answer);
1109             if( not defined $answer_hash ) {
1110                 next;
1111             }
1112
1113             $answer_header = @{$answer_hash->{'header'}}[0];
1114             @answer_target_l = @{$answer_hash->{'target'}};
1115             $answer_source = @{$answer_hash->{'source'}}[0];
1116
1117             # deliver msg to all targets
1118             foreach my $answer_target ( @answer_target_l ) {
1119
1120                 # targets of msg are all gosa-si-clients in known_clients_db
1121                 if( $answer_target eq "*" ) {
1122                     # answer is for all clients
1123                     my $sql_statement= "SELECT * FROM known_clients";
1124                     my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1125                     while( my ($hit_num, $hit) = each %{ $query_res } ) {
1126                         my $host_name = $hit->{hostname};
1127                         my $host_key = $hit->{hostkey};
1128                         my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1129                         &update_jobdb_status_for_send_msgs($answer, $error);
1130                     }
1131                 }
1132
1133                 # targets of msg are all gosa-si-server in known_server_db
1134                 elsif( $answer_target eq "KNOWN_SERVER" ) {
1135                     # answer is for all server in known_server
1136                     my $sql_statement= "SELECT * FROM known_server";
1137                     my $query_res = $known_server_db->select_dbentry( $sql_statement );
1138                     while( my ($hit_num, $hit) = each %{ $query_res } ) {
1139                         my $host_name = $hit->{hostname};
1140                         my $host_key = $hit->{hostkey};
1141                         $answer =~ s/KNOWN_SERVER/$host_name/g;
1142                         my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1143                         &update_jobdb_status_for_send_msgs($answer, $error);
1144                     }
1145                 }
1146
1147                 # target of msg is GOsa
1148                                 elsif( $answer_target eq "GOSA" ) {
1149                                         my $session_id = ($1) if $answer =~ /<session_id>(\d+?)<\/session_id>/;
1150                                         my $add_on = "";
1151                     if( defined $session_id ) {
1152                         $add_on = ".session_id=$session_id";
1153                     }
1154                     # answer is for GOSA and has to returned to connected client
1155                     my $gosa_answer = &encrypt_msg($answer, $GosaPackages_key);
1156                     $client_answer = $gosa_answer.$add_on;
1157                 }
1158
1159                 # target of msg is job queue at this host
1160                 elsif( $answer_target eq "JOBDB") {
1161                     $answer =~ /<header>(\S+)<\/header>/;
1162                     my $header;
1163                     if( defined $1 ) { $header = $1; }
1164                     my $error = &send_msg_to_target($answer, $server_address, $GosaPackages_key, $header, $session_id);
1165                     &update_jobdb_status_for_send_msgs($answer, $error);
1166                 }
1167
1168                 # target of msg is a mac address
1169                 elsif( $answer_target =~ /^([0-9a-f]{2}:[0-9a-f]{2}:[0-9a-f]{2}:[0-9a-f]{2}:[0-9a-f]{2}:[0-9a-f]{2})$/i ) {
1170                     daemon_log("$session_id INFO: target is mac address '$answer_target', looking for host in known_clients", 5);
1171                     my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$answer_target'";
1172                     my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1173                     my $found_ip_flag = 0;
1174                     while( my ($hit_num, $hit) = each %{ $query_res } ) {
1175                         my $host_name = $hit->{hostname};
1176                         my $host_key = $hit->{hostkey};
1177                         $answer =~ s/$answer_target/$host_name/g;
1178                         daemon_log("$session_id INFO: found host '$host_name', associated to '$answer_target'", 5);
1179                         my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1180                         &update_jobdb_status_for_send_msgs($answer, $error);
1181                         $found_ip_flag++ ;
1182                     }
1183                     if( $found_ip_flag == 0) {
1184                         daemon_log("$session_id WARNING: no host found in known_clients with mac address '$answer_target'", 3);
1185                         if( $bus_activ eq "true" ) {
1186                             daemon_log("$session_id INFO: try to forward msg '$answer_header' to bus '$bus_address'", 5);
1187                             my $sql_statement = "SELECT * FROM known_server WHERE hostname='$bus_address'";
1188                             my $query_res = $known_server_db->select_dbentry( $sql_statement );
1189                             while( my ($hit_num, $hit) = each %{ $query_res } ) {
1190                                 my $bus_address = $hit->{hostname};
1191                                 my $bus_key = $hit->{hostkey};
1192                                 my $error = &send_msg_to_target($answer, $bus_address, $bus_key, $answer_header, $session_id);
1193                                 &update_jobdb_status_for_send_msgs($answer, $error);
1194                                 last;
1195                             }
1196                         }
1197
1198                     }
1199
1200                 #  answer is for one specific host
1201                 } else {
1202                     # get encrypt_key
1203                     my $encrypt_key = &get_encrypt_key($answer_target);
1204                     if( not defined $encrypt_key ) {
1205                         # unknown target, forward msg to bus
1206                         daemon_log("$session_id WARNING: unknown target '$answer_target'", 3);
1207                         if( $bus_activ eq "true" ) {
1208                             daemon_log("$session_id INFO: try to forward msg '$answer_header' to bus '$bus_address'", 5);
1209                             my $sql_statement = "SELECT * FROM known_server WHERE hostname='$bus_address'";
1210                             my $query_res = $known_server_db->select_dbentry( $sql_statement );
1211                             my $res_length = keys( %{$query_res} );
1212                             if( $res_length == 0 ){
1213                                 daemon_log("$session_id WARNING: send '$answer_header' to '$bus_address' failed, ".
1214                                         "no bus found in known_server", 3);
1215                             }
1216                             else {
1217                                 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1218                                     my $bus_key = $hit->{hostkey};
1219                                     my $error = &send_msg_to_target($answer, $bus_address, $bus_key, $answer_header,$session_id );
1220                                     &update_jobdb_status_for_send_msgs($answer, $error);
1221                                 }
1222                             }
1223                         }
1224                         next;
1225                     }
1226                     my $error = &send_msg_to_target($answer, $answer_target, $encrypt_key, $answer_header,$session_id);
1227                     &update_jobdb_status_for_send_msgs($answer, $error);
1228                 }
1229             }
1230         }
1231     }
1232
1233     my $filter = POE::Filter::Reference->new();
1234     my %result = (
1235             status => "seems ok to me",
1236             answer => $client_answer,
1237             );
1238
1239     my $output = $filter->put( [ \%result ] );
1240     print @$output;
1241
1242
1243 }
1244
1245
1246 sub trigger_db_loop {
1247         my ($kernel) = @_ ;
1248         $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
1249         $kernel->delay_set('watch_for_done_jobs', $job_queue_loop_delay);
1250     $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
1251     $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
1252 }
1253
1254 sub watch_for_done_jobs {
1255     my ($kernel,$heap) = @_[KERNEL, HEAP];
1256
1257     my $sql_statement = "SELECT * FROM ".$job_queue_tn.
1258         " WHERE status='done'";
1259         my $res = $job_db->select_dbentry( $sql_statement );
1260
1261     while( my ($id, $hit) = each %{$res} ) {
1262         my $jobdb_id = $hit->{id};
1263         my $sql_statement = "DELETE FROM $job_queue_tn WHERE id='$jobdb_id'";
1264         my $res = $job_db->del_dbentry($sql_statement);
1265     }
1266
1267     $kernel->delay_set('watch_for_done_jobs',$job_queue_loop_delay);
1268 }
1269
1270 sub watch_for_new_jobs {
1271         my ($kernel,$heap) = @_[KERNEL, HEAP];
1272
1273         # check gosa job queue for jobs with executable timestamp
1274         my $timestamp = &get_time();
1275         my $sql_statement = "SELECT * FROM $job_queue_tn WHERE status='waiting' AND (CAST (timestamp AS INTEGER)) < $timestamp ORDER BY timestamp";
1276         my $res = $job_db->exec_statement( $sql_statement );
1277
1278         # Merge all new jobs that would do the same actions
1279         my @drops;
1280         my $hits;
1281         foreach my $hit (reverse @{$res} ) {
1282                 my $macaddress= lc @{$hit}[8];
1283                 my $headertag= @{$hit}[5];
1284                 if(defined($hits->{$macaddress}->{$headertag})) {
1285                         push @drops, "DELETE FROM $job_queue_tn WHERE id = '$hits->{$macaddress}->{$headertag}[0]'";
1286                 }
1287                 $hits->{$macaddress}->{$headertag}= $hit;
1288         }
1289
1290         # Delete new jobs with a matching job in state 'processing'
1291         foreach my $macaddress (keys %{$hits}) {
1292                 foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
1293                         my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
1294                         my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND headertag='$jobdb_headertag' AND status='processing'";
1295                         my $res = $job_db->exec_statement( $sql_statement );
1296                         foreach my $hit (@{$res}) {
1297                                 push @drops, "DELETE FROM $job_queue_tn WHERE id = '$jobdb_id'";
1298                         }
1299                 }
1300         }
1301
1302         # Commit deletion
1303         $job_db->exec_statementlist(\@drops);
1304
1305         # Look for new jobs that could be executed
1306         foreach my $macaddress (keys %{$hits}) {
1307
1308                 # Look if there is an executing job
1309                 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND status='processing'";
1310                 my $res = $job_db->exec_statement( $sql_statement );
1311
1312                 # Skip new jobs for host if there is a processing job
1313                 if(defined($res) and defined @{$res}[0]) {
1314                         next;
1315                 }
1316
1317                 foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
1318                         my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
1319                         my $job_msg = @{$hits->{$macaddress}->{$jobdb_headertag}}[7];
1320
1321                         daemon_log("J DEBUG: its time to execute $job_msg", 7);
1322                         my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$macaddress'";
1323                         my $res_hash = $known_clients_db->select_dbentry( $sql_statement );
1324
1325                         # expect macaddress is unique!!!!!!
1326                         my $target = $res_hash->{1}->{hostname};
1327
1328                         # change header
1329                         $job_msg =~ s/<header>job_/<header>gosa_/;
1330
1331                         # add sqlite_id
1332                         $job_msg =~ s/<\/xml>$/<jobdb_id>$jobdb_id<\/jobdb_id><\/xml>/;
1333
1334                         $job_msg =~ /<header>(\S+)<\/header>/;
1335                         my $header = $1 ;
1336                         my $func_error = &send_msg_to_target($job_msg, $server_address, $GosaPackages_key, $header, "J");
1337
1338                         # update status in job queue to 'processing'
1339                         $sql_statement = "UPDATE $job_queue_tn SET status='processing' WHERE id='$jobdb_id'";
1340                         my $res = $job_db->update_dbentry($sql_statement);
1341
1342                         # We don't want parallel processing
1343                         last;
1344                 }
1345         }
1346
1347         $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
1348 }
1349
1350
1351 sub watch_for_new_messages {
1352     my ($kernel,$heap) = @_[KERNEL, HEAP];
1353     my @coll_user_msg;   # collection list of outgoing messages
1354
1355     # check messaging_db for new incoming messages with executable timestamp
1356     my $timestamp = &get_time();
1357     my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( (CAST(timestamp AS INTEGER))<$timestamp AND flag='n' AND direction='in' )";
1358     my $res = $messaging_db->exec_statement( $sql_statement );
1359         foreach my $hit (@{$res}) {
1360
1361         # create outgoing messages
1362         my $message_to = @{$hit}[3];
1363
1364         # translate message_to to plain login name
1365 # TODO implement reciever translation
1366         my @reciever_l = ($message_to);
1367         my $message_id = @{$hit}[0];
1368
1369         #add each outgoing msg to messaging_db
1370         my $reciever;
1371         foreach $reciever (@reciever_l) {
1372             my $sql_statement = "INSERT INTO $messaging_tn (id, subject, message_from, message_to, flag, direction, delivery_time, message, timestamp) ".
1373                 "VALUES ('".
1374                 $message_id."', '".    # id
1375                 @{$hit}[1]."', '".     # subject
1376                 @{$hit}[2]."', '".     # message_from
1377                 $reciever."', '".      # message_to
1378                 "none"."', '".         # flag
1379                 "out"."', '".          # direction
1380                 @{$hit}[6]."', '".     # delivery_time
1381                 @{$hit}[7]."', '".     # message
1382                 $timestamp."'".     # timestamp
1383                 ")";
1384             &daemon_log("M DEBUG: $sql_statement", 1);
1385             my $res = $messaging_db->exec_statement($sql_statement);
1386             &daemon_log("M INFO: message '".@{$hit}[0]."' is prepared for delivery to reciever '$reciever'", 5);
1387         }
1388
1389         # send outgoing messages
1390         my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( flag='p' AND direction='out' )";
1391         my $res = $messaging_db->exec_statement( $sql_statement );
1392         foreach my $hit (@{$res}) {
1393             # add subject, from, to and message to list coll_user_msg
1394             my @user_msg = [@{$hit}[1], @{$hit}[2], $reciever, @{$hit}[7]];
1395             push( @coll_user_msg, \@user_msg);
1396         }
1397
1398         # send outgoing list to myself (gosa-si-server) to deliver each message to user
1399         # reason for this workaround: if to much messages have to be delivered, it can come to
1400         # denial of service problems of the server. so, the incoming message list can be processed
1401         # by a forked child and gosa-si-server is always ready to work.
1402         my $collection_out_msg = &create_xml_hash("collection_user_messages", $server_address, $server_address);
1403         # add to hash 'msg1' => [subject, from, to, message]
1404         # hash to string
1405         # send msg to myself
1406 # TODO
1407
1408         # set incoming message to flag d=deliverd
1409         $sql_statement = "UPDATE $messaging_tn SET flag='p' WHERE id='$message_id'";
1410         &daemon_log("M DEBUG: $sql_statement", 7);
1411         $res = $messaging_db->update_dbentry($sql_statement);
1412         &daemon_log("M INFO: message '$message_id' is set to flag 'p' (processed)", 5);
1413
1414     }
1415
1416     $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
1417
1418
1419     return;
1420 }
1421
1422
1423 sub watch_for_done_messages {
1424     my ($kernel,$heap) = @_[KERNEL, HEAP];
1425
1426     $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
1427     return;
1428 }
1429
1430
1431 sub get_ldap_handle {
1432         my ($session_id) = @_;
1433         my $heap;
1434         my $ldap_handle;
1435
1436         if (not defined $session_id ) { $session_id = 0 };
1437         if ($session_id =~ /[^0-9]*/) { $session_id = 0 };
1438
1439         if ($session_id == 0) {
1440                 daemon_log("$session_id DEBUG: get_ldap_handle invoked without a session_id, create a new ldap_handle", 7);
1441                 $ldap_handle = Net::LDAP->new( $ldap_uri );
1442                 $ldap_handle->bind($ldap_admin_dn, password => $ldap_admin_password);
1443
1444         } else {
1445                 my $session_reference = $global_kernel->ID_id_to_session($session_id);
1446                 if( defined $session_reference ) {
1447                         $heap = $session_reference->get_heap();
1448                 }
1449
1450                 if (not defined $heap) {
1451                         daemon_log("$session_id DEBUG: cannot get heap for session_id '$session_id'", 7);
1452                         return;
1453                 }
1454
1455                 # TODO: This "if" is nonsense, because it doesn't prove that the
1456                 #       used handle is still valid - or if we've to reconnect...
1457                 #if (not exists $heap->{ldap_handle}) {
1458                         $ldap_handle = Net::LDAP->new( $ldap_uri );
1459                         $ldap_handle->bind($ldap_admin_dn, password => $ldap_admin_password);
1460                         $heap->{ldap_handle} = $ldap_handle;
1461                 #}
1462         }
1463         return $ldap_handle;
1464 }
1465
1466
1467 sub change_fai_state {
1468     my ($st, $targets, $session_id) = @_;
1469     $session_id = 0 if not defined $session_id;
1470     # Set FAI state to localboot
1471     my %mapActions= (
1472         reboot    => '',
1473         update    => 'softupdate',
1474         localboot => 'localboot',
1475         reinstall => 'install',
1476         rescan    => '',
1477         wake      => '',
1478         memcheck  => 'memcheck',
1479         sysinfo   => 'sysinfo',
1480         install   => 'install',
1481     );
1482
1483     # Return if this is unknown
1484     if (!exists $mapActions{ $st }){
1485         daemon_log("$session_id ERROR: unknown action '$st', can not translate ot FAIstate", 1);
1486       return;
1487     }
1488
1489     my $state= $mapActions{ $st };
1490
1491     my $ldap_handle = &get_ldap_handle($session_id);
1492     if( defined($ldap_handle) ) {
1493
1494       # Build search filter for hosts
1495         my $search= "(&(objectClass=GOhard)";
1496         foreach (@{$targets}){
1497             $search.= "(macAddress=$_)";
1498         }
1499         $search.= ")";
1500
1501       # If there's any host inside of the search string, procress them
1502         if (!($search =~ /macAddress/)){
1503             daemon_log("$session_id ERROR: no macAddress found in filter statement for LDAP search: '$search'", 1);
1504             return;
1505         }
1506
1507       # Perform search for Unit Tag
1508       my $mesg = $ldap_handle->search(
1509           base   => $ldap_base,
1510           scope  => 'sub',
1511           attrs  => ['dn', 'FAIstate', 'objectClass'],
1512           filter => "$search"
1513           );
1514
1515           if ($mesg->count) {
1516                   my @entries = $mesg->entries;
1517                   foreach my $entry (@entries) {
1518                           # Only modify entry if it is not set to '$state'
1519                           if ($entry->get_value("FAIstate") ne "$state"){
1520                                   daemon_log("$session_id INFO: Setting FAIstate to '$state' for ".$entry->dn, 5);
1521                                   my $result;
1522                                   my %tmp = map { $_ => 1 } $entry->get_value("objectClass");
1523                                   if (exists $tmp{'FAIobject'}){
1524                                           if ($state eq ''){
1525                                                   $result= $ldap_handle->modify($entry->dn, changes => [
1526                                                           delete => [ FAIstate => [] ] ]);
1527                                           } else {
1528                                                   $result= $ldap_handle->modify($entry->dn, changes => [
1529                                                           replace => [ FAIstate => $state ] ]);
1530                                           }
1531                                   } elsif ($state ne ''){
1532                                           $result= $ldap_handle->modify($entry->dn, changes => [
1533                                                   add     => [ objectClass => 'FAIobject' ],
1534                                                   add     => [ FAIstate => $state ] ]);
1535                                   }
1536
1537                                   # Errors?
1538                                   if ($result->code){
1539                                           daemon_log("$session_id Error: Setting FAIstate to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
1540                                   }
1541                           } else {
1542                                   daemon_log("$session_id DEBUG FAIstate at host '".$entry->dn."' already at state '$st'", 7);
1543                           }
1544                   }
1545           }
1546     # if no ldap handle defined
1547     } else {
1548         daemon_log("$session_id ERROR: no LDAP handle defined for update FAIstate", 1);
1549     }
1550
1551 }
1552
1553
1554 sub change_goto_state {
1555     my ($st, $targets, $session_id) = @_;
1556     $session_id = 0  if not defined $session_id;
1557
1558     # Switch on or off?
1559     my $state= $st eq 'active' ? 'active': 'locked';
1560
1561     my $ldap_handle = &get_ldap_handle($session_id);
1562     if( defined($ldap_handle) ) {
1563
1564       # Build search filter for hosts
1565       my $search= "(&(objectClass=GOhard)";
1566       foreach (@{$targets}){
1567         $search.= "(macAddress=$_)";
1568       }
1569       $search.= ")";
1570
1571       # If there's any host inside of the search string, procress them
1572       if (!($search =~ /macAddress/)){
1573         return;
1574       }
1575
1576       # Perform search for Unit Tag
1577       my $mesg = $ldap_handle->search(
1578           base   => $ldap_base,
1579           scope  => 'sub',
1580           attrs  => ['dn', 'gotoMode'],
1581           filter => "$search"
1582           );
1583
1584       if ($mesg->count) {
1585         my @entries = $mesg->entries;
1586         foreach my $entry (@entries) {
1587
1588           # Only modify entry if it is not set to '$state'
1589           if ($entry->get_value("gotoMode") ne $state){
1590
1591             daemon_log("$session_id INFO: Setting gotoMode to '$state' for ".$entry->dn, 5);
1592             my $result;
1593             $result= $ldap_handle->modify($entry->dn, changes => [
1594                                                 replace => [ gotoMode => $state ] ]);
1595
1596             # Errors?
1597             if ($result->code){
1598               &daemon_log("$session_id Error: Setting gotoMode to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
1599             }
1600
1601           }
1602         }
1603       }
1604
1605     }
1606 }
1607
1608
1609 sub run_create_fai_server_db {
1610     my ($kernel, $session, $heap, $table_name) = @_[KERNEL, SESSION, HEAP, ARG0];
1611     my $session_id = $session->ID;
1612     my $task = POE::Wheel::Run->new(
1613             Program => sub { &create_fai_server_db($table_name,$kernel, undef, $session_id) },
1614             StdoutEvent  => "session_run_result",
1615             StderrEvent  => "session_run_debug",
1616             CloseEvent   => "session_run_done",
1617             );
1618
1619     $heap->{task}->{ $task->ID } = $task;
1620     return;
1621 }
1622
1623
1624 sub create_fai_server_db {
1625     my ($table_name, $kernel, $dont_create_packages_list, $session_id) = @_;
1626         my $result;
1627
1628         if (not defined $session_id) { $session_id = 0; }
1629     my $ldap_handle = &get_ldap_handle();
1630         if(defined($ldap_handle)) {
1631                 daemon_log("$session_id INFO: create_fai_server_db: start", 5);
1632                 my $mesg= $ldap_handle->search(
1633                         base   => $ldap_base,
1634                         scope  => 'sub',
1635                         attrs  => ['FAIrepository', 'gosaUnitTag'],
1636                         filter => "(&(FAIrepository=*)(objectClass=FAIrepositoryServer))",
1637                 );
1638                 if($mesg->{'resultCode'} == 0 &&
1639                    $mesg->count != 0) {
1640                    foreach my $entry (@{$mesg->{entries}}) {
1641                            if($entry->exists('FAIrepository')) {
1642                                    # Add an entry for each Repository configured for server
1643                                    foreach my $repo(@{$entry->get_value('FAIrepository', asref => 1)}) {
1644                                                    my($tmp_url,$tmp_server,$tmp_release,$tmp_sections) = split(/\|/, $repo);
1645                                                    my $tmp_tag= $entry->get_value('gosaUnitTag') || "";
1646                                                    $result= $fai_server_db->add_dbentry( {
1647                                                                    table => $table_name,
1648                                                                    primkey => ['server', 'release', 'tag'],
1649                                                                    server => $tmp_url,
1650                                                                    release => $tmp_release,
1651                                                                    sections => $tmp_sections,
1652                                                                    tag => (length($tmp_tag)>0)?$tmp_tag:"",
1653                                                            } );
1654                                            }
1655                                    }
1656                            }
1657                    }
1658                 daemon_log("$session_id INFO: create_fai_server_db: finished", 5);
1659
1660                 # TODO: Find a way to post the 'create_packages_list_db' event
1661                 if(not defined($dont_create_packages_list)) {
1662                         &create_packages_list_db(undef, undef, $session_id);
1663                 }
1664         }
1665
1666     $ldap_handle->disconnect;
1667         return $result;
1668 }
1669
1670
1671 sub run_create_fai_release_db {
1672     my ($session, $heap, $table_name) = @_[SESSION, HEAP, ARG0];
1673         my $session_id = $session->ID;
1674     my $task = POE::Wheel::Run->new(
1675             Program => sub { &create_fai_release_db($table_name, $session_id) },
1676             StdoutEvent  => "session_run_result",
1677             StderrEvent  => "session_run_debug",
1678             CloseEvent   => "session_run_done",
1679             );
1680
1681     $heap->{task}->{ $task->ID } = $task;
1682     return;
1683 }
1684
1685
1686 sub create_fai_release_db {
1687         my ($table_name, $session_id) = @_;
1688         my $result;
1689
1690     # used for logging
1691     if (not defined $session_id) { $session_id = 0; }
1692
1693     my $ldap_handle = &get_ldap_handle();
1694         if(defined($ldap_handle)) {
1695                 daemon_log("$session_id INFO: create_fai_release_db: start",5);
1696                 my $mesg= $ldap_handle->search(
1697                         base   => $ldap_base,
1698                         scope  => 'sub',
1699                         attrs  => [],
1700                         filter => "(&(objectClass=organizationalUnit)(ou=fai))",
1701                 );
1702                 if($mesg->{'resultCode'} == 0 &&
1703                         $mesg->count != 0) {
1704                         # Walk through all possible FAI container ou's
1705                         my @sql_list;
1706                         my $timestamp= &get_time();
1707                         foreach my $ou (@{$mesg->{entries}}) {
1708                                 my $tmp_classes= resolve_fai_classes($ou->dn, $ldap_handle, $session_id);
1709                                 if(defined($tmp_classes) && ref($tmp_classes) eq 'HASH') {
1710                                         my @tmp_array=get_fai_release_entries($tmp_classes);
1711                                         if(@tmp_array) {
1712                                                 foreach my $entry (@tmp_array) {
1713                                                         if(defined($entry) && ref($entry) eq 'HASH') {
1714                                                                 my $sql=
1715                                                                 "INSERT INTO $table_name "
1716                                                                 ."(timestamp, release, class, type, state) VALUES ("
1717                                                                 .$timestamp.","
1718                                                                 ."'".$entry->{'release'}."',"
1719                                                                 ."'".$entry->{'class'}."',"
1720                                                                 ."'".$entry->{'type'}."',"
1721                                                                 ."'".$entry->{'state'}."')";
1722                                                                 push @sql_list, $sql;
1723                                                         }
1724                                                 }
1725                                         }
1726                                 }
1727                         }
1728
1729                         daemon_log("$session_id DEBUG: Inserting ".scalar @sql_list." entries to DB",8);
1730                         if(@sql_list) {
1731                                 unshift @sql_list, "DELETE FROM $table_name";   # at first, clear db
1732                                 $fai_release_db->exec_statementlist(\@sql_list);
1733                         }
1734                         daemon_log("$session_id DEBUG: Done with inserting",7);
1735                 }
1736                 daemon_log("$session_id INFO: create_fai_release_db: finished",5);
1737         }
1738     $ldap_handle->disconnect;
1739         return $result;
1740 }
1741
1742 sub get_fai_types {
1743         my $tmp_classes = shift || return undef;
1744         my @result;
1745
1746         foreach my $type(keys %{$tmp_classes}) {
1747                 if(defined($tmp_classes->{$type}[0]) && (!($tmp_classes->{$type}[0] =~ /^.*?removed.*?$/))) {
1748                         my $entry = {
1749                                 type => $type,
1750                                 state => $tmp_classes->{$type}[0],
1751                         };
1752                         push @result, $entry;
1753                 }
1754         }
1755
1756         return @result;
1757 }
1758
1759 sub get_fai_state {
1760         my $result = "";
1761         my $tmp_classes = shift || return $result;
1762
1763         foreach my $type(keys %{$tmp_classes}) {
1764                 if(defined($tmp_classes->{$type}[0])) {
1765                         $result = $tmp_classes->{$type}[0];
1766
1767                 # State is equal for all types in class
1768                         last;
1769                 }
1770         }
1771
1772         return $result;
1773 }
1774
1775 sub resolve_fai_classes {
1776         my ($fai_base, $ldap_handle, $session_id) = @_;
1777         if (not defined $session_id) { $session_id = 0; }
1778         my $result;
1779         my @possible_fai_classes= ("FAIscript", "FAIhook", "FAIpartitionTable", "FAItemplate", "FAIvariable", "FAIprofile", "FAIpackageList");
1780         my $fai_filter= "(|(&(objectClass=FAIclass)(|(objectClass=".join(")(objectClass=", @possible_fai_classes).")))(objectClass=FAIbranch))";
1781         my $fai_classes;
1782
1783         daemon_log("$session_id DEBUG: Searching for FAI entries in base $fai_base",7);
1784         my $mesg= $ldap_handle->search(
1785                 base   => $fai_base,
1786                 scope  => 'sub',
1787                 attrs  => ['cn','objectClass','FAIstate'],
1788                 filter => $fai_filter,
1789         );
1790         daemon_log("$session_id DEBUG: Found ".$mesg->count()." FAI entries",7);
1791
1792         if($mesg->{'resultCode'} == 0 &&
1793                 $mesg->count != 0) {
1794                 foreach my $entry (@{$mesg->{entries}}) {
1795                         if($entry->exists('cn')) {
1796                                 my $tmp_dn= $entry->dn();
1797
1798                                 # Skip classname and ou dn parts for class
1799                                 my $tmp_release = ($1) if $tmp_dn =~ /^[^,]+,[^,]+,(.*?),$fai_base$/;
1800
1801                                 # Skip classes without releases
1802                                 if((!defined($tmp_release)) || length($tmp_release)==0) {
1803                                         next;
1804                                 }
1805
1806                                 my $tmp_cn= $entry->get_value('cn');
1807                                 my $tmp_state= $entry->get_value('FAIstate');
1808
1809                                 my $tmp_type;
1810                                 # Get FAI type
1811                                 for my $oclass(@{$entry->get_value('objectClass', asref => 1)}) {
1812                                         if(grep $_ eq $oclass, @possible_fai_classes) {
1813                                                 $tmp_type= $oclass;
1814                                                 last;
1815                                         }
1816                                 }
1817
1818                                 if($tmp_release =~ /^.*?,.*?$/ && (!($tmp_release =~ /^.*?\\,.*?$/))) {
1819                                         # A Subrelease
1820                                         my @sub_releases = split(/,/, $tmp_release);
1821
1822                                         # Walk through subreleases and build hash tree
1823                                         my $hash;
1824                                         while(my $tmp_sub_release = pop @sub_releases) {
1825                                                 $hash .= "\{'$tmp_sub_release'\}->";
1826                                         }
1827                                         eval('push @{$fai_classes->'.$hash.'{$tmp_cn}->{$tmp_type}}, (defined($tmp_state) && length($tmp_state)>0)?$tmp_state:"";');
1828                                 } else {
1829                                         # A branch, no subrelease
1830                                         push @{$fai_classes->{$tmp_release}->{$tmp_cn}->{$tmp_type}}, (defined($tmp_state) && length($tmp_state)>0)?$tmp_state:"";
1831                                 }
1832                         } elsif (!$entry->exists('cn')) {
1833                                 my $tmp_dn= $entry->dn();
1834                                 my $tmp_release = ($1) if $tmp_dn =~ /^(.*?),$fai_base$/;
1835
1836                                 # Skip classes without releases
1837                                 if((!defined($tmp_release)) || length($tmp_release)==0) {
1838                                         next;
1839                                 }
1840
1841                                 if($tmp_release =~ /^.*?,.*?$/ && (!($tmp_release =~ /^.*?\\,.*?$/))) {
1842                                         # A Subrelease
1843                                         my @sub_releases= split(/,/, $tmp_release);
1844
1845                                         # Walk through subreleases and build hash tree
1846                                         my $hash;
1847                                         while(my $tmp_sub_release = pop @sub_releases) {
1848                                                 $hash .= "\{'$tmp_sub_release'\}->";
1849                                         }
1850                                         # Remove the last two characters
1851                                         chop($hash);
1852                                         chop($hash);
1853
1854                                         eval('$fai_classes->'.$hash.'= {}');
1855                                 } else {
1856                                         # A branch, no subrelease
1857                                         if(!exists($fai_classes->{$tmp_release})) {
1858                                                 $fai_classes->{$tmp_release} = {};
1859                                         }
1860                                 }
1861                         }
1862                 }
1863
1864                 # The hash is complete, now we can honor the copy-on-write based missing entries
1865                 foreach my $release (keys %$fai_classes) {
1866                         $result->{$release}= deep_copy(apply_fai_inheritance($fai_classes->{$release}));
1867                 }
1868         }
1869         return $result;
1870 }
1871
1872 sub apply_fai_inheritance {
1873        my $fai_classes = shift || return {};
1874        my $tmp_classes;
1875
1876        # Get the classes from the branch
1877        foreach my $class (keys %{$fai_classes}) {
1878                # Skip subreleases
1879                if($class =~ /^ou=.*$/) {
1880                        next;
1881                } else {
1882                        $tmp_classes->{$class}= deep_copy($fai_classes->{$class});
1883                }
1884        }
1885
1886        # Apply to each subrelease
1887        foreach my $subrelease (keys %{$fai_classes}) {
1888                if($subrelease =~ /ou=/) {
1889                        foreach my $tmp_class (keys %{$tmp_classes}) {
1890                                if(!exists($fai_classes->{$subrelease}->{$tmp_class})) {
1891                                        $fai_classes->{$subrelease}->{$tmp_class} =
1892                                        deep_copy($tmp_classes->{$tmp_class});
1893                                } else {
1894                                        foreach my $type (keys %{$tmp_classes->{$tmp_class}}) {
1895                                                if(!exists($fai_classes->{$subrelease}->{$tmp_class}->{$type})) {
1896                                                        $fai_classes->{$subrelease}->{$tmp_class}->{$type}=
1897                                                        deep_copy($tmp_classes->{$tmp_class}->{$type});
1898                                                }
1899                                        }
1900                                }
1901                        }
1902                }
1903        }
1904
1905        # Find subreleases in deeper levels
1906        foreach my $subrelease (keys %{$fai_classes}) {
1907                if($subrelease =~ /ou=/) {
1908                        foreach my $subsubrelease (keys %{$fai_classes->{$subrelease}}) {
1909                                if($subsubrelease =~ /ou=/) {
1910                                        apply_fai_inheritance($fai_classes->{$subrelease});
1911                                }
1912                        }
1913                }
1914        }
1915
1916        return $fai_classes;
1917 }
1918
1919 sub get_fai_release_entries {
1920         my $tmp_classes = shift || return;
1921         my $parent = shift || "";
1922         my @result = shift || ();
1923
1924         foreach my $entry (keys %{$tmp_classes}) {
1925                 if(defined($entry)) {
1926                         if($entry =~ /^ou=.*$/) {
1927                                 my $release_name = $entry;
1928                                 $release_name =~ s/ou=//g;
1929                                 if(length($parent)>0) {
1930                                         $release_name = $parent."/".$release_name;
1931                                 }
1932                                 my @bufentries = get_fai_release_entries($tmp_classes->{$entry}, $release_name, @result);
1933                                 foreach my $bufentry(@bufentries) {
1934                                         push @result, $bufentry;
1935                                 }
1936                         } else {
1937                                 my @types = get_fai_types($tmp_classes->{$entry});
1938                                 foreach my $type (@types) {
1939                                         push @result,
1940                                         {
1941                                                 'class' => $entry,
1942                                                 'type' => $type->{'type'},
1943                                                 'release' => $parent,
1944                                                 'state' => $type->{'state'},
1945                                         };
1946                                 }
1947                         }
1948                 }
1949         }
1950
1951         return @result;
1952 }
1953
1954 sub deep_copy {
1955         my $this = shift;
1956         if (not ref $this) {
1957                 $this;
1958         } elsif (ref $this eq "ARRAY") {
1959                 [map deep_copy($_), @$this];
1960         } elsif (ref $this eq "HASH") {
1961                 +{map { $_ => deep_copy($this->{$_}) } keys %$this};
1962         } else { die "what type is $_?" }
1963 }
1964
1965
1966 sub session_run_result {
1967     my ($kernel, $heap, $client_answer) = @_[KERNEL, HEAP, ARG0];
1968     $kernel->sig(CHLD => "child_reap");
1969 }
1970
1971 sub session_run_debug {
1972     my $result = $_[ARG0];
1973     print STDERR "$result\n";
1974 }
1975
1976 sub session_run_done {
1977     my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
1978     delete $heap->{task}->{$task_id};
1979 }
1980
1981 sub create_sources_list {
1982     my ($session_id) = @_;
1983     my $ldap_handle = &get_ldap_handle;
1984         my $result="/tmp/gosa_si_tmp_sources_list";
1985
1986         # Remove old file
1987         if(stat($result)) {
1988                 unlink($result);
1989         &main::daemon_log("$session_id DEBUG: remove an old version of '$result'", 7);
1990         }
1991
1992         my $fh;
1993         open($fh, ">$result");
1994     if (not defined $fh) {
1995         &main::daemon_log("$session_id DEBUG: cannot open '$result' for writing", 7);
1996         return undef;
1997     }
1998         if(defined($ldap_server_dn) and length($ldap_server_dn) > 0) {
1999                 my $mesg=$ldap_handle->search(
2000                                 base    => $ldap_server_dn,
2001                                 scope   => 'base',
2002                                 attrs   => 'FAIrepository',
2003                                 filter  => 'objectClass=FAIrepositoryServer'
2004                                 );
2005                 if($mesg->count) {
2006                         foreach my $entry(@{$mesg->{'entries'}}) {
2007                                 foreach my $value(@{$entry->get_value('FAIrepository', asref => 1)}) {
2008                                         my ($server, $tag, $release, $sections)= split /\|/, $value;
2009                                         my $line = "deb $server $release";
2010                                         $sections =~ s/,/ /g;
2011                                         $line.= " $sections";
2012                                         print $fh $line."\n";
2013                                 }
2014                         }
2015                 }
2016         } else {
2017         &main::daemon_log("$session_id ERROR: something wrong with ldap_server_dn '$ldap_server_dn', abort create_soureces_list", 1);
2018     }
2019         close($fh);
2020
2021         return $result;
2022 }
2023
2024
2025 sub run_create_packages_list_db {
2026     my ($session, $heap) = @_[SESSION, HEAP];
2027         my $session_id = $session->ID;
2028
2029         my $task = POE::Wheel::Run->new(
2030                                         Program => sub {&create_packages_list_db(undef, undef, $session_id)},
2031                                         StdoutEvent  => "session_run_result",
2032                                         StderrEvent  => "session_run_debug",
2033                                         CloseEvent   => "session_run_done",
2034                                         );
2035         $heap->{task}->{ $task->ID } = $task;
2036 }
2037
2038
2039 sub create_packages_list_db {
2040     my ($ldap_handle, $sources_file, $session_id) = @_;
2041
2042         if (not defined $session_id) { $session_id = 0; }
2043         if (not defined $ldap_handle) {
2044                 $ldap_handle= &get_ldap_handle();
2045
2046                 if (not defined $ldap_handle) {
2047                         daemon_log("$session_id ERROR: no ldap_handle available to create_packages_list_db", 1);
2048                         return;
2049                 }
2050         }
2051     if (not defined $sources_file) {
2052         &main::daemon_log("$session_id INFO: no sources_file given for creating packages list so trigger creation of it", 5);
2053         $sources_file = &create_sources_list($session_id);
2054     }
2055
2056     if (not defined $sources_file) {
2057         &main::daemon_log("$session_id ERROR: no sources_file given under '$sources_file', skip create_packages_list_db", 1);
2058
2059     }
2060
2061         # it should not be possible to trigger a recreation of packages_list_db
2062         # while packages_list_db is under construction, so set flag packages_list_under_construction
2063         # which is tested befor recreation can be started
2064         if ($packages_list_under_construction) {
2065                         daemon_log("$session_id WARNING: packages_list_db is right now under construction, please wait untill this process is finished", 3);
2066                         return;
2067         } else {
2068                         daemon_log("$session_id INFO: create_packages_list_db: start", 5);
2069                         # set packages_list_under_construction to true
2070                         $packages_list_under_construction = 1;
2071         }
2072         my $line;
2073
2074     open(CONFIG, "<$sources_file") or do {
2075         daemon_log( "$session_id ERROR: create_packages_list_db: Failed to open '$sources_file'", 1);
2076         return;
2077     };
2078
2079     # Read lines
2080     while ($line = <CONFIG>){
2081         # Unify
2082         chop($line);
2083         $line =~ s/^\s+//;
2084         $line =~ s/^\s+/ /;
2085
2086         # Strip comments
2087         $line =~ s/#.*$//g;
2088
2089         # Skip empty lines
2090         if ($line =~ /^\s*$/){
2091             next;
2092         }
2093
2094         # Interpret deb line
2095         if ($line =~ /^deb [^\s]+\s[^\s]+\s[^\s]+/){
2096             my( $baseurl, $dist, $sections ) = ($line =~ /^deb\s([^\s]+)\s+([^\s]+)\s+(.*)$/);
2097             my $section;
2098             foreach $section (split(' ', $sections)){
2099                 &parse_package_info( $baseurl, $dist, $section, $session_id );
2100             }
2101         }
2102     }
2103
2104     close (CONFIG);
2105
2106     daemon_log("$session_id INFO: create_packages_list_db: finished", 5);
2107         # set packages_list_under_construction to false
2108         $packages_list_under_construction = 0;
2109
2110     return;
2111 }
2112
2113
2114 sub parse_package_info {
2115   my ($baseurl, $dist, $section, $session_id)= @_;
2116   my ($package);
2117         if (not defined $session_id) { $session_id = 0; }
2118   my ($path) = ($baseurl =~ m%://[^/]*(.*)$%);
2119   $repo_dirs{ "${repo_path}/pool" } = 1;
2120
2121   foreach $package ("Packages.gz"){
2122     daemon_log("$session_id DEBUG: create_packages_list: fetch $baseurl, $dist, $section", 7);
2123     get_package( "$baseurl/dists/$dist/$section/binary-$arch/$package", "$outdir/$dist/$section", $session_id );
2124     parse_package( "$outdir/$dist/$section", $dist, $path, $session_id );
2125   }
2126   find(\&cleanup_and_extract($session_id), keys( %repo_dirs ));
2127 }
2128
2129
2130 sub get_package {
2131   my ($url, $dest, $session_id)= @_;
2132   if (not defined $session_id) { $session_id = 0; }
2133
2134   my $tpath = dirname($dest);
2135   -d "$tpath" || mkpath "$tpath";
2136
2137   # This is ugly, but I've no time to take a look at "how it works in perl"
2138   if(0 == system("wget '$url' -O '$dest' 2>/dev/null") ) {
2139       system("gunzip -cd '$dest' > '$dest.in'");
2140           daemon_log("$session_id DEBUG: run command: gunzip -cd '$dest' > '$dest.in'", 5);
2141       unlink($dest);
2142           daemon_log("$session_id DEBUG: delete file '$dest'", 5);
2143   } else {
2144       daemon_log("$session_id ERROR: create_packages_list_db: get_packages: fetching '$url' failed!", 1);
2145   }
2146   return 0;
2147 }
2148
2149 sub parse_package {
2150     my ($path, $dist, $srv_path, $session_id)= @_;
2151         if (not defined $session_id) { $session_id = 0;}
2152     my ($package, $version, $section, $description);
2153     my @sql_list;
2154     my $PACKAGES;
2155
2156     if(not stat("$path.in")) {
2157         daemon_log("$session_id ERROR: create_packages_list: parse_package: file '$path.in' is not readable",1);
2158         return;
2159     }
2160
2161     open($PACKAGES, "<$path.in");
2162         if(not defined($PACKAGES)) {
2163         daemon_log("$session_id ERROR: create_packages_list_db: parse_package: cannot open '$path.in'",1);
2164         return;
2165     }
2166
2167     # Read lines
2168     while (<$PACKAGES>){
2169         my $line = $_;
2170         # Unify
2171         chop($line);
2172
2173         # Use empty lines as a trigger
2174         if ($line =~ /^\s*$/){
2175             my $sql = "INSERT INTO packages_list VALUES ('$dist', '$package', '$version', '$section', '', 'none', '0')";
2176             push(@sql_list, $sql);
2177             $package = "none";
2178             $version = "none";
2179             $section = "none";
2180             $description = "none";
2181             next;
2182         }
2183
2184         # Trigger for package name
2185         if ($line =~ /^Package:\s/){
2186             ($package)= ($line =~ /^Package: (.*)$/);
2187             next;
2188         }
2189
2190         # Trigger for version
2191         if ($line =~ /^Version:\s/){
2192             ($version)= ($line =~ /^Version: (.*)$/);
2193             next;
2194         }
2195
2196         # Trigger for description
2197         if ($line =~ /^Description:\s/){
2198             ($description)= ($line =~ /^Description: (.*)$/);
2199             next;
2200         }
2201
2202         # Trigger for section
2203         if ($line =~ /^Section:\s/){
2204             ($section)= ($line =~ /^Section: (.*)$/);
2205             next;
2206         }
2207
2208         # Trigger for filename
2209         if ($line =~ /^Filename:\s/){
2210                 my ($filename) = ($line =~ /^Filename: (.*)$/);
2211                 store_fileinfo( $package, $filename, $dist, $srv_path, $version, $repo_path );
2212                 next;
2213         }
2214     }
2215
2216     close( $PACKAGES );
2217 #    unlink( "$path.in" );
2218     &main::daemon_log("$session_id DEBUG: unlink '$path.in'", 1);
2219     my $len_sql_list = @sql_list;
2220     &main::daemon_log("$session_id DEBUG: add $len_sql_list insert-statements to packages_list_db", 5);
2221     $packages_list_db->exec_statementlist(\@sql_list);
2222 }
2223
2224 sub store_fileinfo {
2225   my( $package, $file, $dist, $path, $vers, $srvdir) = @_;
2226
2227   my %fileinfo = (
2228     'package' => $package,
2229     'dist' => $dist,
2230     'version' => $vers,
2231   );
2232
2233   $repo_files{ "${srvdir}/$file" } = \%fileinfo;
2234 }
2235
2236 sub cleanup_and_extract {
2237         my ($session_id) = @_;
2238         if (not defined $session_id) { $session_id  = 0; }
2239                 my $fileinfo = $repo_files{ $File::Find::name };
2240
2241                 if( defined $fileinfo ) {
2242
2243                                 my $dir = "$outdir/$fileinfo->{ 'dist' }/debconf.d";
2244                                 my $sql;
2245                                 my $package = $fileinfo->{ 'package' };
2246                                 my $newver = $fileinfo->{ 'version' };
2247
2248                                 mkpath($dir);
2249                                 system( "dpkg -e '$File::Find::name' '$dir/DEBIAN'" );
2250
2251                                 if( -f "$dir/DEBIAN/templates" ) {
2252
2253                                                 daemon_log("$session_id DEBUG: Found debconf templates in '$package' - $newver", 5);
2254
2255                                                 my $tmpl= "";
2256                                                 {
2257                                                                 local $/=undef;
2258                                                                 open FILE, "$dir/DEBIAN/templates";
2259                                                                 $tmpl = &encode_base64(<FILE>);
2260                                                                 close FILE;
2261                                                 }
2262                                                 rmtree("$dir/DEBIAN/templates");
2263
2264                                                 $sql= "update $main::packages_list_tn set template = '$tmpl' where package = '$package' and version = '$newver';";
2265
2266                                 } else {
2267                                                 $sql= "update $main::packages_list_tn set template = '' where package = '$package' and version = '$newver';";
2268                                 }
2269
2270                                 my $res= $main::packages_list_db->update_dbentry($sql);
2271                 }
2272 }
2273
2274
2275 #==== MAIN = main ==============================================================
2276 #  parse commandline options
2277 Getopt::Long::Configure( "bundling" );
2278 GetOptions("h|help" => \&usage,
2279         "c|config=s" => \$cfg_file,
2280         "f|foreground" => \$foreground,
2281         "v|verbose+" => \$verbose,
2282         "no-bus+" => \$no_bus,
2283         "no-arp+" => \$no_arp,
2284            );
2285
2286 #  read and set config parameters
2287 &check_cmdline_param ;
2288 &read_configfile;
2289 &check_pid;
2290
2291 $SIG{CHLD} = 'IGNORE';
2292
2293 # forward error messages to logfile
2294 if( ! $foreground ) {
2295   open( STDIN,  '+>/dev/null' );
2296   open( STDOUT, '+>&STDIN'    );
2297   open( STDERR, '+>&STDIN'    );
2298 }
2299
2300 # Just fork, if we are not in foreground mode
2301 if( ! $foreground ) {
2302     chdir '/'                 or die "Can't chdir to /: $!";
2303     $pid = fork;
2304     setsid                    or die "Can't start a new session: $!";
2305     umask 0;
2306 } else {
2307     $pid = $$;
2308 }
2309
2310 # Do something useful - put our PID into the pid_file
2311 if( 0 != $pid ) {
2312     open( LOCK_FILE, ">$pid_file" );
2313     print LOCK_FILE "$pid\n";
2314     close( LOCK_FILE );
2315     if( !$foreground ) {
2316         exit( 0 )
2317     };
2318 }
2319
2320 daemon_log(" ", 1);
2321 daemon_log("$0 started!", 1);
2322
2323 if ($no_bus > 0) {
2324     $bus_activ = "false"
2325 }
2326
2327 # connect to gosa-si job queue
2328 $job_db = GOSA::DBsqlite->new($job_queue_file_name);
2329 $job_db->create_table($job_queue_tn, \@job_queue_col_names);
2330
2331 # connect to known_clients_db
2332 $known_clients_db = GOSA::DBsqlite->new($known_clients_file_name);
2333 $known_clients_db->create_table($known_clients_tn, \@known_clients_col_names);
2334
2335 # connect to known_server_db
2336 $known_server_db = GOSA::DBsqlite->new($known_server_file_name);
2337 $known_server_db->create_table($known_server_tn, \@known_server_col_names);
2338
2339 # connect to login_usr_db
2340 $login_users_db = GOSA::DBsqlite->new($login_users_file_name);
2341 $login_users_db->create_table($login_users_tn, \@login_users_col_names);
2342
2343 # connect to fai_server_db and fai_release_db
2344 unlink($fai_server_file_name);
2345 $fai_server_db = GOSA::DBsqlite->new($fai_server_file_name);
2346 $fai_server_db->create_table($fai_server_tn, \@fai_server_col_names);
2347
2348 unlink($fai_release_file_name);
2349 $fai_release_db = GOSA::DBsqlite->new($fai_release_file_name);
2350 $fai_release_db->create_table($fai_release_tn, \@fai_release_col_names);
2351
2352 # connect to packages_list_db
2353 unlink($packages_list_file_name);
2354 $packages_list_db = GOSA::DBsqlite->new($packages_list_file_name);
2355 $packages_list_db->create_table($packages_list_tn, \@packages_list_col_names);
2356
2357 # connect to messaging_db
2358 $messaging_db = GOSA::DBsqlite->new($messaging_file_name);
2359 $messaging_db->create_table($messaging_tn, \@messaging_col_names);
2360
2361
2362 # create xml object used for en/decrypting
2363 $xml = new XML::Simple();
2364
2365 # create socket for incoming xml messages
2366
2367 POE::Component::Server::TCP->new(
2368         Port => $server_port,
2369         ClientInput => sub {
2370         my ($kernel, $input) = @_[KERNEL, ARG0];
2371         push(@tasks, $input);
2372         $kernel->yield("next_task");
2373         },
2374     InlineStates => {
2375         next_task => \&next_task,
2376         task_result => \&handle_task_result,
2377         task_done   => \&handle_task_done,
2378         task_debug  => \&handle_task_debug,
2379         child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!"  },
2380     }
2381 );
2382
2383 daemon_log("start socket for incoming xml messages at port '$server_port' ", 1);
2384
2385 # create session for repeatedly checking the job queue for jobs
2386 POE::Session->create(
2387         inline_states => {
2388                 _start => \&_start,
2389                 sig_handler => \&sig_handler,
2390         watch_for_new_messages => \&watch_for_new_messages,
2391         watch_for_done_messages => \&watch_for_done_messages,
2392                 watch_for_new_jobs => \&watch_for_new_jobs,
2393         watch_for_done_jobs => \&watch_for_done_jobs,
2394         create_packages_list_db => \&run_create_packages_list_db,
2395         create_fai_server_db => \&run_create_fai_server_db,
2396         create_fai_release_db => \&run_create_fai_release_db,
2397         session_run_result => \&session_run_result,
2398         session_run_debug => \&session_run_debug,
2399         session_run_done => \&session_run_done,
2400         child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!"  },
2401         }
2402 );
2403
2404
2405 # import all modules
2406 &import_modules;
2407
2408 # check wether all modules are gosa-si valid passwd check
2409
2410 POE::Kernel->run();
2411 exit;
2412