gosa-si/gosa-si-server

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