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