gosa-si/gosa-si-server

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