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 # TODO
  25 #
  26 # max_children wird momentan nicht mehr verwendet, jede eingehende nachricht bekommt ein eigenes POE child
  27
  28 use strict;
  29 use warnings;
  30 use Getopt::Long;
  31 use Config::IniFiles;
  32 use POSIX;
  33
  34 use Fcntl;
  35 use IO::Socket::INET;
  36 use IO::Handle;
  37 use IO::Select;
  38 use Symbol qw(qualify_to_ref);
  39 use Crypt::Rijndael;
  40 use MIME::Base64;
  41 use Digest::MD5  qw(md5 md5_hex md5_base64);
  42 use XML::Simple;
  43 use Data::Dumper;
  44 use Sys::Syslog qw( :DEFAULT setlogsock);
  45 use Cwd;
  46 use File::Spec;
  47 use File::Basename;
  48 use File::Find;
  49 use File::Copy;
  50 use File::Path;
  51 use GOSA::GosaSupportDaemon;
  52 use POE qw(Component::Server::TCP Wheel::Run Filter::Reference);
  53 use Net::LDAP;
  54 use Net::LDAP::Util qw(:escape);
  55 use Time::HiRes qw( usleep);
  56
  57 my $db_module = "DBsqlite";
  58 {
  59 no strict "refs";
  60 require ("GOSA/".$db_module.".pm");
  61 ("GOSA/".$db_module)->import;
  62 daemon_log("0 INFO: importing database module '$db_module'", 1);
  63 }
  64
  65 my $modules_path = "/usr/lib/gosa-si/modules";
  66 use lib "/usr/lib/gosa-si/modules";
  67
  68 # revision number of server and program name
  69 my $server_version = '$HeadURL: https://oss.gonicus.de/repositories/gosa/trunk/gosa-si/gosa-si-server $:$Rev: 10826 $';
  70 my $server_headURL;
  71 my $server_revision;
  72 my $server_status;
  73 our $prg= basename($0);
  74
  75 our $global_kernel;
  76 my ($foreground, $ping_timeout);
  77 my ($server);
  78 my ($gosa_server, $job_queue_timeout, $job_queue_loop_delay);
  79 my ($messaging_db_loop_delay);
  80 my ($procid, $pid);
  81 my ($arp_fifo);
  82 my ($xml);
  83 my $sources_list;
  84 my $max_clients;
  85 my %repo_files=();
  86 my $repo_path;
  87 my %repo_dirs=();
  88
  89 # Variables declared in config file are always set to 'our'
  90 our (%cfg_defaults, $log_file, $pid_file,
  91     $server_ip, $server_port, $ClientPackages_key, $dns_lookup,
  92     $arp_activ, $gosa_unit_tag,
  93     $GosaPackages_key, $gosa_timeout,
  94     $foreign_server_string, $server_domain, $ServerPackages_key, $foreign_servers_register_delay,
  95     $wake_on_lan_passwd, $job_synchronization, $modified_jobs_loop_delay,
  96     $arp_enabled, $arp_interface,
  97     $opsi_enabled, $opsi_server, $opsi_admin, $opsi_password,
  98                 $new_systems_ou,
  99 );
 100
 101 # additional variable which should be globaly accessable
 102 our $server_address;
 103 our $server_mac_address;
 104 our $gosa_address;
 105 our $no_arp;
 106 our $verbose;
 107 our $forground;
 108 our $cfg_file;
 109 our ($ldap_uri, $ldap_base, $ldap_admin_dn, $ldap_admin_password, $ldap_server_dn);
 110 our ($mysql_username, $mysql_password, $mysql_database, $mysql_host);
 111 our $known_modules;
 112 our $root_uid;
 113 our $adm_gid;
 114
 115
 116 # specifies the verbosity of the daemon_log
 117 $verbose = 0 ;
 118
 119 # if foreground is not null, script will be not forked to background
 120 $foreground = 0 ;
 121
 122 # specifies the timeout seconds while checking the online status of a registrating client
 123 $ping_timeout = 5;
 124
 125 $no_arp = 0;
 126 my $packages_list_under_construction = "/tmp/packages_list_creation_in_progress";
 127 my @packages_list_statements;
 128 my $watch_for_new_jobs_in_progress = 0;
 129
 130 # holds all incoming decrypted messages
 131 our $incoming_db;
 132 our $incoming_tn = 'incoming';
 133 my $incoming_file_name;
 134 my @incoming_col_names = ("id INTEGER PRIMARY KEY auto_increment",
 135         "timestamp VARCHAR(14) DEFAULT 'none'",
 136         "headertag VARCHAR(255) DEFAULT 'none'",
 137         "targettag VARCHAR(255) DEFAULT 'none'",
 138         "xmlmessage TEXT",
 139         "module VARCHAR(255) DEFAULT 'none'",
 140         "sessionid VARCHAR(255) DEFAULT '0'",
 141 );
 142
 143 # holds all gosa jobs
 144 our $job_db;
 145 our $job_queue_tn = 'jobs';
 146 my $job_queue_file_name;
 147 my @job_queue_col_names = ("id INTEGER PRIMARY KEY auto_increment",
 148         "timestamp VARCHAR(14) DEFAULT 'none'",
 149         "status VARCHAR(255) DEFAULT 'none'",
 150         "result TEXT",
 151         "progress VARCHAR(255) DEFAULT 'none'",
 152         "headertag VARCHAR(255) DEFAULT 'none'",
 153         "targettag VARCHAR(255) DEFAULT 'none'",
 154         "xmlmessage TEXT",
 155         "macaddress VARCHAR(17) DEFAULT 'none'",
 156         "plainname VARCHAR(255) DEFAULT 'none'",
 157         "siserver VARCHAR(255) DEFAULT 'none'",
 158         "modified INTEGER DEFAULT '0'",
 159 );
 160
 161 # holds all other gosa-si-server
 162 our $known_server_db;
 163 our $known_server_tn = "known_server";
 164 my $known_server_file_name;
 165 my @known_server_col_names = ("hostname VARCHAR(255)", "macaddress VARCHAR(17)", "status VARCHAR(255)", "hostkey VARCHAR(255)", "loaded_modules TEXT", "timestamp VARCHAR(14)");
 166
 167 # holds all registrated clients
 168 our $known_clients_db;
 169 our $known_clients_tn = "known_clients";
 170 my $known_clients_file_name;
 171 my @known_clients_col_names = ("hostname VARCHAR(255)", "status VARCHAR(255)", "hostkey VARCHAR(255)", "timestamp VARCHAR(14)", "macaddress VARCHAR(17)", "events TEXT", "keylifetime VARCHAR(255)");
 172
 173 # holds all registered clients at a foreign server
 174 our $foreign_clients_db;
 175 our $foreign_clients_tn = "foreign_clients";
 176 my $foreign_clients_file_name;
 177 my @foreign_clients_col_names = ("hostname VARCHAR(255)", "macaddress VARCHAR(17)", "regserver VARCHAR(255)", "timestamp VARCHAR(14)");
 178
 179 # holds all logged in user at each client
 180 our $login_users_db;
 181 our $login_users_tn = "login_users";
 182 my $login_users_file_name;
 183 my @login_users_col_names = ("client VARCHAR(255)", "user VARCHAR(255)", "timestamp VARCHAR(14)");
 184
 185 # holds all fai server, the debian release and tag
 186 our $fai_server_db;
 187 our $fai_server_tn = "fai_server";
 188 my $fai_server_file_name;
 189 our @fai_server_col_names = ("timestamp VARCHAR(14)", "server VARCHAR(255)", "fai_release VARCHAR(255)", "sections VARCHAR(255)", "tag VARCHAR(255)");
 190
 191 our $fai_release_db;
 192 our $fai_release_tn = "fai_release";
 193 my $fai_release_file_name;
 194 our @fai_release_col_names = ("timestamp VARCHAR(14)", "fai_release VARCHAR(255)", "class VARCHAR(255)", "type VARCHAR(255)", "state VARCHAR(255)");
 195
 196 # holds all packages available from different repositories
 197 our $packages_list_db;
 198 our $packages_list_tn = "packages_list";
 199 my $packages_list_file_name;
 200 our @packages_list_col_names = ("distribution VARCHAR(255)", "package VARCHAR(255)", "version VARCHAR(255)", "section VARCHAR(255)", "description TEXT", "template LONGBLOB", "timestamp VARCHAR(14)");
 201 my $outdir = "/tmp/packages_list_db";
 202 my $arch = "i386";
 203
 204 # holds all messages which should be delivered to a user
 205 our $messaging_db;
 206 our $messaging_tn = "messaging";
 207 our @messaging_col_names = ("id INTEGER", "subject TEXT", "message_from VARCHAR(255)", "message_to VARCHAR(255)",
 208         "flag VARCHAR(255)", "direction VARCHAR(255)", "delivery_time VARCHAR(255)", "message TEXT", "timestamp VARCHAR(14)" );
 209 my $messaging_file_name;
 210
 211 # path to directory to store client install log files
 212 our $client_fai_log_dir = "/var/log/fai";
 213
 214 # queue which stores taskes until one of the $max_children children are ready to process the task
 215 #my @tasks = qw();
 216 my @msgs_to_decrypt = qw();
 217 my $max_children = 2;
 218
 219
 220 # loop delay for job queue to look for opsi jobs
 221 my $job_queue_opsi_delay = 10;
 222 our $opsi_client;
 223 our $opsi_url;
 224
 225 # Lifetime of logged in user information. If no update information comes after n seconds,
 226 # the user is expeceted to be no longer logged in or the host is no longer running. Because
 227 # of this, the user is deleted from login_users_db
 228 our $logged_in_user_date_of_expiry = 600;
 229
 230
 231 %cfg_defaults = (
 232 "general" => {
 233     "log-file" => [\$log_file, "/var/run/".$prg.".log"],
 234     "pid-file" => [\$pid_file, "/var/run/".$prg.".pid"],
 235     },
 236 "server" => {
 237     "ip"                    => [\$server_ip, "0.0.0.0"],
 238     "port"                  => [\$server_port, "20081"],
 239     "known-clients"         => [\$known_clients_file_name, '/var/lib/gosa-si/clients.db' ],
 240     "known-servers"         => [\$known_server_file_name, '/var/lib/gosa-si/servers.db'],
 241     "incoming"              => [\$incoming_file_name, '/var/lib/gosa-si/incoming.db'],
 242     "login-users"           => [\$login_users_file_name, '/var/lib/gosa-si/users.db'],
 243     "fai-server"            => [\$fai_server_file_name, '/var/lib/gosa-si/fai_server.db'],
 244     "fai-release"           => [\$fai_release_file_name, '/var/lib/gosa-si/fai_release.db'],
 245     "packages-list"         => [\$packages_list_file_name, '/var/lib/gosa-si/packages.db'],
 246     "messaging"             => [\$messaging_file_name, '/var/lib/gosa-si/messaging.db'],
 247     "foreign-clients"       => [\$foreign_clients_file_name, '/var/lib/gosa-si/foreign_clients.db'],
 248     "source-list"           => [\$sources_list, '/etc/apt/sources.list'],
 249     "repo-path"             => [\$repo_path, '/srv/www/repository'],
 250     "ldap-uri"              => [\$ldap_uri, ""],
 251     "ldap-base"             => [\$ldap_base, ""],
 252     "ldap-admin-dn"         => [\$ldap_admin_dn, ""],
 253     "ldap-admin-password"   => [\$ldap_admin_password, ""],
 254     "gosa-unit-tag"         => [\$gosa_unit_tag, ""],
 255     "max-clients"           => [\$max_clients, 10],
 256     "wol-password"          => [\$wake_on_lan_passwd, ""],
 257                 "mysql-username"        => [\$mysql_username, "gosa_si"],
 258                 "mysql-password"        => [\$mysql_password, ""],
 259                 "mysql-database"        => [\$mysql_database, "gosa_si"],
 260                 "mysql-host"            => [\$mysql_host, "127.0.0.1"],
 261     },
 262 "GOsaPackages" => {
 263     "job-queue" => [\$job_queue_file_name, '/var/lib/gosa-si/jobs.db'],
 264     "job-queue-loop-delay" => [\$job_queue_loop_delay, 3],
 265     "messaging-db-loop-delay" => [\$messaging_db_loop_delay, 3],
 266     "key" => [\$GosaPackages_key, "none"],
 267                 "new-systems-ou" => [\$new_systems_ou, 'ou=workstations,ou=systems'],
 268     },
 269 "ClientPackages" => {
 270     "key" => [\$ClientPackages_key, "none"],
 271     "user-date-of-expiry" => [\$logged_in_user_date_of_expiry, 600],
 272     },
 273 "ServerPackages"=> {
 274     "address"      => [\$foreign_server_string, ""],
 275     "dns-lookup"            => [\$dns_lookup, "true"],
 276     "domain"  => [\$server_domain, ""],
 277     "key"     => [\$ServerPackages_key, "none"],
 278     "key-lifetime" => [\$foreign_servers_register_delay, 120],
 279     "job-synchronization-enabled" => [\$job_synchronization, "true"],
 280     "synchronization-loop" => [\$modified_jobs_loop_delay, 5],
 281     },
 282 "ArpHandler" => {
 283     "enabled"   => [\$arp_enabled, "true"],
 284     "interface" => [\$arp_interface, "all"],
 285         },
 286 "Opsi" => {
 287     "enabled"  => [\$opsi_enabled, "false"],
 288     "server"   => [\$opsi_server, "localhost"],
 289     "admin"    => [\$opsi_admin, "opsi-admin"],
 290     "password" => [\$opsi_password, "secret"],
 291    },
 292
 293 );
 294
 295
 296 #===  FUNCTION  ================================================================
 297 #         NAME:  usage
 298 #   PARAMETERS:  nothing
 299 #      RETURNS:  nothing
 300 #  DESCRIPTION:  print out usage text to STDERR
 301 #===============================================================================
 302 sub usage {
 303     print STDERR << "EOF" ;
 304 usage: $prg [-hvf] [-c config]
 305
 306            -h        : this (help) message
 307            -c <file> : config file
 308            -f        : foreground, process will not be forked to background
 309            -v        : be verbose (multiple to increase verbosity)
 310            -no-arp   : starts $prg without connection to arp module
 311
 312 EOF
 313     print "\n" ;
 314 }
 315
 316
 317 #===  FUNCTION  ================================================================
 318 #         NAME:  logging
 319 #   PARAMETERS:  level - string - default 'info'
 320 #                msg - string -
 321 #                facility - string - default 'LOG_DAEMON'
 322 #      RETURNS:  nothing
 323 #  DESCRIPTION:  function for logging
 324 #===============================================================================
 325 sub daemon_log {
 326     # log into log_file
 327     my( $msg, $level ) = @_;
 328     if(not defined $msg) { return }
 329     if(not defined $level) { $level = 1 }
 330     if(defined $log_file){
 331         open(LOG_HANDLE, ">>$log_file");
 332         if(not defined open( LOG_HANDLE, ">>$log_file" )) {
 333             print STDERR "cannot open $log_file: $!";
 334             return
 335         }
 336         chomp($msg);
 337         #$msg =~s/\n//g;   # no newlines are allowed in log messages, this is important for later log parsing
 338         if($level <= $verbose){
 339             my ($seconds, $minutes, $hours, $monthday, $month,
 340                     $year, $weekday, $yearday, $sommertime) = localtime(time);
 341             $hours = $hours < 10 ? $hours = "0".$hours : $hours;
 342             $minutes = $minutes < 10 ? $minutes = "0".$minutes : $minutes;
 343             $seconds = $seconds < 10 ? $seconds = "0".$seconds : $seconds;
 344             my @monthnames = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
 345             $month = $monthnames[$month];
 346             $monthday = $monthday < 10 ? $monthday = "0".$monthday : $monthday;
 347             $year+=1900;
 348             my $name = $prg;
 349
 350             my $log_msg = "$month $monthday $hours:$minutes:$seconds $name $msg\n";
 351             print LOG_HANDLE $log_msg;
 352             if( $foreground ) {
 353                 print STDERR $log_msg;
 354             }
 355         }
 356         close( LOG_HANDLE );
 357     }
 358 }
 359
 360
 361 #===  FUNCTION  ================================================================
 362 #         NAME:  check_cmdline_param
 363 #   PARAMETERS:  nothing
 364 #      RETURNS:  nothing
 365 #  DESCRIPTION:  validates commandline parameter
 366 #===============================================================================
 367 sub check_cmdline_param () {
 368     my $err_config;
 369     my $err_counter = 0;
 370         if(not defined($cfg_file)) {
 371                 $cfg_file = "/etc/gosa-si/server.conf";
 372                 if(! -r $cfg_file) {
 373                         $err_config = "please specify a config file";
 374                         $err_counter += 1;
 375                 }
 376     }
 377     if( $err_counter > 0 ) {
 378         &usage( "", 1 );
 379         if( defined( $err_config)) { print STDERR "$err_config\n"}
 380         print STDERR "\n";
 381         exit( -1 );
 382     }
 383 }
 384
 385
 386 #===  FUNCTION  ================================================================
 387 #         NAME:  check_pid
 388 #   PARAMETERS:  nothing
 389 #      RETURNS:  nothing
 390 #  DESCRIPTION:  handels pid processing
 391 #===============================================================================
 392 sub check_pid {
 393     $pid = -1;
 394     # Check, if we are already running
 395     if( open(LOCK_FILE, "<$pid_file") ) {
 396         $pid = <LOCK_FILE>;
 397         if( defined $pid ) {
 398             chomp( $pid );
 399             if( -f "/proc/$pid/stat" ) {
 400                 my($stat) = `cat /proc/$pid/stat` =~ m/$pid \((.+)\).*/;
 401                 if( $stat ) {
 402                                         daemon_log("ERROR: Already running",1);
 403                     close( LOCK_FILE );
 404                     exit -1;
 405                 }
 406             }
 407         }
 408         close( LOCK_FILE );
 409         unlink( $pid_file );
 410     }
 411
 412     # create a syslog msg if it is not to possible to open PID file
 413     if (not sysopen(LOCK_FILE, $pid_file, O_WRONLY|O_CREAT|O_EXCL, 0644)) {
 414         my($msg) = "Couldn't obtain lockfile '$pid_file' ";
 415         if (open(LOCK_FILE, '<', $pid_file)
 416                 && ($pid = <LOCK_FILE>))
 417         {
 418             chomp($pid);
 419             $msg .= "(PID $pid)\n";
 420         } else {
 421             $msg .= "(unable to read PID)\n";
 422         }
 423         if( ! ($foreground) ) {
 424             openlog( $0, "cons,pid", "daemon" );
 425             syslog( "warning", $msg );
 426             closelog();
 427         }
 428         else {
 429             print( STDERR " $msg " );
 430         }
 431         exit( -1 );
 432     }
 433 }
 434
 435 #===  FUNCTION  ================================================================
 436 #         NAME:  import_modules
 437 #   PARAMETERS:  module_path - string - abs. path to the directory the modules
 438 #                are stored
 439 #      RETURNS:  nothing
 440 #  DESCRIPTION:  each file in module_path which ends with '.pm' and activation
 441 #                state is on is imported by "require 'file';"
 442 #===============================================================================
 443 sub import_modules {
 444     daemon_log(" ", 1);
 445
 446     if (not -e $modules_path) {
 447         daemon_log("0 ERROR: cannot find directory or directory is not readable: $modules_path", 1);
 448     }
 449
 450     opendir (DIR, $modules_path) or die "ERROR while loading modules from directory $modules_path : $!\n";
 451     while (defined (my $file = readdir (DIR))) {
 452         if (not $file =~ /(\S*?).pm$/) {
 453             next;
 454         }
 455                 my $mod_name = $1;
 456
 457         # ArpHandler switch
 458         if( $file =~ /ArpHandler.pm/ ) {
 459             if( $arp_enabled eq "false" ) { next; }
 460         }
 461
 462         eval { require $file; };
 463         if ($@) {
 464             daemon_log("0 ERROR: gosa-si-server could not load module $file", 1);
 465             daemon_log("$@", 1);
 466             exit;
 467                 } else {
 468                         my $info = eval($mod_name.'::get_module_info()');
 469                         # Only load module if get_module_info() returns a non-null object
 470                         if( $info ) {
 471                                 my ($input_address, $input_key, $event_hash) = @{$info};
 472                                 $known_modules->{$mod_name} = $info;
 473                                 daemon_log("0 INFO: module $mod_name loaded", 5);
 474                         }
 475                 }
 476     }
 477
 478     close (DIR);
 479 }
 480
 481 #===  FUNCTION  ================================================================
 482 #         NAME:  password_check
 483 #   PARAMETERS:  nothing
 484 #      RETURNS:  nothing
 485 #  DESCRIPTION:  escalates an critical error if two modules exist which are avaialable by
 486 #                the same password
 487 #===============================================================================
 488 sub password_check {
 489     my $passwd_hash = {};
 490     while (my ($mod_name, $mod_info) = each %$known_modules) {
 491         my $mod_passwd = @$mod_info[1];
 492         if (not defined $mod_passwd) { next; }
 493         if (not exists $passwd_hash->{$mod_passwd}) {
 494             $passwd_hash->{$mod_passwd} = $mod_name;
 495
 496         # escalates critical error
 497         } else {
 498             &daemon_log("0 ERROR: two loaded modules do have the same password. Please modify the 'key'-parameter in config file");
 499             &daemon_log("0 ERROR: module='$mod_name' and module='".$passwd_hash->{$mod_passwd}."'");
 500             exit( -1 );
 501         }
 502     }
 503
 504 }
 505
 506
 507 #===  FUNCTION  ================================================================
 508 #         NAME:  sig_int_handler
 509 #   PARAMETERS:  signal - string - signal arose from system
 510 #      RETURNS:  nothing
 511 #  DESCRIPTION:  handels tasks to be done befor signal becomes active
 512 #===============================================================================
 513 sub sig_int_handler {
 514     my ($signal) = @_;
 515
 516 #       if (defined($ldap_handle)) {
 517 #               $ldap_handle->disconnect;
 518 #       }
 519     # TODO alle verbliebenden ldap verbindungen aus allen heaps beenden
 520
 521
 522     daemon_log("shutting down gosa-si-server", 1);
 523     system("kill `ps -C gosa-si-server -o pid=`");
 524 }
 525 $SIG{INT} = \&sig_int_handler;
 526
 527
 528 sub check_key_and_xml_validity {
 529     my ($crypted_msg, $module_key, $session_id) = @_;
 530     my $msg;
 531     my $msg_hash;
 532     my $error_string;
 533     eval{
 534         $msg = &decrypt_msg($crypted_msg, $module_key);
 535
 536         if ($msg =~ /<xml>/i){
 537             $msg =~ s/\s+/ /g;  # just for better daemon_log
 538             daemon_log("$session_id DEBUG: decrypted_msg: \n$msg", 9);
 539             $msg_hash = $xml->XMLin($msg, ForceArray=>1);
 540
 541             ##############
 542             # check header
 543             if( not exists $msg_hash->{'header'} ) { die "no header specified"; }
 544             my $header_l = $msg_hash->{'header'};
 545             if( (1 > @{$header_l}) || ( ( 'HASH' eq ref @{$header_l}[0]) && (1 > keys %{@{$header_l}[0]}) ) ) { die 'empty header tag'; }
 546             if( 1 < @{$header_l} ) { die 'more than one header specified'; }
 547             my $header = @{$header_l}[0];
 548             if( 0 == length $header) { die 'empty string in header tag'; }
 549
 550             ##############
 551             # check source
 552             if( not exists $msg_hash->{'source'} ) { die "no source specified"; }
 553             my $source_l = $msg_hash->{'source'};
 554             if( (1 > @{$source_l}) || ( ( 'HASH' eq ref @{$source_l}[0]) && (1 > keys %{@{$source_l}[0]}) ) ) { die 'empty source tag'; }
 555             if( 1 < @{$source_l} ) { die 'more than one source specified'; }
 556             my $source = @{$source_l}[0];
 557             if( 0 == length $source) { die 'source error'; }
 558
 559             ##############
 560             # check target
 561             if( not exists $msg_hash->{'target'} ) { die "no target specified"; }
 562             my $target_l = $msg_hash->{'target'};
 563             if( (1 > @{$target_l}) || ( ('HASH' eq ref @{$target_l}[0]) && (1 > keys %{@{$target_l}[0]}) ) ) { die 'empty target tag'; }
 564         }
 565     };
 566     if($@) {
 567         daemon_log("$session_id ERROR: do not understand the message: $@", 1);
 568         $msg = undef;
 569         $msg_hash = undef;
 570     }
 571
 572     return ($msg, $msg_hash);
 573 }
 574
 575
 576 sub check_outgoing_xml_validity {
 577     my ($msg, $session_id) = @_;
 578
 579     my $msg_hash;
 580     eval{
 581         $msg_hash = $xml->XMLin($msg, ForceArray=>1);
 582
 583         ##############
 584         # check header
 585         my $header_l = $msg_hash->{'header'};
 586         if( 1 != @{$header_l} ) {
 587             die 'no or more than one headers specified';
 588         }
 589         my $header = @{$header_l}[0];
 590         if( 0 == length $header) {
 591             die 'header has length 0';
 592         }
 593
 594         ##############
 595         # check source
 596         my $source_l = $msg_hash->{'source'};
 597         if( 1 != @{$source_l} ) {
 598             die 'no or more than 1 sources specified';
 599         }
 600         my $source = @{$source_l}[0];
 601         if( 0 == length $source) {
 602             die 'source has length 0';
 603         }
 604
 605                                 # Check if source contains hostname instead of ip address
 606                                 if(not $source =~ /^[a-z0-9\.]+:\d+$/i) {
 607                                                 my ($hostname,$port) = split(/:/, $source);
 608                                                 my $ip_address = inet_ntoa(scalar gethostbyname($hostname));
 609                                                 if(defined($ip_address) && $ip_address =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/ && $port =~ /^\d+$/) {
 610                                                         # Write ip address to $source variable
 611                                                         $source = "$ip_address:$port";
 612                                                 }
 613                                 }
 614         unless( $source =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+$/ ||
 615                 $source =~ /^GOSA$/i) {
 616             die "source '$source' is neither a complete ip-address with port nor 'GOSA'";
 617         }
 618
 619         ##############
 620         # check target
 621         my $target_l = $msg_hash->{'target'};
 622         if( 0 == @{$target_l} ) {
 623             die "no targets specified";
 624         }
 625         foreach my $target (@$target_l) {
 626             if( 0 == length $target) {
 627                 die "target has length 0";
 628             }
 629             unless( $target =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+$/ ||
 630                     $target =~ /^GOSA$/i ||
 631                     $target =~ /^\*$/ ||
 632                     $target =~ /KNOWN_SERVER/i ||
 633                     $target =~ /JOBDB/i ||
 634                     $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 ){
 635                 die "target '$target' is not a complete ip-address with port or a valid target name or a mac-address";
 636             }
 637         }
 638     };
 639     if($@) {
 640         daemon_log("$session_id ERROR: outgoing msg is not gosa-si envelope conform: $@", 1);
 641         daemon_log("$@ ".(defined($msg) && length($msg)>0)?$msg:"Empty Message", 1);
 642         $msg_hash = undef;
 643     }
 644
 645     return ($msg_hash);
 646 }
 647
 648
 649 sub input_from_known_server {
 650     my ($input, $remote_ip, $session_id) = @_ ;
 651     my ($msg, $msg_hash, $module);
 652
 653     my $sql_statement= "SELECT * FROM known_server";
 654     my $query_res = $known_server_db->select_dbentry( $sql_statement );
 655
 656     while( my ($hit_num, $hit) = each %{ $query_res } ) {
 657         my $host_name = $hit->{hostname};
 658         if( not $host_name =~ "^$remote_ip") {
 659             next;
 660         }
 661         my $host_key = $hit->{hostkey};
 662         daemon_log("$session_id DEBUG: input_from_known_server: host_name: $host_name", 7);
 663         daemon_log("$session_id DEBUG: input_from_known_server: host_key: $host_key", 7);
 664
 665         # check if module can open msg envelope with module key
 666         my ($tmp_msg, $tmp_msg_hash) = &check_key_and_xml_validity($input, $host_key, $session_id);
 667         if( (!$tmp_msg) || (!$tmp_msg_hash) ) {
 668             daemon_log("$session_id DEBUG: input_from_known_server: deciphering raise error", 7);
 669             daemon_log("$@", 8);
 670             next;
 671         }
 672         else {
 673             $msg = $tmp_msg;
 674             $msg_hash = $tmp_msg_hash;
 675             $module = "ServerPackages";
 676             daemon_log("$session_id DEBUG: check_key_and_xml_validity... ok", 7);
 677             last;
 678         }
 679     }
 680
 681     if( (!$msg) || (!$msg_hash) || (!$module) ) {
 682         daemon_log("$session_id DEBUG: Incoming message is not from a known server", 7);
 683     }
 684
 685     return ($msg, $msg_hash, $module);
 686 }
 687
 688
 689 sub input_from_known_client {
 690     my ($input, $remote_ip, $session_id) = @_ ;
 691     my ($msg, $msg_hash, $module);
 692
 693     my $sql_statement= "SELECT * FROM known_clients";
 694     my $query_res = $known_clients_db->select_dbentry( $sql_statement );
 695     while( my ($hit_num, $hit) = each %{ $query_res } ) {
 696         my $host_name = $hit->{hostname};
 697         if( not $host_name =~ /^$remote_ip:\d*$/) {
 698                 next;
 699                 }
 700         my $host_key = $hit->{hostkey};
 701         &daemon_log("$session_id DEBUG: input_from_known_client: host_name: $host_name", 7);
 702         &daemon_log("$session_id DEBUG: input_from_known_client: host_key: $host_key", 7);
 703
 704         # check if module can open msg envelope with module key
 705         ($msg, $msg_hash) = &check_key_and_xml_validity($input, $host_key, $session_id);
 706
 707         if( (!$msg) || (!$msg_hash) ) {
 708             &daemon_log("$session_id DEGUG: input_from_known_client: deciphering raise error", 7);
 709             &daemon_log("$@", 8);
 710             next;
 711         }
 712         else {
 713             $module = "ClientPackages";
 714             daemon_log("$session_id DEBUG: check_key_and_xml_validity... ok", 7);
 715             last;
 716         }
 717     }
 718
 719     if( (!$msg) || (!$msg_hash) || (!$module) ) {
 720         &daemon_log("$session_id DEBUG: Incoming message is not from a known client", 7);
 721     }
 722
 723     return ($msg, $msg_hash, $module);
 724 }
 725
 726
 727 sub input_from_unknown_host {
 728         no strict "refs";
 729         my ($input, $session_id) = @_ ;
 730         my ($msg, $msg_hash, $module);
 731         my $error_string;
 732
 733         my %act_modules = %$known_modules;
 734
 735         while( my ($mod, $info) = each(%act_modules)) {
 736
 737                 # check a key exists for this module
 738                 my $module_key = ${$mod."_key"};
 739                 if( not defined $module_key ) {
 740                         if( $mod eq 'ArpHandler' ) {
 741                                 next;
 742                         }
 743                         daemon_log("$session_id ERROR: no key specified in config file for $mod", 1);
 744                         next;
 745                 }
 746                 daemon_log("$session_id DEBUG: $mod: $module_key", 7);
 747
 748                 # check if module can open msg envelope with module key
 749                 ($msg, $msg_hash) = &check_key_and_xml_validity($input, $module_key, $session_id);
 750                 if( (not defined $msg) || (not defined $msg_hash) ) {
 751                         next;
 752                 } else {
 753                         $module = $mod;
 754             daemon_log("$session_id DEBUG: check_key_and_xml_validity... ok", 7);
 755                         last;
 756                 }
 757         }
 758
 759         if( (!$msg) || (!$msg_hash) || (!$module)) {
 760                 daemon_log("$session_id DEBUG: Incoming message is not from an unknown host", 7);
 761         }
 762
 763         return ($msg, $msg_hash, $module);
 764 }
 765
 766
 767 sub create_ciphering {
 768     my ($passwd) = @_;
 769         if((!defined($passwd)) || length($passwd)==0) {
 770                 $passwd = "";
 771         }
 772     $passwd = substr(md5_hex("$passwd") x 32, 0, 32);
 773     my $iv = substr(md5_hex('GONICUS GmbH'),0, 16);
 774     my $my_cipher = Crypt::Rijndael->new($passwd , Crypt::Rijndael::MODE_CBC());
 775     $my_cipher->set_iv($iv);
 776     return $my_cipher;
 777 }
 778
 779
 780 sub encrypt_msg {
 781     my ($msg, $key) = @_;
 782     my $my_cipher = &create_ciphering($key);
 783     my $len;
 784     {
 785             use bytes;
 786             $len= 16-length($msg)%16;
 787     }
 788     $msg = "\0"x($len).$msg;
 789     $msg = $my_cipher->encrypt($msg);
 790     chomp($msg = &encode_base64($msg));
 791     # there are no newlines allowed inside msg
 792     $msg=~ s/\n//g;
 793     return $msg;
 794 }
 795
 796
 797 sub decrypt_msg {
 798
 799     my ($msg, $key) = @_ ;
 800     $msg = &decode_base64($msg);
 801     my $my_cipher = &create_ciphering($key);
 802     $msg = $my_cipher->decrypt($msg);
 803     $msg =~ s/\0*//g;
 804     return $msg;
 805 }
 806
 807
 808 sub get_encrypt_key {
 809     my ($target) = @_ ;
 810     my $encrypt_key;
 811     my $error = 0;
 812
 813     # target can be in known_server
 814     if( not defined $encrypt_key ) {
 815         my $sql_statement= "SELECT * FROM known_server WHERE hostname='$target'";
 816         my $query_res = $known_server_db->select_dbentry( $sql_statement );
 817         while( my ($hit_num, $hit) = each %{ $query_res } ) {
 818             my $host_name = $hit->{hostname};
 819             if( $host_name ne $target ) {
 820                 next;
 821             }
 822             $encrypt_key = $hit->{hostkey};
 823             last;
 824         }
 825     }
 826
 827     # target can be in known_client
 828     if( not defined $encrypt_key ) {
 829         my $sql_statement= "SELECT * FROM known_clients WHERE hostname='$target'";
 830         my $query_res = $known_clients_db->select_dbentry( $sql_statement );
 831         while( my ($hit_num, $hit) = each %{ $query_res } ) {
 832             my $host_name = $hit->{hostname};
 833             if( $host_name ne $target ) {
 834                 next;
 835             }
 836             $encrypt_key = $hit->{hostkey};
 837             last;
 838         }
 839     }
 840
 841     return $encrypt_key;
 842 }
 843
 844
 845 #===  FUNCTION  ================================================================
 846 #         NAME:  open_socket
 847 #   PARAMETERS:  PeerAddr string something like 192.168.1.1 or 192.168.1.1:10000
 848 #                [PeerPort] string necessary if port not appended by PeerAddr
 849 #      RETURNS:  socket IO::Socket::INET
 850 #  DESCRIPTION:  open a socket to PeerAddr
 851 #===============================================================================
 852 sub open_socket {
 853     my ($PeerAddr, $PeerPort) = @_ ;
 854     if(defined($PeerPort)){
 855         $PeerAddr = $PeerAddr.":".$PeerPort;
 856     }
 857     my $socket;
 858     $socket = new IO::Socket::INET(PeerAddr => $PeerAddr,
 859             Porto => "tcp",
 860             Type => SOCK_STREAM,
 861             Timeout => 5,
 862             );
 863     if(not defined $socket) {
 864         return;
 865     }
 866 #    &daemon_log("DEBUG: open_socket: $PeerAddr", 7);
 867     return $socket;
 868 }
 869
 870
 871 #sub get_local_ip_for_remote_ip {
 872 #       my $remote_ip= shift;
 873 #       my $result="0.0.0.0";
 874 #
 875 #       if($remote_ip =~ /^(\d\d?\d?\.){3}\d\d?\d?$/) {
 876 #               if($remote_ip eq "127.0.0.1") {
 877 #                       $result = "127.0.0.1";
 878 #               } else {
 879 #                       my $PROC_NET_ROUTE= ('/proc/net/route');
 880 #
 881 #                       open(PROC_NET_ROUTE, "<$PROC_NET_ROUTE")
 882 #                               or die "Could not open $PROC_NET_ROUTE";
 883 #
 884 #                       my @ifs = <PROC_NET_ROUTE>;
 885 #
 886 #                       close(PROC_NET_ROUTE);
 887 #
 888 #                       # Eat header line
 889 #                       shift @ifs;
 890 #                       chomp @ifs;
 891 #                       foreach my $line(@ifs) {
 892 #                               my ($Iface,$Destination,$Gateway,$Flags,$RefCnt,$Use,$Metric,$Mask,$MTU,$Window,$IRTT)=split(/\s/, $line);
 893 #                               my $destination;
 894 #                               my $mask;
 895 #                               my ($d,$c,$b,$a)=unpack('a2 a2 a2 a2', $Destination);
 896 #                               $destination= sprintf("%d.%d.%d.%d", hex($a), hex($b), hex($c), hex($d));
 897 #                               ($d,$c,$b,$a)=unpack('a2 a2 a2 a2', $Mask);
 898 #                               $mask= sprintf("%d.%d.%d.%d", hex($a), hex($b), hex($c), hex($d));
 899 #                               if(new NetAddr::IP($remote_ip)->within(new NetAddr::IP($destination, $mask))) {
 900 #                                       # destination matches route, save mac and exit
 901 #                                       $result= &get_ip($Iface);
 902 #                                       last;
 903 #                               }
 904 #                       }
 905 #               }
 906 #       } else {
 907 #               daemon_log("0 WARNING: get_local_ip_for_remote_ip() was called with a non-ip parameter: '$remote_ip'", 1);
 908 #       }
 909 #       return $result;
 910 #}
 911
 912
 913 sub send_msg_to_target {
 914     my ($msg, $address, $encrypt_key, $msg_header, $session_id) = @_ ;
 915     my $error = 0;
 916     my $header;
 917     my $timestamp = &get_time();
 918     my $new_status;
 919     my $act_status;
 920     my ($sql_statement, $res);
 921
 922     if( $msg_header ) {
 923         $header = "'$msg_header'-";
 924     } else {
 925         $header = "";
 926     }
 927
 928         # Patch the source ip
 929         if($msg =~ /<source>0\.0\.0\.0:\d*?<\/source>/) {
 930                 my $remote_ip = &get_local_ip_for_remote_ip(sprintf("%s", $address =~ /^([0-9\.]*?):.*$/));
 931                 $msg =~ s/<source>(0\.0\.0\.0):(\d*?)<\/source>/<source>$remote_ip:$2<\/source>/s;
 932         }
 933
 934     # encrypt xml msg
 935     my $crypted_msg = &encrypt_msg($msg, $encrypt_key);
 936
 937     # opensocket
 938     my $socket = &open_socket($address);
 939     if( !$socket ) {
 940         daemon_log("$session_id WARNING: cannot send ".$header."msg to $address , host not reachable", 3);
 941         $error++;
 942     }
 943
 944     if( $error == 0 ) {
 945         # send xml msg
 946         print $socket $crypted_msg."\n";
 947
 948         daemon_log("$session_id INFO: send ".$header."msg to $address", 5);
 949         daemon_log("$session_id DEBUG: message:\n$msg", 9);
 950
 951     }
 952
 953     # close socket in any case
 954     if( $socket ) {
 955         close $socket;
 956     }
 957
 958     if( $error > 0 ) { $new_status = "down"; }
 959     else { $new_status = $msg_header; }
 960
 961
 962     # known_clients
 963     $sql_statement = "SELECT * FROM $known_clients_tn WHERE hostname='$address'";
 964     $res = $known_clients_db->select_dbentry($sql_statement);
 965     if( keys(%$res) == 1) {
 966         $act_status = exists $res->{1}->{'status'} ? $res->{1}->{'status'} : "";
 967         if ($act_status eq "down" && $new_status eq "down") {
 968             $sql_statement = "DELETE FROM known_clients WHERE hostname='$address'";
 969             $res = $known_clients_db->del_dbentry($sql_statement);
 970             daemon_log("$session_id WARNING: failed 2x to send msg to host '$address', delete host from known_clients", 3);
 971         } else {
 972             $sql_statement = "UPDATE known_clients SET status='$new_status', timestamp='$timestamp' WHERE hostname='$address'";
 973             $res = $known_clients_db->update_dbentry($sql_statement);
 974             if($new_status eq "down"){
 975                 daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
 976             } else {
 977                 daemon_log("$session_id INFO: set '$address' from status '$act_status' to '$new_status'", 5);
 978             }
 979         }
 980     }
 981
 982     # known_server
 983     $sql_statement = "SELECT * FROM $known_server_tn WHERE hostname='$address'";
 984     $res = $known_server_db->select_dbentry($sql_statement);
 985     if( keys(%$res) == 1) {
 986         $act_status = exists $res->{1}->{'status'} ? $res->{1}->{'status'} : "";
 987         if ($act_status eq "down" && $new_status eq "down") {
 988             $sql_statement = "DELETE FROM known_server WHERE hostname='$address'";
 989             $res = $known_server_db->del_dbentry($sql_statement);
 990             daemon_log("$session_id WARNING: failed 2x to send a message to host '$address', delete host from known_server", 3);
 991         }
 992         else {
 993             $sql_statement = "UPDATE known_server SET status='$new_status', timestamp='$timestamp' WHERE hostname='$address'";
 994             $res = $known_server_db->update_dbentry($sql_statement);
 995             if($new_status eq "down"){
 996                 daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
 997             } else {
 998                 daemon_log("$session_id INFO: set '$address' from status '$act_status' to '$new_status'", 5);
 999             }
1000         }
1001     }
1002     return $error;
1003 }
1004
1005
1006 sub update_jobdb_status_for_send_msgs {
1007     my ($answer, $error) = @_;
1008     if( $answer =~ /<jobdb_id>(\d+)<\/jobdb_id>/ ) {
1009         my $jobdb_id = $1;
1010
1011         # sending msg faild
1012         if( $error ) {
1013             if (not $answer =~ /<header>trigger_action_reinstall<\/header>/) {
1014                 my $sql_statement = "UPDATE $job_queue_tn ".
1015                     "SET status='error', result='can not deliver msg, please consult log file' ".
1016                     "WHERE id=$jobdb_id";
1017                 my $res = $job_db->update_dbentry($sql_statement);
1018             }
1019
1020         # sending msg was successful
1021         } else {
1022             my $sql_statement = "UPDATE $job_queue_tn ".
1023                 "SET status='done' ".
1024                 "WHERE id=$jobdb_id AND status='processed'";
1025             my $res = $job_db->update_dbentry($sql_statement);
1026         }
1027     }
1028 }
1029
1030
1031 sub sig_handler {
1032         my ($kernel, $signal) = @_[KERNEL, ARG0] ;
1033         daemon_log("0 INFO got signal '$signal'", 1);
1034         $kernel->sig_handled();
1035         return;
1036 }
1037
1038
1039 sub msg_to_decrypt {
1040         my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];
1041         my $session_id = $session->ID;
1042         my ($msg, $msg_hash, $module);
1043         my $error = 0;
1044
1045         # hole neue msg aus @msgs_to_decrypt
1046         my $next_msg = shift @msgs_to_decrypt;
1047
1048         # msg is from a new client or gosa
1049         ($msg, $msg_hash, $module) = &input_from_unknown_host($next_msg, $session_id);
1050
1051         # msg is from a gosa-si-server
1052         if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1053                 ($msg, $msg_hash, $module) = &input_from_known_server($next_msg, $heap->{'remote_ip'}, $session_id);
1054         }
1055         # msg is from a gosa-si-client
1056         if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1057                 ($msg, $msg_hash, $module) = &input_from_known_client($next_msg, $heap->{'remote_ip'}, $session_id);
1058         }
1059         # an error occurred
1060         if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1061                 # if an incoming msg could not be decrypted (maybe a wrong key), send client a ping. If the client
1062                 # could not understand a msg from its server the client cause a re-registering process
1063                 daemon_log("$session_id WARNING cannot understand incoming msg, send 'ping'-msg to all host with ip '".$heap->{remote_ip}.
1064                         "' to cause a re-registering of the client if necessary", 3);
1065                 my $sql_statement = "SELECT * FROM $main::known_clients_tn WHERE (hostname LIKE '".$heap->{'remote_ip'}."%')";
1066                 my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1067                 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1068                         my $host_name = $hit->{'hostname'};
1069                         my $host_key = $hit->{'hostkey'};
1070                         my $ping_msg = "<xml> <header>gosa_ping</header> <source>$server_address</source> <target>$host_name</target></xml>";
1071                         my $error = &send_msg_to_target($ping_msg, $host_name, $host_key, "gosa_ping", $session_id);
1072                         &update_jobdb_status_for_send_msgs($ping_msg, $error);
1073                 }
1074                 $error++;
1075         }
1076
1077
1078         my $header;
1079         my $target;
1080         my $source;
1081         my $done = 0;
1082         my $sql;
1083         my $res;
1084
1085         # check whether this message should be processed here
1086         if ($error == 0) {
1087                 $header = @{$msg_hash->{'header'}}[0];
1088                 $target = @{$msg_hash->{'target'}}[0];
1089                 $source = @{$msg_hash->{'source'}}[0];
1090                 my $not_found_in_known_clients_db = 0;
1091                 my $not_found_in_known_server_db = 0;
1092                 my $not_found_in_foreign_clients_db = 0;
1093                 my $local_address;
1094                 my $local_mac;
1095                 my ($target_ip, $target_port) = split(':', $target);
1096
1097                 # Determine the local ip address if target is an ip address
1098                 if ($target =~ /^\d+\.\d+\.\d+\.\d+:\d+$/) {
1099                         $local_address = &get_local_ip_for_remote_ip($target_ip).":$server_port";
1100                 } else {
1101                         $local_address = $server_address;
1102                 }
1103
1104                 # Determine the local mac address if target is a mac address
1105                 if ($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) {
1106                         my $loc_ip = &get_local_ip_for_remote_ip($heap->{'remote_ip'});
1107                         my $network_interface= &get_interface_for_ip($loc_ip);
1108                         $local_mac = &get_mac_for_interface($network_interface);
1109                 } else {
1110                         $local_mac = $server_mac_address;
1111                 }
1112
1113                 # target and source is equal to GOSA -> process here
1114                 if (not $done) {
1115                         if ($target eq "GOSA" && $source eq "GOSA") {
1116                                 $done = 1;
1117                                 &daemon_log("$session_id DEBUG: target and source is 'GOSA' -> process here", 7);
1118                         }
1119                 }
1120
1121                 # target is own address without forward_to_gosa-tag -> process here
1122                 if (not $done) {
1123                         #if ((($target eq $local_address) || ($target eq $local_mac) ) && (not exists $msg_hash->{'forward_to_gosa'})) {
1124                         if (($target eq $local_address) && (not exists $msg_hash->{'forward_to_gosa'})) {
1125                                 $done = 1;
1126                                 if ($source eq "GOSA") {
1127                                         $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1128                                 }
1129                                 &daemon_log("$session_id DEBUG: target is own address without forward_to_gosa-tag -> process here", 7);
1130                         }
1131                 }
1132
1133                 # target is a client address in known_clients -> process here
1134                 if (not $done) {
1135                         $sql = "SELECT * FROM $known_clients_tn WHERE (hostname='$target' OR macaddress LIKE '$target')";
1136                         $res = $known_clients_db->select_dbentry($sql);
1137                         if (keys(%$res) > 0) {
1138                                 $done = 1;
1139                                 my $hostname = $res->{1}->{'hostname'};
1140                                 $msg =~ s/<target>$target<\/target>/<target>$hostname<\/target>/;
1141                                 my $local_address = &get_local_ip_for_remote_ip($target_ip).":$server_port";
1142                                 if ($source eq "GOSA") {
1143                                         $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1144                                 }
1145                                 &daemon_log("$session_id DEBUG: target is a client address in known_clients -> process here", 7);
1146
1147                         } else {
1148                                 $not_found_in_known_clients_db = 1;
1149                         }
1150                 }
1151
1152                 # target ist own address with forward_to_gosa-tag not pointing to myself -> process here
1153                 if (not $done) {
1154                         my $forward_to_gosa =  @{$msg_hash->{'forward_to_gosa'}}[0];
1155                         my $gosa_at;
1156                         my $gosa_session_id;
1157                         if (($target eq $local_address) && (defined $forward_to_gosa)){
1158                                 my ($gosa_at, $gosa_session_id) = split(/,/, $forward_to_gosa);
1159                                 if ($gosa_at ne $local_address) {
1160                                         $done = 1;
1161                                         &daemon_log("$session_id DEBUG: target is own address with forward_to_gosa-tag not pointing to myself -> process here", 7);
1162                                 }
1163                         }
1164                 }
1165
1166                 # if message should be processed here -> add message to incoming_db
1167                 if ($done) {
1168                         # if a job or a gosa message comes from a foreign server, fake module to GosaPackages
1169                         # so gosa-si-server knows how to process this kind of messages
1170                         if ($header =~ /^gosa_/ || $header =~ /^job_/) {
1171                                 $module = "GosaPackages";
1172                         }
1173
1174                         my $res = $incoming_db->add_dbentry( {table=>$incoming_tn,
1175                                         primkey=>[],
1176                                         headertag=>$header,
1177                                         targettag=>$target,
1178                                         xmlmessage=>&encode_base64($msg),
1179                                         timestamp=>&get_time,
1180                                         module=>$module,
1181                                         sessionid=>$session_id,
1182                                 } );
1183
1184                 }
1185
1186                 # target is own address with forward_to_gosa-tag pointing at myself -> forward to gosa
1187                 if (not $done) {
1188                         my $forward_to_gosa =  @{$msg_hash->{'forward_to_gosa'}}[0];
1189                         my $gosa_at;
1190                         my $gosa_session_id;
1191                         if (($target eq $local_address) && (defined $forward_to_gosa)){
1192                                 my ($gosa_at, $gosa_session_id) = split(/,/, $forward_to_gosa);
1193                                 if ($gosa_at eq $local_address) {
1194                                         my $session_reference = $kernel->ID_id_to_session($gosa_session_id);
1195                                         if( defined $session_reference ) {
1196                                                 $heap = $session_reference->get_heap();
1197                                         }
1198                                         if(exists $heap->{'client'}) {
1199                                                 $msg = &encrypt_msg($msg, $GosaPackages_key);
1200                                                 $heap->{'client'}->put($msg);
1201                                                 &daemon_log("$session_id INFO: incoming '$header' message forwarded to GOsa", 5);
1202                                         }
1203                                         $done = 1;
1204                                         &daemon_log("$session_id DEBUG: target is own address with forward_to_gosa-tag pointing at myself -> forward to gosa", 7);
1205                                 }
1206                         }
1207
1208                 }
1209
1210                 # target is a client address in foreign_clients -> forward to registration server
1211                 if (not $done) {
1212                         $sql = "SELECT * FROM $foreign_clients_tn WHERE (hostname='$target' OR macaddress LIKE '$target')";
1213                         $res = $foreign_clients_db->select_dbentry($sql);
1214                         if (keys(%$res) > 0) {
1215                                 my $hostname = $res->{1}->{'hostname'};
1216                                 my ($host_ip, $host_port) = split(/:/, $hostname);
1217                                 my $local_address =  &get_local_ip_for_remote_ip($host_ip).":$server_port";
1218                                 my $regserver = $res->{1}->{'regserver'};
1219                                 my $sql = "SELECT * FROM $known_server_tn WHERE hostname='$regserver'";
1220                                 my $res = $known_server_db->select_dbentry($sql);
1221                                 if (keys(%$res) > 0) {
1222                                         my $regserver_key = $res->{1}->{'hostkey'};
1223                                         $msg =~ s/<source>GOSA<\/source>/<source>$local_address<\/source>/;
1224                                         $msg =~ s/<target>$target<\/target>/<target>$hostname<\/target>/;
1225                                         if ($source eq "GOSA") {
1226                                                 $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1227                                         }
1228                                         &send_msg_to_target($msg, $regserver, $regserver_key, $header, $session_id);
1229                                 }
1230                                 $done = 1;
1231                                 &daemon_log("$session_id DEBUG: target is a client address in foreign_clients -> forward to registration server", 7);
1232                         } else {
1233                                 $not_found_in_foreign_clients_db = 1;
1234                         }
1235                 }
1236
1237                 # target is a server address -> forward to server
1238                 if (not $done) {
1239                         $sql = "SELECT * FROM $known_server_tn WHERE (hostname='$target' OR macaddress LIKE '$target')";
1240                         $res = $known_server_db->select_dbentry($sql);
1241                         if (keys(%$res) > 0) {
1242                                 my $hostkey = $res->{1}->{'hostkey'};
1243
1244                                 if ($source eq "GOSA") {
1245                                         $msg =~ s/<source>GOSA<\/source>/<source>$local_address<\/source>/;
1246                                         $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1247
1248                                 }
1249
1250                                 &send_msg_to_target($msg, $target, $hostkey, $header, $session_id);
1251                                 $done = 1;
1252                                 &daemon_log("$session_id DEBUG: target is a server address -> forward to server", 7);
1253                         } else {
1254                                 $not_found_in_known_server_db = 1;
1255                         }
1256                 }
1257
1258
1259                 # target is not in foreign_clients_db, known_server_db or known_clients_db, maybe it is a complete new one -> process here
1260                 if ( $not_found_in_foreign_clients_db
1261                         && $not_found_in_known_server_db
1262                         && $not_found_in_known_clients_db) {
1263                         &daemon_log("$session_id DEBUG: target is not in foreign_clients_db, known_server_db or known_clients_db, maybe it is a complete new one -> process here", 7);
1264                         my $res = $incoming_db->add_dbentry( {table=>$incoming_tn,
1265                                         primkey=>[],
1266                                         headertag=>$header,
1267                                         targettag=>$target,
1268                                         xmlmessage=>&encode_base64($msg),
1269                                         timestamp=>&get_time,
1270                                         module=>$module,
1271                                         sessionid=>$session_id,
1272                                 } );
1273                         $done = 1;
1274                 }
1275
1276
1277                 if (not $done) {
1278                         daemon_log("$session_id ERROR: do not know what to do with this message: $msg", 1);
1279                         if ($source eq "GOSA") {
1280                                 my %data = ('error_msg' => &encode_base64($msg), 'error_string' => "Do not know what to do with this message!");
1281                                 my $error_msg = &build_msg("error", $local_address, "GOSA", \%data );
1282
1283                                 my $session_reference = $kernel->ID_id_to_session($session_id);
1284                                 if( defined $session_reference ) {
1285                                         $heap = $session_reference->get_heap();
1286                                 }
1287                                 if(exists $heap->{'client'}) {
1288                                         $error_msg = &encrypt_msg($error_msg, $GosaPackages_key);
1289                                         $heap->{'client'}->put($error_msg);
1290                                 }
1291                         }
1292                 }
1293
1294         }
1295
1296         return;
1297 }
1298
1299
1300 sub next_task {
1301     my ($session, $heap, $task) = @_[SESSION, HEAP, ARG0];
1302     my $running_task = POE::Wheel::Run->new(
1303             Program => sub { process_task($session, $heap, $task) },
1304             StdioFilter => POE::Filter::Reference->new(),
1305             StdoutEvent  => "task_result",
1306             StderrEvent  => "task_debug",
1307             CloseEvent   => "task_done",
1308             );
1309     $heap->{task}->{ $running_task->ID } = $running_task;
1310 }
1311
1312 sub handle_task_result {
1313     my ($kernel, $heap, $result) = @_[KERNEL, HEAP, ARG0];
1314     my $client_answer = $result->{'answer'};
1315     if( $client_answer =~ s/session_id=(\d+)$// ) {
1316         my $session_id = $1;
1317         if( defined $session_id ) {
1318             my $session_reference = $kernel->ID_id_to_session($session_id);
1319             if( defined $session_reference ) {
1320                 $heap = $session_reference->get_heap();
1321             }
1322         }
1323
1324         if(exists $heap->{'client'}) {
1325             $heap->{'client'}->put($client_answer);
1326         }
1327     }
1328     $kernel->sig(CHLD => "child_reap");
1329 }
1330
1331 sub handle_task_debug {
1332     my $result = $_[ARG0];
1333     print STDERR "$result\n";
1334 }
1335
1336 sub handle_task_done {
1337     my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
1338     delete $heap->{task}->{$task_id};
1339 }
1340
1341 sub process_task {
1342     no strict "refs";
1343     #CHECK: Not @_[...]?
1344     my ($session, $heap, $task) = @_;
1345     my $error = 0;
1346     my $answer_l;
1347     my ($answer_header, @answer_target_l, $answer_source);
1348     my $client_answer = "";
1349
1350     # prepare all variables needed to process message
1351     #my $msg = $task->{'xmlmessage'};
1352     my $msg = &decode_base64($task->{'xmlmessage'});
1353     my $incoming_id = $task->{'id'};
1354     my $module = $task->{'module'};
1355     my $header =  $task->{'headertag'};
1356     my $session_id = $task->{'sessionid'};
1357                 my $msg_hash;
1358                 eval {
1359         $msg_hash = $xml->XMLin($msg, ForceArray=>1);
1360                 };
1361                 daemon_log("ERROR: XML failure '$@'") if ($@);
1362     my $source = @{$msg_hash->{'source'}}[0];
1363
1364     # set timestamp of incoming client uptodate, so client will not
1365     # be deleted from known_clients because of expiration
1366     my $act_time = &get_time();
1367     my $sql = "UPDATE $known_clients_tn SET timestamp='$act_time' WHERE hostname='$source'";
1368     my $res = $known_clients_db->exec_statement($sql);
1369
1370     ######################
1371     # process incoming msg
1372     if( $error == 0) {
1373         daemon_log("$session_id INFO: Incoming msg (session_id=$session_id) with header '".@{$msg_hash->{'header'}}[0]."'", 5);
1374         daemon_log("$session_id DEBUG: Processing module ".$module, 7);
1375         $answer_l = &{ $module."::process_incoming_msg" }($msg, $msg_hash, $session_id);
1376
1377         if ( 0 < @{$answer_l} ) {
1378             my $answer_str = join("\n", @{$answer_l});
1379             while ($answer_str =~ /<header>(\w+)<\/header>/g) {
1380                 daemon_log("$session_id INFO: got answer message with header '$1'", 5);
1381             }
1382             daemon_log("$session_id DEBUG: $module: got answer from module: \n".$answer_str,9);
1383         } else {
1384             daemon_log("$session_id DEBUG: $module: got no answer from module!" ,7);
1385         }
1386
1387     }
1388     if( !$answer_l ) { $error++ };
1389
1390     ########
1391     # answer
1392     if( $error == 0 ) {
1393
1394         foreach my $answer ( @{$answer_l} ) {
1395             # check outgoing msg to xml validity
1396             my $answer_hash = &check_outgoing_xml_validity($answer, $session_id);
1397             if( not defined $answer_hash ) { next; }
1398
1399             $answer_header = @{$answer_hash->{'header'}}[0];
1400             @answer_target_l = @{$answer_hash->{'target'}};
1401             $answer_source = @{$answer_hash->{'source'}}[0];
1402
1403             # deliver msg to all targets
1404             foreach my $answer_target ( @answer_target_l ) {
1405
1406                 # targets of msg are all gosa-si-clients in known_clients_db
1407                 if( $answer_target eq "*" ) {
1408                     # answer is for all clients
1409                     my $sql_statement= "SELECT * FROM known_clients";
1410                     my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1411                     while( my ($hit_num, $hit) = each %{ $query_res } ) {
1412                         my $host_name = $hit->{hostname};
1413                         my $host_key = $hit->{hostkey};
1414                         my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1415                         &update_jobdb_status_for_send_msgs($answer, $error);
1416                     }
1417                 }
1418
1419                 # targets of msg are all gosa-si-server in known_server_db
1420                 elsif( $answer_target eq "KNOWN_SERVER" ) {
1421                     # answer is for all server in known_server
1422                     my $sql_statement= "SELECT * FROM $known_server_tn";
1423                     my $query_res = $known_server_db->select_dbentry( $sql_statement );
1424                     while( my ($hit_num, $hit) = each %{ $query_res } ) {
1425                         my $host_name = $hit->{hostname};
1426                         my $host_key = $hit->{hostkey};
1427                         $answer =~ s/<target>\S+<\/target>/<target>$host_name<\/target>/g;
1428                         my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1429                         &update_jobdb_status_for_send_msgs($answer, $error);
1430                     }
1431                 }
1432
1433                 # target of msg is GOsa
1434                                 elsif( $answer_target eq "GOSA" ) {
1435                                         my $session_id = ($1) if $answer =~ /<session_id>(\d+?)<\/session_id>/;
1436                                         my $add_on = "";
1437                     if( defined $session_id ) {
1438                         $add_on = ".session_id=$session_id";
1439                     }
1440                     # answer is for GOSA and has to returned to connected client
1441                     my $gosa_answer = &encrypt_msg($answer, $GosaPackages_key);
1442                     $client_answer = $gosa_answer.$add_on;
1443                 }
1444
1445                 # target of msg is job queue at this host
1446                 elsif( $answer_target eq "JOBDB") {
1447                     $answer =~ /<header>(\S+)<\/header>/;
1448                     my $header;
1449                     if( defined $1 ) { $header = $1; }
1450                     my $error = &send_msg_to_target($answer, $server_address, $GosaPackages_key, $header, $session_id);
1451                     &update_jobdb_status_for_send_msgs($answer, $error);
1452                 }
1453
1454                 # Target of msg is a mac address
1455                 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 ) {
1456                     daemon_log("$session_id INFO: target is mac address '$answer_target', looking for host in known_clients and foreign_clients", 5);
1457                     my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$answer_target'";
1458                     my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1459                     my $found_ip_flag = 0;
1460                     while( my ($hit_num, $hit) = each %{ $query_res } ) {
1461                         my $host_name = $hit->{hostname};
1462                         my $host_key = $hit->{hostkey};
1463                         $answer =~ s/$answer_target/$host_name/g;
1464                         daemon_log("$session_id INFO: found host '$host_name', associated to '$answer_target'", 5);
1465                         my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1466                         &update_jobdb_status_for_send_msgs($answer, $error);
1467                         $found_ip_flag++ ;
1468                     }
1469                     if ($found_ip_flag == 0) {
1470                         my $sql = "SELECT * FROM $foreign_clients_tn WHERE macaddress LIKE '$answer_target'";
1471                         my $res = $foreign_clients_db->select_dbentry($sql);
1472                         while( my ($hit_num, $hit) = each %{ $res } ) {
1473                             my $host_name = $hit->{hostname};
1474                             my $reg_server = $hit->{regserver};
1475                             daemon_log("$session_id INFO: found host '$host_name' with mac '$answer_target', registered at '$reg_server'", 5);
1476
1477                             # Fetch key for reg_server
1478                             my $reg_server_key;
1479                             my $sql = "SELECT * FROM $known_server_tn WHERE hostname='$reg_server'";
1480                             my $res = $known_server_db->select_dbentry($sql);
1481                             if (exists $res->{1}) {
1482                                 $reg_server_key = $res->{1}->{'hostkey'};
1483                             } else {
1484                                 daemon_log("$session_id ERROR: cannot find hostkey for '$host_name' in '$known_server_tn'", 1);
1485                                 daemon_log("$session_id ERROR: unable to forward answer to correct registration server, processing is aborted!", 1);
1486                                 $reg_server_key = undef;
1487                             }
1488
1489                             # Send answer to server where client is registered
1490                             if (defined $reg_server_key) {
1491                                 $answer =~ s/$answer_target/$host_name/g;
1492                                 my $error = &send_msg_to_target($answer, $reg_server, $reg_server_key, $answer_header, $session_id);
1493                                 &update_jobdb_status_for_send_msgs($answer, $error);
1494                                 $found_ip_flag++ ;
1495                             }
1496                         }
1497                     }
1498                     if( $found_ip_flag == 0) {
1499                         daemon_log("$session_id WARNING: no host found in known_clients or foreign_clients with mac address '$answer_target'", 3);
1500
1501                         # Sometimes the client is still booting or does not wake up, in this case reactivate the job (if it exists) with a delay of 30 sec
1502                         my $delay_timestamp = &calc_timestamp(&get_time(), "plus", 30);
1503                         my $sql = "UPDATE $job_queue_tn Set timestamp='$delay_timestamp', status='waiting' WHERE (macaddress='$answer_target' AND headertag='$answer_header')";
1504                         my $res = $job_db->update_dbentry($sql);
1505                         daemon_log("$session_id INFO: '$answer_header'-job will be reactivated at '$delay_timestamp' ".
1506                                 "cause client '$answer_target' is currently not available", 5);
1507                         daemon_log("$session_id $sql", 7);
1508                     }
1509
1510                 # Answer is for one specific host
1511                 } else {
1512                     # get encrypt_key
1513                     my $encrypt_key = &get_encrypt_key($answer_target);
1514                     if( not defined $encrypt_key ) {
1515                         # unknown target
1516                         daemon_log("$session_id WARNING: unknown target '$answer_target'", 3);
1517                         next;
1518                     }
1519                     my $error = &send_msg_to_target($answer, $answer_target, $encrypt_key, $answer_header,$session_id);
1520                     &update_jobdb_status_for_send_msgs($answer, $error);
1521                 }
1522             }
1523         }
1524     }
1525
1526     my $filter = POE::Filter::Reference->new();
1527     my %result = (
1528             status => "seems ok to me",
1529             answer => $client_answer,
1530             );
1531
1532     my $output = $filter->put( [ \%result ] );
1533     print @$output;
1534
1535
1536 }
1537
1538 sub session_start {
1539     my ($kernel) = $_[KERNEL];
1540     $global_kernel = $kernel;
1541     $kernel->yield('register_at_foreign_servers');
1542         $kernel->yield('create_fai_server_db', $fai_server_tn );
1543         $kernel->yield('create_fai_release_db', $fai_release_tn );
1544     $kernel->yield('watch_for_next_tasks');
1545         $kernel->sig(USR1 => "sig_handler");
1546         $kernel->sig(USR2 => "recreate_packages_db");
1547         $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
1548         $kernel->delay_set('watch_for_done_jobs', $job_queue_loop_delay);
1549     $kernel->delay_set('watch_for_modified_jobs', $modified_jobs_loop_delay);
1550         $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
1551     $kernel->delay_set('watch_for_delivery_messages', $messaging_db_loop_delay);
1552         $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
1553     $kernel->delay_set('watch_for_old_known_clients', $job_queue_loop_delay);
1554
1555     # Start opsi check
1556     if ($opsi_enabled eq "true") {
1557         $kernel->delay_set('watch_for_opsi_jobs', $job_queue_opsi_delay);
1558     }
1559
1560 }
1561
1562
1563 sub watch_for_done_jobs {
1564     #CHECK: $heap for what?
1565     my ($kernel,$heap) = @_[KERNEL, HEAP];
1566
1567     my $sql_statement = "SELECT * FROM ".$job_queue_tn." WHERE ((status='done') AND (modified='0'))";
1568         my $res = $job_db->select_dbentry( $sql_statement );
1569
1570     while( my ($id, $hit) = each %{$res} ) {
1571         my $jobdb_id = $hit->{id};
1572         my $sql_statement = "DELETE FROM $job_queue_tn WHERE id=$jobdb_id";
1573         my $res = $job_db->del_dbentry($sql_statement);
1574     }
1575
1576     $kernel->delay_set('watch_for_done_jobs',$job_queue_loop_delay);
1577 }
1578
1579
1580 sub watch_for_opsi_jobs {
1581     my ($kernel) = $_[KERNEL];
1582
1583     # This is not very nice to look for opsi install jobs, but headertag has to be trigger_action_reinstall. The only way to identify a
1584     # opsi install job is to parse the xml message. There is still the correct header.
1585     my $sql_statement = "SELECT * FROM ".$job_queue_tn." WHERE ((xmlmessage LIKE '%opsi_install_client</header>%') AND (status='processing') AND (siserver='localhost'))";
1586         my $res = $job_db->select_dbentry( $sql_statement );
1587
1588     # Ask OPSI for an update of the running jobs
1589     while (my ($id, $hit) = each %$res ) {
1590         # Determine current parameters of the job
1591         my $hostId = $hit->{'plainname'};
1592         my $macaddress = $hit->{'macaddress'};
1593         my $progress = $hit->{'progress'};
1594
1595         my $result= {};
1596
1597         # For hosts, only return the products that are or get installed
1598         my $callobj;
1599         $callobj = {
1600             method  => 'getProductStates_hash',
1601             params  => [ $hostId ],
1602             id  => 1,
1603         };
1604
1605         my $hres = $opsi_client->call($opsi_url, $callobj);
1606         #my ($hres_err, $hres_err_string) = &check_opsi_res($hres);
1607         if (not &check_opsi_res($hres)) {
1608             my $htmp= $hres->result->{$hostId};
1609
1610             # Check state != not_installed or action == setup -> load and add
1611             my $products= 0;
1612             my $installed= 0;
1613             my $installing = 0;
1614             my $error= 0;
1615             my @installed_list;
1616             my @error_list;
1617             my $act_status = "none";
1618             foreach my $product (@{$htmp}){
1619
1620                 if ($product->{'installationStatus'} ne "not_installed" or
1621                         $product->{'actionRequest'} eq "setup"){
1622
1623                     # Increase number of products for this host
1624                     $products++;
1625
1626                     if ($product->{'installationStatus'} eq "failed"){
1627                         $result->{$product->{'productId'}}= "error";
1628                         unshift(@error_list, $product->{'productId'});
1629                         $error++;
1630                     }
1631                     if ($product->{'installationStatus'} eq "installed" && $product->{'actionRequest'}  eq "none"){
1632                         $result->{$product->{'productId'}}= "installed";
1633                         unshift(@installed_list, $product->{'productId'});
1634                         $installed++;
1635                     }
1636                     if ($product->{'installationStatus'} eq "installing"){
1637                         $result->{$product->{'productId'}}= "installing";
1638                         $installing++;
1639                         $act_status = "installing - ".$product->{'productId'};
1640                     }
1641                 }
1642             }
1643
1644             # Estimate "rough" progress, avoid division by zero
1645             if ($products == 0) {
1646                 $result->{'progress'}= 0;
1647             } else {
1648                 $result->{'progress'}= int($installed * 100 / $products);
1649             }
1650
1651             # Set updates in job queue
1652             if ((not $error) && (not $installing) && ($installed)) {
1653                 $act_status = "installed - ".join(", ", @installed_list);
1654             }
1655             if ($error) {
1656                 $act_status = "error - ".join(", ", @error_list);
1657             }
1658             if ($progress ne $result->{'progress'} ) {
1659                 # Updating progress and result
1660                 my $update_statement = "UPDATE $job_queue_tn SET modified='1', progress='".$result->{'progress'}."', result='$act_status' WHERE macaddress='$macaddress' AND siserver='localhost'";
1661                 my $update_res = $job_db->update_dbentry($update_statement);
1662             }
1663             if ($progress eq 100) {
1664                 # Updateing status
1665                 my $done_statement = "UPDATE $job_queue_tn SET modified='1', ";
1666                 if ($error) {
1667                     $done_statement .= "status='error'";
1668                 } else {
1669                     $done_statement .= "status='done'";
1670                 }
1671                 $done_statement .= " WHERE macaddress='$macaddress' AND siserver='localhost'";
1672                 my $done_res = $job_db->update_dbentry($done_statement);
1673             }
1674
1675
1676         }
1677     }
1678
1679     $kernel->delay_set('watch_for_opsi_jobs', $job_queue_opsi_delay);
1680 }
1681
1682
1683 # If a job got an update or was modified anyway, send to all other si-server an update message of this jobs.
1684 sub watch_for_modified_jobs {
1685     my ($kernel,$heap) = @_[KERNEL, HEAP];
1686
1687     my $sql_statement = "SELECT * FROM $job_queue_tn WHERE ((siserver='localhost') AND (modified='1'))";
1688     my $res = $job_db->select_dbentry( $sql_statement );
1689
1690     # if db contains no jobs which should be update, do nothing
1691     if (keys %$res != 0) {
1692
1693         if ($job_synchronization  eq "true") {
1694             # make out of the db result a gosa-si message
1695             my $update_msg = &db_res2si_msg ($res, "foreign_job_updates", "KNOWN_SERVER", "MY_LOCAL_ADDRESS");
1696
1697             # update all other SI-server
1698             &inform_all_other_si_server($update_msg);
1699         }
1700
1701         # set jobs all jobs to modified = 0, wait until the next modification for updates of other si-server
1702         $sql_statement = "UPDATE $job_queue_tn SET modified='0' ";
1703         $res = $job_db->update_dbentry($sql_statement);
1704     }
1705
1706     $kernel->delay_set('watch_for_modified_jobs', $modified_jobs_loop_delay);
1707 }
1708
1709
1710 sub watch_for_new_jobs {
1711         if($watch_for_new_jobs_in_progress == 0) {
1712                 $watch_for_new_jobs_in_progress = 1;
1713                 my ($kernel,$heap) = @_[KERNEL, HEAP];
1714
1715                 # check gosa job quaeue for jobs with executable timestamp
1716                 my $timestamp = &get_time();
1717                 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE status='waiting' AND (CAST(timestamp AS UNSIGNED)) < $timestamp ORDER BY timestamp";
1718                 my $res = $job_db->exec_statement( $sql_statement );
1719
1720                 # Merge all new jobs that would do the same actions
1721                 my @drops;
1722                 my $hits;
1723                 foreach my $hit (reverse @{$res} ) {
1724                         my $macaddress= lc @{$hit}[8];
1725                         my $headertag= @{$hit}[5];
1726                         if(
1727                                 defined($hits->{$macaddress}) &&
1728                                 defined($hits->{$macaddress}->{$headertag}) &&
1729                                 defined($hits->{$macaddress}->{$headertag}[0])
1730                         ) {
1731                                 push @drops, "DELETE FROM $job_queue_tn WHERE id = $hits->{$macaddress}->{$headertag}[0]";
1732                         }
1733                         $hits->{$macaddress}->{$headertag}= $hit;
1734                 }
1735
1736                 # Delete new jobs with a matching job in state 'processing'
1737                 foreach my $macaddress (keys %{$hits}) {
1738                         foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
1739                                 my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
1740                                 if(defined($jobdb_id)) {
1741                                         my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND headertag='$jobdb_headertag' AND status='processing'";
1742                                         my $res = $job_db->exec_statement( $sql_statement );
1743                                         foreach my $hit (@{$res}) {
1744                                                 push @drops, "DELETE FROM $job_queue_tn WHERE id=$jobdb_id";
1745                                         }
1746                                 } else {
1747                                         daemon_log("J ERROR: Job without id exists for macaddress $macaddress!", 1);
1748                                 }
1749                         }
1750                 }
1751
1752                 # Commit deletion
1753                 $job_db->exec_statementlist(\@drops);
1754
1755                 # Look for new jobs that could be executed
1756                 foreach my $macaddress (keys %{$hits}) {
1757
1758                         # Look if there is an executing job
1759                         my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND status='processing'";
1760                         my $res = $job_db->exec_statement( $sql_statement );
1761
1762                         # Skip new jobs for host if there is a processing job
1763                         if(defined($res) and defined @{$res}[0]) {
1764                                 # Prevent race condition if there is a trigger_activate job waiting and a goto-activation job processing
1765                                 my $row = @{$res}[0] if (ref $res eq 'ARRAY');
1766                                 if(@{$row}[5] eq 'trigger_action_reinstall') {
1767                                         my $sql_statement_2 =  "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND status='waiting' AND headertag = 'trigger_activate_new'";
1768                                         my $res_2 = $job_db->exec_statement( $sql_statement_2 );
1769                                         if(defined($res_2) and defined @{$res_2}[0]) {
1770                                                 # Set status from goto-activation to 'waiting' and update timestamp
1771                                                 $job_db->exec_statement("UPDATE $job_queue_tn SET status='waiting' WHERE macaddress LIKE '$macaddress' AND headertag = 'trigger_action_reinstall'");
1772                                                 $job_db->exec_statement("UPDATE $job_queue_tn SET timestamp='".&get_time(30)."' WHERE macaddress LIKE '$macaddress' AND headertag = 'trigger_action_reinstall'");
1773                                         }
1774                                 }
1775                                 next;
1776                         }
1777
1778                         foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
1779                                 my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
1780                                 if(defined($jobdb_id)) {
1781                                         my $job_msg = @{$hits->{$macaddress}->{$jobdb_headertag}}[7];
1782
1783                                         daemon_log("J DEBUG: its time to execute $job_msg", 7);
1784                                         my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$macaddress'";
1785                                         my $res_hash = $known_clients_db->select_dbentry( $sql_statement );
1786
1787                                         # expect macaddress is unique!!!!!!
1788                                         my $target = $res_hash->{1}->{hostname};
1789
1790                                         # change header
1791                                         $job_msg =~ s/<header>job_/<header>gosa_/;
1792
1793                                         # add sqlite_id
1794                                         $job_msg =~ s/<\/xml>$/<jobdb_id>$jobdb_id<\/jobdb_id><\/xml>/;
1795
1796                                         $job_msg =~ /<header>(\S+)<\/header>/;
1797                                         my $header = $1 ;
1798                                         my $func_error = &send_msg_to_target($job_msg, $server_address, $GosaPackages_key, $header, "J");
1799
1800                                         # update status in job queue to 'processing'
1801                                         $sql_statement = "UPDATE $job_queue_tn SET status='processing' WHERE id=$jobdb_id";
1802                                         my $res = $job_db->update_dbentry($sql_statement);
1803 # TODO: abfangen ob alles in ordnung ist oder nicht, wenn nicht error schmeißen
1804
1805                                         # We don't want parallel processing
1806                                         last;
1807                                 }
1808                         }
1809                 }
1810
1811                 $watch_for_new_jobs_in_progress = 0;
1812                 $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
1813         }
1814 }
1815
1816
1817 sub watch_for_new_messages {
1818     my ($kernel,$heap) = @_[KERNEL, HEAP];
1819     my @coll_user_msg;   # collection list of outgoing messages
1820
1821     # check messaging_db for new incoming messages with executable timestamp
1822     my $timestamp = &get_time();
1823     my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( (CAST(timestamp AS UNSIGNED))<$timestamp AND flag='n' AND direction='in' )";
1824     my $res = $messaging_db->exec_statement( $sql_statement );
1825         foreach my $hit (@{$res}) {
1826
1827         # create outgoing messages
1828         my $message_to = @{$hit}[3];
1829         # translate message_to to plain login name
1830         my @message_to_l = split(/,/, $message_to);
1831                 my %receiver_h;
1832                 foreach my $receiver (@message_to_l) {
1833                         if ($receiver =~ /^u_([\s\S]*)$/) {
1834                                 $receiver_h{$1} = 0;
1835                         } elsif ($receiver =~ /^g_([\s\S]*)$/) {
1836                                 my $group_name = $1;
1837                                 # fetch all group members from ldap and add them to receiver hash
1838                                 my $ldap_handle = &get_ldap_handle();
1839                                 if (defined $ldap_handle) {
1840                                                 my $mesg = $ldap_handle->search(
1841                                                                                 base => $ldap_base,
1842                                                                                 scope => 'sub',
1843                                                                                 attrs => ['memberUid'],
1844                                                                                 filter => "cn=$group_name",
1845                                                                                 );
1846                                                 if ($mesg->count) {
1847                                                                 my @entries = $mesg->entries;
1848                                                                 foreach my $entry (@entries) {
1849                                                                                 my @receivers= $entry->get_value("memberUid");
1850                                                                                 foreach my $receiver (@receivers) {
1851                                                                                                 $receiver_h{$1} = 0;
1852                                                                                 }
1853                                                                 }
1854                                                 }
1855                                                 # translating errors ?
1856                                                 if ($mesg->code) {
1857                                                                 daemon_log("M ERROR: unable to translate group '$group_name' to user list for message delivery: $mesg->error", 1);
1858                                                 }
1859                                 # ldap handle error ?
1860                                 } else {
1861                                         daemon_log("M ERROR: unable to translate group '$group_name' to user list for message delivery: no ldap handle available", 1);
1862                                 }
1863                         } else {
1864                                 my $sbjct = &encode_base64(@{$hit}[1]);
1865                                 my $msg = &encode_base64(@{$hit}[7]);
1866                                 &daemon_log("M WARNING: unknown receiver '$receiver' for a user-message '$sbjct - $msg'", 3);
1867                         }
1868                 }
1869                 my @receiver_l = keys(%receiver_h);
1870
1871         my $message_id = @{$hit}[0];
1872
1873         #add each outgoing msg to messaging_db
1874         my $receiver;
1875         foreach $receiver (@receiver_l) {
1876             my $sql_statement = "INSERT INTO $messaging_tn (id, subject, message_from, message_to, flag, direction, delivery_time, message, timestamp) ".
1877                 "VALUES ('".
1878                 $message_id."', '".    # id
1879                 @{$hit}[1]."', '".     # subject
1880                 @{$hit}[2]."', '".     # message_from
1881                 $receiver."', '".      # message_to
1882                 "none"."', '".         # flag
1883                 "out"."', '".          # direction
1884                 @{$hit}[6]."', '".     # delivery_time
1885                 @{$hit}[7]."', '".     # message
1886                 $timestamp."'".     # timestamp
1887                 ")";
1888             &daemon_log("M DEBUG: $sql_statement", 1);
1889             my $res = $messaging_db->exec_statement($sql_statement);
1890             &daemon_log("M INFO: message '".@{$hit}[0]."' is prepared for delivery to receiver '$receiver'", 5);
1891         }
1892
1893         # set incoming message to flag d=deliverd
1894         $sql_statement = "UPDATE $messaging_tn SET flag='p' WHERE id='$message_id'";
1895         &daemon_log("M DEBUG: $sql_statement", 7);
1896         $res = $messaging_db->update_dbentry($sql_statement);
1897         &daemon_log("M INFO: message '$message_id' is set to flag 'p' (processed)", 5);
1898     }
1899
1900     $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
1901     return;
1902 }
1903
1904 sub watch_for_delivery_messages {
1905     my ($kernel, $heap) = @_[KERNEL, HEAP];
1906
1907     # select outgoing messages
1908     my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( flag='p' AND direction='out' )";
1909     #&daemon_log("0 DEBUG: $sql", 7);
1910     my $res = $messaging_db->exec_statement( $sql_statement );
1911
1912     # build out msg for each    usr
1913     foreach my $hit (@{$res}) {
1914         my $receiver = @{$hit}[3];
1915         my $msg_id = @{$hit}[0];
1916         my $subject = @{$hit}[1];
1917         my $message = @{$hit}[7];
1918
1919         # resolve usr -> host where usr is logged in
1920         my $sql = "SELECT * FROM $login_users_tn WHERE (user='$receiver')";
1921         #&daemon_log("0 DEBUG: $sql", 7);
1922         my $res = $login_users_db->exec_statement($sql);
1923
1924         # reciver is logged in nowhere
1925         if (not ref(@$res[0]) eq "ARRAY") { next; }
1926
1927                 my $send_succeed = 0;
1928                 foreach my $hit (@$res) {
1929                                 my $receiver_host = @$hit[0];
1930                 my $delivered2host = 0;
1931                                 &daemon_log("M DEBUG: user '$receiver' is logged in at host '$receiver_host'", 7);
1932
1933                                 # Looking for host in know_clients_db
1934                                 my $sql = "SELECT * FROM $known_clients_tn WHERE (hostname='$receiver_host')";
1935                                 my $res = $known_clients_db->exec_statement($sql);
1936
1937                 # Host is known in known_clients_db
1938                 if (ref(@$res[0]) eq "ARRAY") {
1939                     my $receiver_key = @{@{$res}[0]}[2];
1940                     my %data = ('subject' => $subject, 'message' => $message, 'usr' => $receiver);
1941                     my $out_msg = &build_msg("usr_msg", $server_address, $receiver_host, \%data );
1942                     my $error = &send_msg_to_target($out_msg, $receiver_host, $receiver_key, "usr_msg", 0);
1943                     if ($error == 0 ) {
1944                         $send_succeed++ ;
1945                         $delivered2host++ ;
1946                         &daemon_log("M DEBUG: send message for user '$receiver' to host '$receiver_host'", 7);
1947                     } else {
1948                         &daemon_log("M DEBUG: cannot send message for user '$receiver' to host '$receiver_host'", 7);
1949                     }
1950                 }
1951
1952                 # Message already send, do not need to do anything more, otherwise ...
1953                 if ($delivered2host) { next;}
1954
1955                 # ...looking for host in foreign_clients_db
1956                 $sql = "SELECT * FROM $foreign_clients_tn WHERE (hostname='$receiver_host')";
1957                 $res = $foreign_clients_db->exec_statement($sql);
1958
1959                                 # Host is known in foreign_clients_db
1960                                 if (ref(@$res[0]) eq "ARRAY") {
1961                     my $registration_server = @{@{$res}[0]}[2];
1962
1963                     # Fetch encryption key for registration server
1964                     my $sql = "SELECT * FROM $known_server_tn WHERE (hostname='$registration_server')";
1965                     my $res = $known_server_db->exec_statement($sql);
1966                     if (ref(@$res[0]) eq "ARRAY") {
1967                         my $registration_server_key = @{@{$res}[0]}[3];
1968                         my %data = ('subject' => $subject, 'message' => $message, 'usr' => $receiver);
1969                         my $out_msg = &build_msg("usr_msg", $server_address, $receiver_host, \%data );
1970                         my $error = &send_msg_to_target($out_msg, $registration_server, $registration_server_key, "usr_msg", 0);
1971                         if ($error == 0 ) {
1972                             $send_succeed++ ;
1973                             $delivered2host++ ;
1974                             &daemon_log("M DEBUG: send message for user '$receiver' to server '$registration_server'", 7);
1975                         } else {
1976                             &daemon_log("M ERROR: cannot send message for user '$receiver' to server '$registration_server'", 1);
1977                         }
1978
1979                     } else {
1980                         &daemon_log("M ERROR: host '$receiver_host' is reported to be ".
1981                                 "registrated at server '$registration_server', ".
1982                                 "but no data available in known_server_db ", 1);
1983                     }
1984                 }
1985
1986                 if (not $delivered2host) {
1987                     &daemon_log("M ERROR: unable to send user message to host '$receiver_host'", 1);
1988                 }
1989                 }
1990
1991                 if ($send_succeed) {
1992                                 # set outgoing msg at db to deliverd
1993                                 my $sql = "UPDATE $messaging_tn SET flag='d' WHERE (id='$msg_id' AND direction='out' AND message_to='$receiver')";
1994                                 my $res = $messaging_db->exec_statement($sql);
1995                 &daemon_log("M INFO: send message for user '$receiver' to logged in hosts", 5);
1996                 } else {
1997             &daemon_log("M WARNING: failed to deliver message for user '$receiver'", 3);
1998         }
1999         }
2000
2001     $kernel->delay_set('watch_for_delivery_messages', $messaging_db_loop_delay);
2002     return;
2003 }
2004
2005
2006 sub watch_for_done_messages {
2007     my ($kernel,$heap) = @_[KERNEL, HEAP];
2008
2009     my $sql = "SELECT * FROM $messaging_tn WHERE (flag='p' AND direction='in')";
2010     #&daemon_log("0 DEBUG: $sql", 7);
2011     my $res = $messaging_db->exec_statement($sql);
2012
2013     foreach my $hit (@{$res}) {
2014         my $msg_id = @{$hit}[0];
2015
2016         my $sql = "SELECT * FROM $messaging_tn WHERE (id='$msg_id' AND direction='out' AND (NOT flag='s'))";
2017         #&daemon_log("0 DEBUG: $sql", 7);
2018         my $res = $messaging_db->exec_statement($sql);
2019
2020         # not all usr msgs have been seen till now
2021         if ( ref(@$res[0]) eq "ARRAY") { next; }
2022
2023         $sql = "DELETE FROM $messaging_tn WHERE (id='$msg_id')";
2024         #&daemon_log("0 DEBUG: $sql", 7);
2025         $res = $messaging_db->exec_statement($sql);
2026
2027     }
2028
2029     $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
2030     return;
2031 }
2032
2033
2034 sub watch_for_old_known_clients {
2035     my ($kernel,$heap) = @_[KERNEL, HEAP];
2036
2037     my $sql_statement = "SELECT * FROM $known_clients_tn";
2038     my $res = $known_clients_db->select_dbentry( $sql_statement );
2039
2040     my $act_time = int(&get_time());
2041
2042     while ( my ($hit_num, $hit) = each %$res) {
2043         my $expired_timestamp = int($hit->{'timestamp'});
2044         $expired_timestamp =~ /(\d{4})(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)/;
2045         my $dt = DateTime->new( year   => $1,
2046                 month  => $2,
2047                 day    => $3,
2048                 hour   => $4,
2049                 minute => $5,
2050                 second => $6,
2051                 );
2052
2053         $dt->add( seconds => 2 * int($hit->{'keylifetime'}) );
2054         $expired_timestamp = $dt->ymd('').$dt->hms('');
2055         if ($act_time > $expired_timestamp) {
2056             my $hostname = $hit->{'hostname'};
2057             my $del_sql = "DELETE FROM $known_clients_tn WHERE hostname='$hostname'";
2058             my $del_res = $known_clients_db->exec_statement($del_sql);
2059
2060             &main::daemon_log("0 INFO: timestamp '".$hit->{'timestamp'}."' of client '$hostname' is expired('$expired_timestamp'), client will be deleted from known_clients_db", 5);
2061         }
2062
2063     }
2064
2065     $kernel->delay_set('watch_for_old_known_clients', $job_queue_loop_delay);
2066 }
2067
2068
2069 sub watch_for_next_tasks {
2070     my ($kernel,$heap) = @_[KERNEL, HEAP];
2071
2072     my $sql = "SELECT * FROM $incoming_tn";
2073     my $res = $incoming_db->select_dbentry($sql);
2074
2075     while ( my ($hit_num, $hit) = each %$res) {
2076         my $headertag = $hit->{'headertag'};
2077         if ($headertag =~ /^answer_(\d+)/) {
2078             # do not start processing, this message is for a still running POE::Wheel
2079             next;
2080         }
2081         my $message_id = $hit->{'id'};
2082         my $session_id = $hit->{'sessionid'};
2083         &daemon_log("$session_id DEBUG: start processing for message with incoming id: '$message_id'", 7);
2084         $kernel->yield('next_task', $hit);
2085
2086         my $sql = "DELETE FROM $incoming_tn WHERE id=$message_id";
2087         my $res = $incoming_db->exec_statement($sql);
2088     }
2089
2090     $kernel->delay_set('watch_for_next_tasks', 1);
2091 }
2092
2093
2094 sub get_ldap_handle {
2095         my ($session_id) = @_;
2096         my $heap;
2097         my $ldap_handle;
2098
2099         if (not defined $session_id ) { $session_id = 0 };
2100         if ($session_id =~ /[^0-9]*/) { $session_id = 0 };
2101
2102         if ($session_id == 0) {
2103                 daemon_log("$session_id DEBUG: get_ldap_handle invoked without a session_id, create a new ldap_handle", 7);
2104                 $ldap_handle = Net::LDAP->new( $ldap_uri );
2105                 if (defined $ldap_handle) {
2106                         $ldap_handle->bind($ldap_admin_dn, password => $ldap_admin_password) or daemon_log("$session_id ERROR: Bind to LDAP $ldap_uri as $ldap_admin_dn failed!");
2107                 } else {
2108                         daemon_log("$session_id ERROR: creation of a new LDAP handle failed (ldap_uri '$ldap_uri')");
2109                 }
2110
2111         } else {
2112                 my $session_reference = $global_kernel->ID_id_to_session($session_id);
2113                 if( defined $session_reference ) {
2114                         $heap = $session_reference->get_heap();
2115                 }
2116
2117                 if (not defined $heap) {
2118                         daemon_log("$session_id DEBUG: cannot get heap for session_id '$session_id'", 7);
2119                         return;
2120                 }
2121
2122                 # TODO: This "if" is nonsense, because it doesn't prove that the
2123                 #       used handle is still valid - or if we've to reconnect...
2124                 #if (not exists $heap->{ldap_handle}) {
2125                         $ldap_handle = Net::LDAP->new( $ldap_uri );
2126                         $ldap_handle->bind($ldap_admin_dn, password => $ldap_admin_password) or daemon_log("$session_id ERROR: Bind to LDAP $ldap_uri as $ldap_admin_dn failed!");
2127                         $heap->{ldap_handle} = $ldap_handle;
2128                 #}
2129         }
2130         return $ldap_handle;
2131 }
2132
2133
2134 sub change_fai_state {
2135     my ($st, $targets, $session_id) = @_;
2136     $session_id = 0 if not defined $session_id;
2137     # Set FAI state to localboot
2138     my %mapActions= (
2139         reboot    => '',
2140         update    => 'softupdate',
2141         localboot => 'localboot',
2142         reinstall => 'install',
2143         rescan    => '',
2144         wake      => '',
2145         memcheck  => 'memcheck',
2146         sysinfo   => 'sysinfo',
2147         install   => 'install',
2148     );
2149
2150     # Return if this is unknown
2151     if (!exists $mapActions{ $st }){
2152         daemon_log("$session_id ERROR: unknown action '$st', can not translate ot FAIstate", 1);
2153       return;
2154     }
2155
2156     my $state= $mapActions{ $st };
2157
2158     my $ldap_handle = &get_ldap_handle($session_id);
2159     if( defined($ldap_handle) ) {
2160
2161       # Build search filter for hosts
2162         my $search= "(&(objectClass=GOhard)";
2163         foreach (@{$targets}){
2164             $search.= "(macAddress=$_)";
2165         }
2166         $search.= ")";
2167
2168       # If there's any host inside of the search string, procress them
2169         if (!($search =~ /macAddress/)){
2170             daemon_log("$session_id ERROR: no macAddress found in filter statement for LDAP search: '$search'", 1);
2171             return;
2172         }
2173
2174       # Perform search for Unit Tag
2175       my $mesg = $ldap_handle->search(
2176           base   => $ldap_base,
2177           scope  => 'sub',
2178           attrs  => ['dn', 'FAIstate', 'objectClass'],
2179           filter => "$search"
2180           );
2181
2182           if ($mesg->count) {
2183                   my @entries = $mesg->entries;
2184                   if (0 == @entries) {
2185                                   daemon_log("$session_id ERROR: ldap search failed: ldap_base=$ldap_base, filter=$search", 1);
2186                   }
2187
2188                   foreach my $entry (@entries) {
2189                           # Only modify entry if it is not set to '$state'
2190                           if ($entry->get_value("FAIstate") ne "$state"){
2191                                   daemon_log("$session_id INFO: Setting FAIstate to '$state' for ".$entry->dn, 5);
2192                                   my $result;
2193                                   my %tmp = map { $_ => 1 } $entry->get_value("objectClass");
2194                                   if (exists $tmp{'FAIobject'}){
2195                                           if ($state eq ''){
2196                                                   $result= $ldap_handle->modify($entry->dn, changes => [
2197                                                           delete => [ FAIstate => [] ] ]);
2198                                           } else {
2199                                                   $result= $ldap_handle->modify($entry->dn, changes => [
2200                                                           replace => [ FAIstate => $state ] ]);
2201                                           }
2202                                   } elsif ($state ne ''){
2203                                           $result= $ldap_handle->modify($entry->dn, changes => [
2204                                                   add     => [ objectClass => 'FAIobject' ],
2205                                                   add     => [ FAIstate => $state ] ]);
2206                                   }
2207
2208                                   # Errors?
2209                                   if ($result->code){
2210                                           daemon_log("$session_id Error: Setting FAIstate to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
2211                                   }
2212                           } else {
2213                                   daemon_log("$session_id DEBUG FAIstate at host '".$entry->dn."' already at state '$st'", 7);
2214                           }
2215                   }
2216           } else {
2217                 daemon_log("$session_id ERROR: LDAP search failed: ldap_base=$ldap_base, filter=$search", 1);
2218           }
2219
2220     # if no ldap handle defined
2221     } else {
2222         daemon_log("$session_id ERROR: no LDAP handle defined for update FAIstate", 1);
2223     }
2224
2225         return;
2226 }
2227
2228
2229 sub change_goto_state {
2230     my ($st, $targets, $session_id) = @_;
2231     $session_id = 0  if not defined $session_id;
2232
2233     # Switch on or off?
2234     my $state= $st eq 'active' ? 'active': 'locked';
2235
2236     my $ldap_handle = &get_ldap_handle($session_id);
2237     if( defined($ldap_handle) ) {
2238
2239       # Build search filter for hosts
2240       my $search= "(&(objectClass=GOhard)";
2241       foreach (@{$targets}){
2242         $search.= "(macAddress=$_)";
2243       }
2244       $search.= ")";
2245
2246       # If there's any host inside of the search string, procress them
2247       if (!($search =~ /macAddress/)){
2248         return;
2249       }
2250
2251       # Perform search for Unit Tag
2252       my $mesg = $ldap_handle->search(
2253           base   => $ldap_base,
2254           scope  => 'sub',
2255           attrs  => ['dn', 'gotoMode'],
2256           filter => "$search"
2257           );
2258
2259       if ($mesg->count) {
2260         my @entries = $mesg->entries;
2261         foreach my $entry (@entries) {
2262
2263           # Only modify entry if it is not set to '$state'
2264           if ($entry->get_value("gotoMode") ne $state){
2265
2266             daemon_log("$session_id INFO: Setting gotoMode to '$state' for ".$entry->dn, 5);
2267             my $result;
2268             $result= $ldap_handle->modify($entry->dn, changes => [
2269                                                 replace => [ gotoMode => $state ] ]);
2270
2271             # Errors?
2272             if ($result->code){
2273               &daemon_log("$session_id Error: Setting gotoMode to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
2274             }
2275
2276           }
2277         }
2278       } else {
2279                 daemon_log("$session_id ERROR: LDAP search failed in function change_goto_state: ldap_base=$ldap_base, filter=$search", 1);
2280           }
2281
2282     }
2283 }
2284
2285
2286 sub run_recreate_packages_db {
2287     my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];
2288     my $session_id = $session->ID;
2289         &main::daemon_log("$session_id INFO: Recreating FAI Packages DB ('$fai_release_tn', '$fai_server_tn', '$packages_list_tn')", 5);
2290         $kernel->yield('create_fai_release_db', $fai_release_tn);
2291         $kernel->yield('create_fai_server_db', $fai_server_tn);
2292         return;
2293 }
2294
2295
2296 sub run_create_fai_server_db {
2297     my ($kernel, $session, $heap, $table_name) = @_[KERNEL, SESSION, HEAP, ARG0];
2298     my $session_id = $session->ID;
2299     my $task = POE::Wheel::Run->new(
2300             Program => sub { &create_fai_server_db($table_name,$kernel, undef, $session_id) },
2301             StdoutEvent  => "session_run_result",
2302             StderrEvent  => "session_run_debug",
2303             CloseEvent   => "session_run_done",
2304             );
2305
2306     $heap->{task}->{ $task->ID } = $task;
2307     return;
2308 }
2309
2310
2311 sub create_fai_server_db {
2312         my ($table_name, $kernel, $dont_create_packages_list, $session_id) = @_;
2313         my $result;
2314
2315         if (not defined $session_id) { $session_id = 0; }
2316         my $ldap_handle = &get_ldap_handle();
2317         if(defined($ldap_handle)) {
2318                 daemon_log("$session_id INFO: create_fai_server_db: start", 5);
2319                 my $mesg= $ldap_handle->search(
2320                         base   => $ldap_base,
2321                         scope  => 'sub',
2322                         attrs  => ['FAIrepository', 'gosaUnitTag'],
2323                         filter => "(&(FAIrepository=*)(objectClass=FAIrepositoryServer))",
2324                 );
2325                 if($mesg->{'resultCode'} == 0 &&
2326                         $mesg->count != 0) {
2327                         foreach my $entry (@{$mesg->{entries}}) {
2328                                 if($entry->exists('FAIrepository')) {
2329                                         # Add an entry for each Repository configured for server
2330                                         foreach my $repo(@{$entry->get_value('FAIrepository', asref => 1)}) {
2331                                                 my($tmp_url,$tmp_server,$tmp_release,$tmp_sections) = split(/\|/, $repo);
2332                                                 my $tmp_tag= $entry->get_value('gosaUnitTag') || "";
2333                                                 $result= $fai_server_db->add_dbentry( {
2334                                                                 table => $table_name,
2335                                                                 primkey => ['server', 'fai_release', 'tag'],
2336                                                                 server => $tmp_url,
2337                                                                 fai_release => $tmp_release,
2338                                                                 sections => $tmp_sections,
2339                                                                 tag => (length($tmp_tag)>0)?$tmp_tag:"",
2340                                                         } );
2341                                         }
2342                                 }
2343                         }
2344                 }
2345                 daemon_log("$session_id INFO: create_fai_server_db: finished", 5);
2346
2347                 # TODO: Find a way to post the 'create_packages_list_db' event
2348                 if(not defined($dont_create_packages_list)) {
2349                         &create_packages_list_db(undef, undef, $session_id);
2350                 }
2351         }
2352
2353         $ldap_handle->disconnect;
2354         return $result;
2355 }
2356
2357
2358 sub run_create_fai_release_db {
2359         my ($session, $heap, $table_name) = @_[SESSION, HEAP, ARG0];
2360         my $session_id = $session->ID;
2361         my $task = POE::Wheel::Run->new(
2362                 Program => sub { &create_fai_release_db($table_name, $session_id) },
2363                 StdoutEvent  => "session_run_result",
2364                 StderrEvent  => "session_run_debug",
2365                 CloseEvent   => "session_run_done",
2366         );
2367
2368         $heap->{task}->{ $task->ID } = $task;
2369         return;
2370 }
2371
2372
2373 sub create_fai_release_db {
2374         my ($table_name, $session_id) = @_;
2375         my $result;
2376
2377         # used for logging
2378         if (not defined $session_id) { $session_id = 0; }
2379
2380         my $ldap_handle = &get_ldap_handle();
2381         if(defined($ldap_handle)) {
2382                 daemon_log("$session_id INFO: create_fai_release_db: start",5);
2383                 my $mesg= $ldap_handle->search(
2384                         base   => $ldap_base,
2385                         scope  => 'sub',
2386                         attrs  => [],
2387                         filter => "(&(objectClass=organizationalUnit)(ou=fai))",
2388                 );
2389                 if($mesg->{'resultCode'} == 0 &&
2390                         $mesg->count != 0) {
2391                         # Walk through all possible FAI container ou's
2392                         my @sql_list;
2393                         my $timestamp= &get_time();
2394                         foreach my $ou (@{$mesg->{entries}}) {
2395                                 my $tmp_classes= resolve_fai_classes($ou->dn, $ldap_handle, $session_id);
2396                                 if(defined($tmp_classes) && ref($tmp_classes) eq 'HASH') {
2397                                         my @tmp_array=get_fai_release_entries($tmp_classes);
2398                                         if(@tmp_array) {
2399                                                 foreach my $entry (@tmp_array) {
2400                                                         if(defined($entry) && ref($entry) eq 'HASH') {
2401                                                                 my $sql=
2402                                                                 "INSERT INTO $table_name "
2403                                                                 ."(timestamp, fai_release, class, type, state) VALUES ("
2404                                                                 .$timestamp.","
2405                                                                 ."'".$entry->{'release'}."',"
2406                                                                 ."'".$entry->{'class'}."',"
2407                                                                 ."'".$entry->{'type'}."',"
2408                                                                 ."'".$entry->{'state'}."')";
2409                                                                 push @sql_list, $sql;
2410                                                         }
2411                                                 }
2412                                         }
2413                                 }
2414                         }
2415
2416                         daemon_log("$session_id DEBUG: Inserting ".scalar @sql_list." entries to DB",8);
2417                         if(@sql_list) {
2418                                 unshift @sql_list, "DELETE FROM $table_name";
2419                                 $fai_release_db->exec_statementlist(\@sql_list);
2420                         }
2421                         daemon_log("$session_id DEBUG: Done with inserting",7);
2422                 }
2423                 daemon_log("$session_id INFO: create_fai_release_db: finished",5);
2424         }
2425         $ldap_handle->disconnect;
2426         return $result;
2427 }
2428
2429 sub get_fai_types {
2430         my $tmp_classes = shift || return undef;
2431         my @result;
2432
2433         foreach my $type(keys %{$tmp_classes}) {
2434                 if(defined($tmp_classes->{$type}[0]) && (!($tmp_classes->{$type}[0] =~ /^.*?removed.*?$/))) {
2435                         my $entry = {
2436                                 type => $type,
2437                                 state => $tmp_classes->{$type}[0],
2438                         };
2439                         push @result, $entry;
2440                 }
2441         }
2442
2443         return @result;
2444 }
2445
2446 sub get_fai_state {
2447         my $result = "";
2448         my $tmp_classes = shift || return $result;
2449
2450         foreach my $type(keys %{$tmp_classes}) {
2451                 if(defined($tmp_classes->{$type}[0])) {
2452                         $result = $tmp_classes->{$type}[0];
2453
2454                 # State is equal for all types in class
2455                         last;
2456                 }
2457         }
2458
2459         return $result;
2460 }
2461
2462 sub resolve_fai_classes {
2463         my ($fai_base, $ldap_handle, $session_id) = @_;
2464         if (not defined $session_id) { $session_id = 0; }
2465         my $result;
2466         my @possible_fai_classes= ("FAIscript", "FAIhook", "FAIpartitionTable", "FAItemplate", "FAIvariable", "FAIprofile", "FAIpackageList");
2467         my $fai_filter= "(|(&(objectClass=FAIclass)(|(objectClass=".join(")(objectClass=", @possible_fai_classes).")))(objectClass=FAIbranch))";
2468         my $fai_classes;
2469
2470         daemon_log("$session_id DEBUG: Searching for FAI entries in base $fai_base",7);
2471         my $mesg= $ldap_handle->search(
2472                 base   => $fai_base,
2473                 scope  => 'sub',
2474                 attrs  => ['cn','objectClass','FAIstate'],
2475                 filter => $fai_filter,
2476         );
2477         daemon_log("$session_id DEBUG: Found ".$mesg->count()." FAI entries",7);
2478
2479         if($mesg->{'resultCode'} == 0 &&
2480                 $mesg->count != 0) {
2481                 foreach my $entry (@{$mesg->{entries}}) {
2482                         if($entry->exists('cn')) {
2483                                 my $tmp_dn= $entry->dn();
2484
2485                                 # Skip classname and ou dn parts for class
2486                                 my $tmp_release = ($1) if $tmp_dn =~ /^[^,]+,[^,]+,(.*?),$fai_base$/;
2487
2488                                 # Skip classes without releases
2489                                 if((!defined($tmp_release)) || length($tmp_release)==0) {
2490                                         next;
2491                                 }
2492
2493                                 my $tmp_cn= $entry->get_value('cn');
2494                                 my $tmp_state= $entry->get_value('FAIstate');
2495
2496                                 my $tmp_type;
2497                                 # Get FAI type
2498                                 for my $oclass(@{$entry->get_value('objectClass', asref => 1)}) {
2499                                         if(grep $_ eq $oclass, @possible_fai_classes) {
2500                                                 $tmp_type= $oclass;
2501                                                 last;
2502                                         }
2503                                 }
2504
2505                                 if($tmp_release =~ /^.*?,.*?$/ && (!($tmp_release =~ /^.*?\\,.*?$/))) {
2506                                         # A Subrelease
2507                                         my @sub_releases = split(/,/, $tmp_release);
2508
2509                                         # Walk through subreleases and build hash tree
2510                                         my $hash;
2511                                         while(my $tmp_sub_release = pop @sub_releases) {
2512                                                 $hash .= "\{'$tmp_sub_release'\}->";
2513                                         }
2514                                         eval('push @{$fai_classes->'.$hash.'{$tmp_cn}->{$tmp_type}}, (defined($tmp_state) && length($tmp_state)>0)?$tmp_state:"";');
2515                                 } else {
2516                                         # A branch, no subrelease
2517                                         push @{$fai_classes->{$tmp_release}->{$tmp_cn}->{$tmp_type}}, (defined($tmp_state) && length($tmp_state)>0)?$tmp_state:"";
2518                                 }
2519                         } elsif (!$entry->exists('cn')) {
2520                                 my $tmp_dn= $entry->dn();
2521                                 my $tmp_release = ($1) if $tmp_dn =~ /^(.*?),$fai_base$/;
2522
2523                                 # Skip classes without releases
2524                                 if((!defined($tmp_release)) || length($tmp_release)==0) {
2525                                         next;
2526                                 }
2527
2528                                 if($tmp_release =~ /^.*?,.*?$/ && (!($tmp_release =~ /^.*?\\,.*?$/))) {
2529                                         # A Subrelease
2530                                         my @sub_releases= split(/,/, $tmp_release);
2531
2532                                         # Walk through subreleases and build hash tree
2533                                         my $hash;
2534                                         while(my $tmp_sub_release = pop @sub_releases) {
2535                                                 $hash .= "\{'$tmp_sub_release'\}->";
2536                                         }
2537                                         # Remove the last two characters
2538                                         chop($hash);
2539                                         chop($hash);
2540
2541                                         eval('$fai_classes->'.$hash.'= {}');
2542                                 } else {
2543                                         # A branch, no subrelease
2544                                         if(!exists($fai_classes->{$tmp_release})) {
2545                                                 $fai_classes->{$tmp_release} = {};
2546                                         }
2547                                 }
2548                         }
2549                 }
2550
2551                 # The hash is complete, now we can honor the copy-on-write based missing entries
2552                 foreach my $release (keys %$fai_classes) {
2553                         $result->{$release}= deep_copy(apply_fai_inheritance($fai_classes->{$release}));
2554                 }
2555         }
2556         return $result;
2557 }
2558
2559 sub apply_fai_inheritance {
2560        my $fai_classes = shift || return {};
2561        my $tmp_classes;
2562
2563        # Get the classes from the branch
2564        foreach my $class (keys %{$fai_classes}) {
2565                # Skip subreleases
2566                if($class =~ /^ou=.*$/) {
2567                        next;
2568                } else {
2569                        $tmp_classes->{$class}= deep_copy($fai_classes->{$class});
2570                }
2571        }
2572
2573        # Apply to each subrelease
2574        foreach my $subrelease (keys %{$fai_classes}) {
2575                if($subrelease =~ /ou=/) {
2576                        foreach my $tmp_class (keys %{$tmp_classes}) {
2577                                if(!exists($fai_classes->{$subrelease}->{$tmp_class})) {
2578                                        $fai_classes->{$subrelease}->{$tmp_class} =
2579                                        deep_copy($tmp_classes->{$tmp_class});
2580                                } else {
2581                                        foreach my $type (keys %{$tmp_classes->{$tmp_class}}) {
2582                                                if(!exists($fai_classes->{$subrelease}->{$tmp_class}->{$type})) {
2583                                                        $fai_classes->{$subrelease}->{$tmp_class}->{$type}=
2584                                                        deep_copy($tmp_classes->{$tmp_class}->{$type});
2585                                                }
2586                                        }
2587                                }
2588                        }
2589                }
2590        }
2591
2592        # Find subreleases in deeper levels
2593        foreach my $subrelease (keys %{$fai_classes}) {
2594                if($subrelease =~ /ou=/) {
2595                        foreach my $subsubrelease (keys %{$fai_classes->{$subrelease}}) {
2596                                if($subsubrelease =~ /ou=/) {
2597                                        apply_fai_inheritance($fai_classes->{$subrelease});
2598                                }
2599                        }
2600                }
2601        }
2602
2603        return $fai_classes;
2604 }
2605
2606 sub get_fai_release_entries {
2607         my $tmp_classes = shift || return;
2608         my $parent = shift || "";
2609         my @result = shift || ();
2610
2611         foreach my $entry (keys %{$tmp_classes}) {
2612                 if(defined($entry)) {
2613                         if($entry =~ /^ou=.*$/) {
2614                                 my $release_name = $entry;
2615                                 $release_name =~ s/ou=//g;
2616                                 if(length($parent)>0) {
2617                                         $release_name = $parent."/".$release_name;
2618                                 }
2619                                 my @bufentries = get_fai_release_entries($tmp_classes->{$entry}, $release_name, @result);
2620                                 foreach my $bufentry(@bufentries) {
2621                                         push @result, $bufentry;
2622                                 }
2623                         } else {
2624                                 my @types = get_fai_types($tmp_classes->{$entry});
2625                                 foreach my $type (@types) {
2626                                         push @result,
2627                                         {
2628                                                 'class' => $entry,
2629                                                 'type' => $type->{'type'},
2630                                                 'release' => $parent,
2631                                                 'state' => $type->{'state'},
2632                                         };
2633                                 }
2634                         }
2635                 }
2636         }
2637
2638         return @result;
2639 }
2640
2641 sub deep_copy {
2642         my $this = shift;
2643         if (not ref $this) {
2644                 $this;
2645         } elsif (ref $this eq "ARRAY") {
2646                 [map deep_copy($_), @$this];
2647         } elsif (ref $this eq "HASH") {
2648                 +{map { $_ => deep_copy($this->{$_}) } keys %$this};
2649         } else { die "what type is $_?" }
2650 }
2651
2652
2653 sub session_run_result {
2654     my ($kernel, $heap, $client_answer) = @_[KERNEL, HEAP, ARG0];
2655     $kernel->sig(CHLD => "child_reap");
2656 }
2657
2658 sub session_run_debug {
2659     my $result = $_[ARG0];
2660     print STDERR "$result\n";
2661 }
2662
2663 sub session_run_done {
2664     my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
2665     delete $heap->{task}->{$task_id};
2666 }
2667
2668
2669 sub create_sources_list {
2670         my $session_id = shift;
2671         my $ldap_handle = &main::get_ldap_handle;
2672         my $result="/tmp/gosa_si_tmp_sources_list";
2673
2674         # Remove old file
2675         if(stat($result)) {
2676                 unlink($result);
2677                 &main::daemon_log("$session_id DEBUG: remove an old version of '$result'", 7);
2678         }
2679
2680         my $fh;
2681         open($fh, ">$result");
2682         if (not defined $fh) {
2683                 &main::daemon_log("$session_id DEBUG: cannot open '$result' for writing", 7);
2684                 return undef;
2685         }
2686         if(defined($main::ldap_server_dn) and length($main::ldap_server_dn) > 0) {
2687                 my $mesg=$ldap_handle->search(
2688                         base    => $main::ldap_server_dn,
2689                         scope   => 'base',
2690                         attrs   => 'FAIrepository',
2691                         filter  => 'objectClass=FAIrepositoryServer'
2692                 );
2693                 if($mesg->count) {
2694                         foreach my $entry(@{$mesg->{'entries'}}) {
2695                                 foreach my $value(@{$entry->get_value('FAIrepository', asref => 1)}) {
2696                                         my ($server, $tag, $release, $sections)= split /\|/, $value;
2697                                         my $line = "deb $server $release";
2698                                         $sections =~ s/,/ /g;
2699                                         $line.= " $sections";
2700                                         print $fh $line."\n";
2701                                 }
2702                         }
2703                 }
2704         } else {
2705                 if (defined $main::ldap_server_dn){
2706                         &main::daemon_log("$session_id ERROR: something wrong with ldap_server_dn '$main::ldap_server_dn', abort create_sources_list", 1);
2707                 } else {
2708                         &main::daemon_log("$session_id ERROR: no ldap_server_dn found, abort create_sources_list", 1);
2709                 }
2710         }
2711         close($fh);
2712
2713         return $result;
2714 }
2715
2716
2717 sub run_create_packages_list_db {
2718     my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];
2719         my $session_id = $session->ID;
2720
2721         my $task = POE::Wheel::Run->new(
2722                                         Priority => +20,
2723                                         Program => sub {&create_packages_list_db(undef, undef, $session_id)},
2724                                         StdoutEvent  => "session_run_result",
2725                                         StderrEvent  => "session_run_debug",
2726                                         CloseEvent   => "session_run_done",
2727                                         );
2728         $heap->{task}->{ $task->ID } = $task;
2729 }
2730
2731
2732 sub create_packages_list_db {
2733         my ($ldap_handle, $sources_file, $session_id) = @_;
2734
2735         # it should not be possible to trigger a recreation of packages_list_db
2736         # while packages_list_db is under construction, so set flag packages_list_under_construction
2737         # which is tested befor recreation can be started
2738         if (-r $packages_list_under_construction) {
2739                 daemon_log("$session_id WARNING: packages_list_db is right now under construction, please wait until this process is finished", 3);
2740                 return;
2741         } else {
2742                 daemon_log("$session_id INFO: create_packages_list_db: start", 5);
2743                 # set packages_list_under_construction to true
2744                 system("touch $packages_list_under_construction");
2745                 @packages_list_statements=();
2746         }
2747
2748         if (not defined $session_id) { $session_id = 0; }
2749         if (not defined $ldap_handle) {
2750                 $ldap_handle= &get_ldap_handle();
2751
2752                 if (not defined $ldap_handle) {
2753                         daemon_log("$session_id ERROR: no ldap_handle available to create_packages_list_db", 1);
2754                         unlink($packages_list_under_construction);
2755                         return;
2756                 }
2757         }
2758         if (not defined $sources_file) {
2759                 &main::daemon_log("$session_id INFO: no sources_file given for creating packages list so trigger creation of it", 5);
2760                 $sources_file = &create_sources_list($session_id);
2761         }
2762
2763         if (not defined $sources_file) {
2764                 &main::daemon_log("$session_id ERROR: no sources_file given under '$sources_file', skip create_packages_list_db", 1);
2765                 unlink($packages_list_under_construction);
2766                 return;
2767         }
2768
2769         my $line;
2770
2771         open(CONFIG, "<$sources_file") or do {
2772                 daemon_log( "$session_id ERROR: create_packages_list_db: Failed to open '$sources_file'", 1);
2773                 unlink($packages_list_under_construction);
2774                 return;
2775         };
2776
2777         # Read lines
2778         while ($line = <CONFIG>){
2779                 # Unify
2780                 chop($line);
2781                 $line =~ s/^\s+//;
2782                 $line =~ s/^\s+/ /;
2783
2784                 # Strip comments
2785                 $line =~ s/#.*$//g;
2786
2787                 # Skip empty lines
2788                 if ($line =~ /^\s*$/){
2789                         next;
2790                 }
2791
2792                 # Interpret deb line
2793                 if ($line =~ /^deb [^\s]+\s[^\s]+\s[^\s]+/){
2794                         my( $baseurl, $dist, $sections ) = ($line =~ /^deb\s([^\s]+)\s+([^\s]+)\s+(.*)$/);
2795                         my $section;
2796                         foreach $section (split(' ', $sections)){
2797                                 &parse_package_info( $baseurl, $dist, $section, $session_id );
2798                         }
2799                 }
2800         }
2801
2802         close (CONFIG);
2803
2804
2805         if(keys(%repo_dirs)) {
2806                 find(\&cleanup_and_extract, keys( %repo_dirs ));
2807                 &main::strip_packages_list_statements();
2808                 $packages_list_db->exec_statementlist(\@packages_list_statements);
2809         }
2810         unlink($packages_list_under_construction);
2811         daemon_log("$session_id INFO: create_packages_list_db: finished", 5);
2812         return;
2813 }
2814
2815 # This function should do some intensive task to minimize the db-traffic
2816 sub strip_packages_list_statements {
2817     my @existing_entries= @{$packages_list_db->exec_statement("SELECT * FROM $main::packages_list_tn")};
2818         my @new_statement_list=();
2819         my $hash;
2820         my $insert_hash;
2821         my $update_hash;
2822         my $delete_hash;
2823         my $local_timestamp=get_time();
2824
2825         foreach my $existing_entry (@existing_entries) {
2826                 $hash->{@{$existing_entry}[0]}->{@{$existing_entry}[1]}->{@{$existing_entry}[2]}= $existing_entry;
2827         }
2828
2829         foreach my $statement (@packages_list_statements) {
2830                 if($statement =~ /^INSERT/i) {
2831                         # Assign the values from the insert statement
2832                         my ($distribution,$package,$version,$section,$description,$template,$timestamp) = ($1,$2,$3,$4,$5,$6,$7) if $statement =~
2833                         /^INSERT\s+?INTO\s+?$main::packages_list_tn\s+?VALUES\s*?\('(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)'\s*?\)$/si;
2834                         if(exists($hash->{$distribution}->{$package}->{$version})) {
2835                                 # If section or description has changed, update the DB
2836                                 if(
2837                                         (! (@{$hash->{$distribution}->{$package}->{$version}}[3] eq $section)) or
2838                                         (! (@{$hash->{$distribution}->{$package}->{$version}}[4] eq $description))
2839                                 ) {
2840                                         @{$update_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,undef);
2841                                 }
2842                         } else {
2843                                 # Insert a non-existing entry to db
2844                                 @{$insert_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,$template);
2845                         }
2846                 } elsif ($statement =~ /^UPDATE/i) {
2847                         my ($template,$package,$version) = ($1,$2,$3) if $statement =~
2848                         /^update\s+?$main::packages_list_tn\s+?set\s+?template\s*?=\s*?'(.*?)'\s+?where\s+?package\s*?=\s*?'(.*?)'\s+?and\s+?version\s*?=\s*?'(.*?)'\s*?;$/si;
2849                         foreach my $distribution (keys %{$hash}) {
2850                                 if(exists($insert_hash->{$distribution}->{$package}->{$version})) {
2851                                         # update the insertion hash to execute only one query per package (insert instead insert+update)
2852                                         @{$insert_hash->{$distribution}->{$package}->{$version}}[5]= $template;
2853                                 } elsif(exists($hash->{$distribution}->{$package}->{$version})) {
2854                                         if( ! (@{$hash->{$distribution}->{$package}->{$version}}[5] eq $template)) {
2855                                                 my $section;
2856                                                 my $description;
2857                                                 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[3]) and
2858                                                         length(@{$update_hash->{$distribution}->{$package}->{$version}}[3]) > 0 ) {
2859                                                         $section= @{$update_hash->{$distribution}->{$package}->{$version}}[3];
2860                                                 }
2861                                                 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[4])) {
2862                                                         $description= @{$update_hash->{$distribution}->{$package}->{$version}}[4];
2863                                                 }
2864                                                 @{$update_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,$template);
2865                                         }
2866                                 }
2867                         }
2868                 }
2869         }
2870
2871         # TODO: Check for orphaned entries
2872
2873         # unroll the insert_hash
2874         foreach my $distribution (keys %{$insert_hash}) {
2875                 foreach my $package (keys %{$insert_hash->{$distribution}}) {
2876                         foreach my $version (keys %{$insert_hash->{$distribution}->{$package}}) {
2877                                 push @new_statement_list, "INSERT INTO $main::packages_list_tn VALUES ('$distribution','$package','$version',"
2878                                 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[3]',"
2879                                 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[4]',"
2880                                 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[5]',"
2881                                 ."'$local_timestamp')";
2882                         }
2883                 }
2884         }
2885
2886         # unroll the update hash
2887         foreach my $distribution (keys %{$update_hash}) {
2888                 foreach my $package (keys %{$update_hash->{$distribution}}) {
2889                         foreach my $version (keys %{$update_hash->{$distribution}->{$package}}) {
2890                                 my $set = "";
2891                                 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[3])) {
2892                                         $set .= "section = '@{$update_hash->{$distribution}->{$package}->{$version}}[3]', ";
2893                                 }
2894                                 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[4])) {
2895                                         $set .= "description = '@{$update_hash->{$distribution}->{$package}->{$version}}[4]', ";
2896                                 }
2897                                 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[5])) {
2898                                         $set .= "template = '@{$update_hash->{$distribution}->{$package}->{$version}}[5]', ";
2899                                 }
2900                                 if(defined($set) and length($set) > 0) {
2901                                         $set .= "timestamp = '$local_timestamp'";
2902                                 } else {
2903                                         next;
2904                                 }
2905                                 push @new_statement_list,
2906                                         "UPDATE $main::packages_list_tn SET $set WHERE"
2907                                         ." distribution = '$distribution'"
2908                                         ." AND package = '$package'"
2909                                         ." AND version = '$version'";
2910                         }
2911                 }
2912         }
2913
2914         @packages_list_statements = @new_statement_list;
2915 }
2916
2917
2918 sub parse_package_info {
2919     my ($baseurl, $dist, $section, $session_id)= @_;
2920     my ($package);
2921     if (not defined $session_id) { $session_id = 0; }
2922     my ($path) = ($baseurl =~ m%://[^/]*(.*)$%);
2923     $repo_dirs{ "${repo_path}/pool" } = 1;
2924
2925     foreach $package ("Packages.gz"){
2926         daemon_log("$session_id DEBUG: create_packages_list: fetch $baseurl, $dist, $section", 7);
2927         get_package( "$baseurl/dists/$dist/$section/binary-$arch/$package", "$outdir/$dist/$section", $session_id );
2928         parse_package( "$outdir/$dist/$section", $dist, $path, $session_id );
2929     }
2930
2931 }
2932
2933
2934 sub get_package {
2935     my ($url, $dest, $session_id)= @_;
2936     if (not defined $session_id) { $session_id = 0; }
2937
2938     my $tpath = dirname($dest);
2939     -d "$tpath" || mkpath "$tpath";
2940
2941     # This is ugly, but I've no time to take a look at "how it works in perl"
2942     if(0 == system("wget '$url' -O '$dest' 2>/dev/null") ) {
2943         system("gunzip -cd '$dest' > '$dest.in'");
2944         daemon_log("$session_id DEBUG: run command: gunzip -cd '$dest' > '$dest.in'", 5);
2945         unlink($dest);
2946         daemon_log("$session_id DEBUG: delete file '$dest'", 5);
2947     } else {
2948         daemon_log("$session_id ERROR: create_packages_list_db: get_packages: fetching '$url' failed!", 1);
2949     }
2950     return 0;
2951 }
2952
2953
2954 sub parse_package {
2955     my ($path, $dist, $srv_path, $session_id)= @_;
2956     if (not defined $session_id) { $session_id = 0;}
2957     my ($package, $version, $section, $description);
2958     my $PACKAGES;
2959     my $timestamp = &get_time();
2960
2961     if(not stat("$path.in")) {
2962         daemon_log("$session_id ERROR: create_packages_list: parse_package: file '$path.in' is not readable",1);
2963         return;
2964     }
2965
2966     open($PACKAGES, "<$path.in");
2967     if(not defined($PACKAGES)) {
2968         daemon_log("$session_id ERROR: create_packages_list_db: parse_package: cannot open '$path.in'",1);
2969         return;
2970     }
2971
2972     # Read lines
2973     while (<$PACKAGES>){
2974         my $line = $_;
2975         # Unify
2976         chop($line);
2977
2978         # Use empty lines as a trigger
2979         if ($line =~ /^\s*$/){
2980             my $sql = "INSERT INTO packages_list VALUES ('$dist', '$package', '$version', '$section', '$description', '', '$timestamp')";
2981             push(@packages_list_statements, $sql);
2982             $package = "none";
2983             $version = "none";
2984             $section = "none";
2985             $description = "none";
2986             next;
2987         }
2988
2989         # Trigger for package name
2990         if ($line =~ /^Package:\s/){
2991             ($package)= ($line =~ /^Package: (.*)$/);
2992             next;
2993         }
2994
2995         # Trigger for version
2996         if ($line =~ /^Version:\s/){
2997             ($version)= ($line =~ /^Version: (.*)$/);
2998             next;
2999         }
3000
3001         # Trigger for description
3002         if ($line =~ /^Description:\s/){
3003             ($description)= &encode_base64(($line =~ /^Description: (.*)$/));
3004             next;
3005         }
3006
3007         # Trigger for section
3008         if ($line =~ /^Section:\s/){
3009             ($section)= ($line =~ /^Section: (.*)$/);
3010             next;
3011         }
3012
3013         # Trigger for filename
3014         if ($line =~ /^Filename:\s/){
3015             my ($filename) = ($line =~ /^Filename: (.*)$/);
3016             store_fileinfo( $package, $filename, $dist, $srv_path, $version, $repo_path );
3017             next;
3018         }
3019     }
3020
3021     close( $PACKAGES );
3022     unlink( "$path.in" );
3023 }
3024
3025
3026 sub store_fileinfo {
3027     my( $package, $file, $dist, $path, $vers, $srvdir) = @_;
3028
3029     my %fileinfo = (
3030         'package' => $package,
3031         'dist' => $dist,
3032         'version' => $vers,
3033     );
3034
3035     $repo_files{ "${srvdir}/$file" } = \%fileinfo;
3036 }
3037
3038
3039 sub cleanup_and_extract {
3040         my $fileinfo = $repo_files{ $File::Find::name };
3041
3042         if( defined $fileinfo ) {
3043                 my $dir = "$outdir/$fileinfo->{ 'dist' }/debconf.d";
3044                 my $sql;
3045                 my $package = $fileinfo->{ 'package' };
3046                 my $newver = $fileinfo->{ 'version' };
3047
3048                 mkpath($dir);
3049                 system( "dpkg -e '$File::Find::name' '$dir/DEBIAN'" );
3050
3051                 if( -f "$dir/DEBIAN/templates" ) {
3052
3053                         daemon_log("DEBUG: Found debconf templates in '$package' - $newver", 7);
3054
3055                         my $tmpl= ""; {
3056                                 local $/=undef;
3057                                 open FILE, "$dir/DEBIAN/templates";
3058                                 $tmpl = &encode_base64(<FILE>);
3059                                 close FILE;
3060                         }
3061                         rmtree("$dir/DEBIAN/templates");
3062
3063                         $sql= "update $main::packages_list_tn set template = '$tmpl' where package = '$package' and version = '$newver';";
3064                         push @packages_list_statements, $sql;
3065                 }
3066         }
3067
3068         return;
3069 }
3070
3071
3072 sub register_at_foreign_servers {
3073     my ($kernel) = $_[KERNEL];
3074
3075     # hole alle bekannten server aus known_server_db
3076     my $server_sql = "SELECT * FROM $known_server_tn";
3077     my $server_res = $known_server_db->exec_statement($server_sql);
3078
3079     # no entries in known_server_db
3080     if (not ref(@$server_res[0]) eq "ARRAY") {
3081         # TODO
3082     }
3083
3084     # detect already connected clients
3085     my $client_sql = "SELECT * FROM $known_clients_tn";
3086     my $client_res = $known_clients_db->exec_statement($client_sql);
3087
3088     # send my server details to all other gosa-si-server within the network
3089     foreach my $hit (@$server_res) {
3090         my $hostname = @$hit[0];
3091         my $hostkey = &create_passwd;
3092
3093         # add already connected clients to registration message
3094         my $myhash = &create_xml_hash('new_server', $server_address, $hostname);
3095         &add_content2xml_hash($myhash, 'key', $hostkey);
3096         map(&add_content2xml_hash($myhash, 'client', @{$_}[0].",".@{$_}[4]), @$client_res);
3097
3098         # add locally loaded gosa-si modules to registration message
3099         my $loaded_modules = {};
3100         while (my ($package, $pck_info) = each %$known_modules) {
3101                                                 next if ((!defined(@$pck_info[2])) || (!(ref (@$pck_info[2]) eq 'HASH')));
3102                                                 foreach my $act_module (keys(%{@$pck_info[2]})) {
3103                                                         $loaded_modules->{$act_module} = "";
3104                                                 }
3105         }
3106
3107         map(&add_content2xml_hash($myhash, "loaded_modules", $_), keys(%$loaded_modules));
3108
3109         # add macaddress to registration message
3110         my ($host_ip, $host_port) = split(/:/, $hostname);
3111         my $local_ip = &get_local_ip_for_remote_ip($host_ip);
3112         my $network_interface= &get_interface_for_ip($local_ip);
3113         my $host_mac = &get_mac_for_interface($network_interface);
3114         &add_content2xml_hash($myhash, 'macaddress', $host_mac);
3115
3116         # build registration message and send it
3117         my $foreign_server_msg = &create_xml_string($myhash);
3118         my $error = &send_msg_to_target($foreign_server_msg, $hostname, $ServerPackages_key, "new_server", 0);
3119     }
3120
3121     $kernel->delay_set("register_at_foreign_servers", $foreign_servers_register_delay);
3122     return;
3123 }
3124
3125
3126 #==== MAIN = main ==============================================================
3127 #  parse commandline options
3128 Getopt::Long::Configure( "bundling" );
3129 GetOptions("h|help" => \&usage,
3130         "c|config=s" => \$cfg_file,
3131         "f|foreground" => \$foreground,
3132         "v|verbose+" => \$verbose,
3133         "no-arp+" => \$no_arp,
3134            );
3135
3136 #  read and set config parameters
3137 &check_cmdline_param ;
3138 &read_configfile($cfg_file, %cfg_defaults);
3139 &check_pid;
3140
3141 $SIG{CHLD} = 'IGNORE';
3142
3143 # forward error messages to logfile
3144 if( ! $foreground ) {
3145   open( STDIN,  '+>/dev/null' );
3146   open( STDOUT, '+>&STDIN'    );
3147   open( STDERR, '+>&STDIN'    );
3148 }
3149
3150 # Just fork, if we are not in foreground mode
3151 if( ! $foreground ) {
3152     chdir '/'                 or die "Can't chdir to /: $!";
3153     $pid = fork;
3154     setsid                    or die "Can't start a new session: $!";
3155     umask 0;
3156 } else {
3157     $pid = $$;
3158 }
3159
3160 # Do something useful - put our PID into the pid_file
3161 if( 0 != $pid ) {
3162     open( LOCK_FILE, ">$pid_file" );
3163     print LOCK_FILE "$pid\n";
3164     close( LOCK_FILE );
3165     if( !$foreground ) {
3166         exit( 0 )
3167     };
3168 }
3169
3170 # parse head url and revision from svn
3171 my $server_status_hash = { 'developmental'=>'revision', 'stable'=>'release'};
3172 $server_version =~ /^\$HeadURL: (\S+) \$:\$Rev: (\d+) \$$/;
3173 $server_headURL = defined $1 ? $1 : 'unknown' ;
3174 $server_revision = defined $2 ? $2 : 'unknown' ;
3175 if ($server_headURL =~ /\/tag\// ||
3176         $server_headURL =~ /\/branches\// ) {
3177     $server_status = "stable";
3178 } else {
3179     $server_status = "developmental" ;
3180 }
3181
3182 # Prepare log file
3183 $root_uid = getpwnam('root');
3184 $adm_gid = getgrnam('adm');
3185 chmod(0640, $log_file);
3186 chown($root_uid, $adm_gid, $log_file);
3187 chown($root_uid, $adm_gid, "/var/lib/gosa-si");
3188
3189 daemon_log(" ", 1);
3190 daemon_log("$0 started!", 1);
3191 daemon_log("status: $server_status", 1);
3192 daemon_log($server_status_hash->{$server_status}.": $server_revision", 1);
3193
3194 {
3195     no strict "refs";
3196
3197     if ($db_module eq "DBmysql") {
3198         # connect to incoming_db
3199         $incoming_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3200
3201         # connect to gosa-si job queue
3202         $job_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3203
3204         # connect to known_clients_db
3205         $known_clients_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3206
3207         # connect to foreign_clients_db
3208         $foreign_clients_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3209
3210         # connect to known_server_db
3211         $known_server_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3212
3213         # connect to login_usr_db
3214         $login_users_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3215
3216         # connect to fai_server_db
3217         $fai_server_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3218
3219         # connect to fai_release_db
3220         $fai_release_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3221
3222         # connect to packages_list_db
3223         $packages_list_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3224
3225         # connect to messaging_db
3226         $messaging_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3227
3228     } elsif ($db_module eq "DBsqlite") {
3229         # connect to incoming_db
3230         unlink($incoming_file_name);
3231         $incoming_db = GOSA::DBsqlite->new($incoming_file_name);
3232
3233         # connect to gosa-si job queue
3234         unlink($job_queue_file_name);  ## just for debugging
3235         $job_db = GOSA::DBsqlite->new($job_queue_file_name);
3236         chmod(0660, $job_queue_file_name);
3237         chown($root_uid, $adm_gid, $job_queue_file_name);
3238
3239         # connect to known_clients_db
3240         unlink($known_clients_file_name);   ## just for debugging
3241         $known_clients_db = GOSA::DBsqlite->new($known_clients_file_name);
3242         chmod(0660, $known_clients_file_name);
3243         chown($root_uid, $adm_gid, $known_clients_file_name);
3244
3245         # connect to foreign_clients_db
3246         unlink($foreign_clients_file_name);
3247         $foreign_clients_db = GOSA::DBsqlite->new($foreign_clients_file_name);
3248         chmod(0660, $foreign_clients_file_name);
3249         chown($root_uid, $adm_gid, $foreign_clients_file_name);
3250
3251         # connect to known_server_db
3252         unlink($known_server_file_name);
3253         $known_server_db = GOSA::DBsqlite->new($known_server_file_name);
3254         chmod(0660, $known_server_file_name);
3255         chown($root_uid, $adm_gid, $known_server_file_name);
3256
3257         # connect to login_usr_db
3258         unlink($login_users_file_name);
3259         $login_users_db = GOSA::DBsqlite->new($login_users_file_name);
3260         chmod(0660, $login_users_file_name);
3261         chown($root_uid, $adm_gid, $login_users_file_name);
3262
3263         # connect to fai_server_db
3264         unlink($fai_server_file_name);
3265         $fai_server_db = GOSA::DBsqlite->new($fai_server_file_name);
3266         chmod(0660, $fai_server_file_name);
3267         chown($root_uid, $adm_gid, $fai_server_file_name);
3268
3269         # connect to fai_release_db
3270         unlink($fai_release_file_name);
3271         $fai_release_db = GOSA::DBsqlite->new($fai_release_file_name);
3272         chmod(0660, $fai_release_file_name);
3273         chown($root_uid, $adm_gid, $fai_release_file_name);
3274
3275         # connect to packages_list_db
3276         #unlink($packages_list_file_name);
3277         unlink($packages_list_under_construction);
3278         $packages_list_db = GOSA::DBsqlite->new($packages_list_file_name);
3279         chmod(0660, $packages_list_file_name);
3280         chown($root_uid, $adm_gid, $packages_list_file_name);
3281
3282         # connect to messaging_db
3283         unlink($messaging_file_name);
3284         $messaging_db = GOSA::DBsqlite->new($messaging_file_name);
3285         chmod(0660, $messaging_file_name);
3286         chown($root_uid, $adm_gid, $messaging_file_name);
3287     }
3288 }
3289
3290 # Creating tables
3291 $messaging_db->create_table($messaging_tn, \@messaging_col_names);
3292 $packages_list_db->create_table($packages_list_tn, \@packages_list_col_names);
3293 $fai_release_db->create_table($fai_release_tn, \@fai_release_col_names);
3294 $fai_server_db->create_table($fai_server_tn, \@fai_server_col_names);
3295 $login_users_db->create_table($login_users_tn, \@login_users_col_names);
3296 $known_server_db->create_table($known_server_tn, \@known_server_col_names);
3297 $foreign_clients_db->create_table($foreign_clients_tn, \@foreign_clients_col_names);
3298 $known_clients_db->create_table($known_clients_tn, \@known_clients_col_names);
3299 $incoming_db->create_table($incoming_tn, \@incoming_col_names);
3300 $job_db->create_table($job_queue_tn, \@job_queue_col_names);
3301
3302
3303 # create xml object used for en/decrypting
3304 $xml = new XML::Simple();
3305
3306
3307 # foreign servers
3308 my @foreign_server_list;
3309
3310 # add foreign server from cfg file
3311 if ($foreign_server_string ne "") {
3312     my @cfg_foreign_server_list = split(",", $foreign_server_string);
3313     foreach my $foreign_server (@cfg_foreign_server_list) {
3314         push(@foreign_server_list, $foreign_server);
3315     }
3316
3317     daemon_log("0 INFO: found foreign server in config file: ".join(", ", @foreign_server_list), 5);
3318 }
3319
3320 # Perform a DNS lookup for server registration if flag is true
3321 if ($dns_lookup eq "true") {
3322     # Add foreign server from dns
3323     my @tmp_servers;
3324     if (not $server_domain) {
3325         # Try our DNS Searchlist
3326         for my $domain(get_dns_domains()) {
3327             chomp($domain);
3328             my ($tmp_domains, $error_string) = &get_server_addresses($domain);
3329             if(@$tmp_domains) {
3330                 for my $tmp_server(@$tmp_domains) {
3331                     push @tmp_servers, $tmp_server;
3332                 }
3333             }
3334         }
3335         if(@tmp_servers && length(@tmp_servers)==0) {
3336             daemon_log("0 WARNING: no foreign gosa-si-server found in DNS for domain '$server_domain'", 3);
3337         }
3338     } else {
3339         @tmp_servers = &get_server_addresses($server_domain);
3340         if( 0 == @tmp_servers ) {
3341             daemon_log("0 WARNING: no foreign gosa-si-server found in DNS for domain '$server_domain'", 3);
3342         }
3343     }
3344
3345     daemon_log("0 INFO: found foreign server via DNS ".join(", ", @tmp_servers), 5);
3346
3347     foreach my $server (@tmp_servers) {
3348         unshift(@foreign_server_list, $server);
3349     }
3350 } else {
3351     daemon_log("0 INFO: DNS lookup for server registration is disabled", 5);
3352 }
3353
3354
3355 # eliminate duplicate entries
3356 @foreign_server_list = &del_doubles(@foreign_server_list);
3357 my $all_foreign_server = join(", ", @foreign_server_list);
3358 daemon_log("0 INFO: found foreign server in config file and DNS: '$all_foreign_server'", 5);
3359
3360 # add all found foreign servers to known_server
3361 my $act_timestamp = &get_time();
3362 foreach my $foreign_server (@foreign_server_list) {
3363
3364         # do not add myself to known_server_db
3365         if (&is_local($foreign_server)) { next; }
3366         ######################################
3367
3368     my $res = $known_server_db->add_dbentry( {table=>$known_server_tn,
3369             primkey=>['hostname'],
3370             hostname=>$foreign_server,
3371             macaddress=>"",
3372             status=>'not_jet_registered',
3373             hostkey=>"none",
3374             loaded_modules => "none",
3375             timestamp=>$act_timestamp,
3376             } );
3377 }
3378
3379
3380 # Import all modules
3381 &import_modules;
3382
3383 # Check wether all modules are gosa-si valid passwd check
3384 &password_check;
3385
3386 # Prepare for using Opsi
3387 if ($opsi_enabled eq "true") {
3388     use JSON::RPC::Client;
3389     use XML::Quote qw(:all);
3390     $opsi_url= "https://".$opsi_admin.":".$opsi_password."@".$opsi_server.":4447/rpc";
3391     $opsi_client = new JSON::RPC::Client;
3392 }
3393
3394
3395 POE::Component::Server::TCP->new(
3396         Alias => "TCP_SERVER",
3397         Port => $server_port,
3398         ClientInput => sub {
3399                 my ($kernel, $input, $heap, $session) = @_[KERNEL, ARG0, HEAP, SESSION];
3400         my $session_id = $session->ID;
3401         my $remote_ip = $heap->{'remote_ip'};
3402                 push(@msgs_to_decrypt, $input);
3403         &daemon_log("$session_id DEBUG: incoming message from '$remote_ip'", 7);
3404                 $kernel->yield("msg_to_decrypt");
3405         },
3406         InlineStates => {
3407                 msg_to_decrypt => \&msg_to_decrypt,
3408                 next_task => \&next_task,
3409                 task_result => \&handle_task_result,
3410                 task_done   => \&handle_task_done,
3411                 task_debug  => \&handle_task_debug,
3412                 child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!"  },
3413         }
3414 );
3415
3416 daemon_log("0 INFO: start socket for incoming xml messages at port '$server_port' ", 1);
3417
3418 # create session for repeatedly checking the job queue for jobs
3419 POE::Session->create(
3420         inline_states => {
3421                 _start => \&session_start,
3422         register_at_foreign_servers => \&register_at_foreign_servers,
3423         sig_handler => \&sig_handler,
3424         next_task => \&next_task,
3425         task_result => \&handle_task_result,
3426         task_done   => \&handle_task_done,
3427         task_debug  => \&handle_task_debug,
3428         watch_for_next_tasks => \&watch_for_next_tasks,
3429         watch_for_new_messages => \&watch_for_new_messages,
3430         watch_for_delivery_messages => \&watch_for_delivery_messages,
3431         watch_for_done_messages => \&watch_for_done_messages,
3432                 watch_for_new_jobs => \&watch_for_new_jobs,
3433         watch_for_modified_jobs => \&watch_for_modified_jobs,
3434         watch_for_done_jobs => \&watch_for_done_jobs,
3435         watch_for_opsi_jobs => \&watch_for_opsi_jobs,
3436         watch_for_old_known_clients => \&watch_for_old_known_clients,
3437         create_packages_list_db => \&run_create_packages_list_db,
3438         create_fai_server_db => \&run_create_fai_server_db,
3439         create_fai_release_db => \&run_create_fai_release_db,
3440                 recreate_packages_db => \&run_recreate_packages_db,
3441         session_run_result => \&session_run_result,
3442         session_run_debug => \&session_run_debug,
3443         session_run_done => \&session_run_done,
3444         child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!"  },
3445         }
3446 );
3447
3448
3449 POE::Kernel->run();
3450 exit;
3451