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