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 0.0.0.0 source to real address
 891         $msg =~ s/<source>(0\.0\.0\.0):(\d*?)<\/source>/<source>$own_source_address<\/source>/s;
 892         # Patch GOSA source to real address and add forward_to_gosa tag
 893         $msg =~ s/<source>GOSA<\/source>/<source>$own_source_address<\/source> <forward_to_gosa>$own_source_address,$session_id<\/forward_to_gosa>/ ;
 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 ERROR: Cannot open socket to host '$address'. Message processing aborted!", 1);
 902         $error++;
 903     }
 904
 905     if( $error == 0 ) {
 906         # send xml msg
 907         print $socket $crypted_msg.";$own_source_address\n";
 908         daemon_log("$session_id INFO: send ".$header."msg to $address", 5);
 909         daemon_log("$session_id DEBUG: message:\n$msg", 9);
 910
 911     }
 912
 913     # close socket in any case
 914     if( $socket ) {
 915         close $socket;
 916     }
 917
 918     if( $error > 0 ) { $new_status = "down"; }
 919     else { $new_status = $msg_header; }
 920
 921
 922     # known_clients
 923     $sql_statement = "SELECT * FROM $known_clients_tn WHERE hostname='$address'";
 924     $res = $known_clients_db->select_dbentry($sql_statement);
 925     if( keys(%$res) == 1) {
 926         $act_status = exists $res->{1}->{'status'} ? $res->{1}->{'status'} : "";
 927         if ($act_status eq "down" && $new_status eq "down") {
 928             $sql_statement = "DELETE FROM known_clients WHERE hostname='$address'";
 929             $res = $known_clients_db->del_dbentry($sql_statement);
 930             daemon_log("$session_id WARNING: failed 2x to send msg to host '$address', delete host from known_clients", 3);
 931         } else {
 932             $sql_statement = "UPDATE known_clients SET status='$new_status', timestamp='$timestamp' WHERE hostname='$address'";
 933             $res = $known_clients_db->update_dbentry($sql_statement);
 934             if($new_status eq "down"){
 935                 daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
 936             } else {
 937                 daemon_log("$session_id INFO: set '$address' from status '$act_status' to '$new_status'", 5);
 938             }
 939         }
 940     }
 941
 942     # known_server
 943     $sql_statement = "SELECT * FROM $known_server_tn WHERE hostname='$address'";
 944     $res = $known_server_db->select_dbentry($sql_statement);
 945     if( keys(%$res) == 1) {
 946         $act_status = exists $res->{1}->{'status'} ? $res->{1}->{'status'} : "";
 947         if ($act_status eq "down" && $new_status eq "down") {
 948             $sql_statement = "DELETE FROM known_server WHERE hostname='$address'";
 949             $res = $known_server_db->del_dbentry($sql_statement);
 950             daemon_log("$session_id WARNING: failed 2x to send a message to host '$address', delete host from known_server", 3);
 951         }
 952         else {
 953             $sql_statement = "UPDATE known_server SET status='$new_status', timestamp='$timestamp' WHERE hostname='$address'";
 954             $res = $known_server_db->update_dbentry($sql_statement);
 955             if($new_status eq "down"){
 956                 daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
 957             } else {
 958                 daemon_log("$session_id INFO: set '$address' from status '$act_status' to '$new_status'", 5);
 959             }
 960         }
 961     }
 962     return $error;
 963 }
 964
 965
 966 sub update_jobdb_status_for_send_msgs {
 967     my ($session_id, $answer, $error) = @_;
 968     &daemon_log("$session_id DEBUG: try to update job status", 7);
 969     if( $answer =~ /<jobdb_id>(\d+)<\/jobdb_id>/ ) {
 970         my $jobdb_id = $1;
 971
 972         $answer =~ /<header>(.*)<\/header>/;
 973         my $job_header = $1;
 974
 975         $answer =~ /<target>(.*)<\/target>/;
 976         my $job_target = $1;
 977
 978         # Sending msg failed
 979         if( $error ) {
 980
 981             # Set jobs to done, jobs do not need to deliver their message in any case
 982             if (($job_header eq "trigger_action_localboot")
 983                     ||($job_header eq "trigger_action_lock")
 984                     ||($job_header eq "trigger_action_halt")
 985                     ) {
 986                 my $sql_statement = "UPDATE $job_queue_tn SET status='done' WHERE id=$jobdb_id";
 987                 &daemon_log("$session_id DEBUG: $sql_statement", 7);
 988                 my $res = $job_db->update_dbentry($sql_statement);
 989
 990             # Reactivate jobs, jobs need to deliver their message
 991             } elsif (($job_header eq "trigger_action_activate")
 992                     ||($job_header eq "trigger_action_update")
 993                     ||($job_header eq "trigger_action_reinstall")
 994                     ||($job_header eq "trigger_activate_new")
 995                     ) {
 996                 &reactivate_job_with_delay($session_id, $job_target, $job_header, 30 );
 997
 998             # For all other messages
 999             } else {
1000                 my $sql_statement = "UPDATE $job_queue_tn ".
1001                     "SET status='error', result='can not deliver msg, please consult log file' ".
1002                     "WHERE id=$jobdb_id";
1003                 &daemon_log("$session_id DEBUG: $sql_statement", 7);
1004                 my $res = $job_db->update_dbentry($sql_statement);
1005             }
1006
1007         # Sending msg was successful
1008         } else {
1009             # Set jobs localboot, lock, activate, halt, reboot and wake to done
1010             # jobs reinstall, update, inst_update do themself setting to done
1011             if (($job_header eq "trigger_action_localboot")
1012                     ||($job_header eq "trigger_action_lock")
1013                     ||($job_header eq "trigger_action_activate")
1014                     ||($job_header eq "trigger_action_halt")
1015                     ||($job_header eq "trigger_action_reboot")
1016                     ||($job_header eq "trigger_action_wake")
1017                     ||($job_header eq "trigger_wake")
1018                     ) {
1019
1020                 my $sql_statement = "UPDATE $job_queue_tn ".
1021                     "SET status='done' ".
1022                     "WHERE id=$jobdb_id AND status='processed'";
1023                 &daemon_log("$session_id DEBUG: $sql_statement", 7);
1024                 my $res = $job_db->update_dbentry($sql_statement);
1025             } else {
1026                 &daemon_log("$session_id DEBUG: sending message succeed but cannot update job status.", 7);
1027             }
1028         }
1029     } else {
1030         &daemon_log("$session_id DEBUG: cannot update job status, msg has no jobdb_id-tag: $answer", 7);
1031     }
1032 }
1033
1034 sub reactivate_job_with_delay {
1035     my ($session_id, $target, $header, $delay) = @_ ;
1036     # 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
1037
1038     if (not defined $delay) { $delay = 30 } ;
1039     my $delay_timestamp = &calc_timestamp(&get_time(), "plus", $delay);
1040
1041     my $sql = "UPDATE $job_queue_tn Set timestamp='$delay_timestamp', status='waiting' WHERE (macaddress LIKE 'target' AND headertag='$header')";
1042     my $res = $job_db->update_dbentry($sql);
1043     daemon_log("$session_id INFO: '$header'-job will be reactivated at '$delay_timestamp' ".
1044             "cause client '$target' is currently not available", 5);
1045     daemon_log("$session_id $sql", 7);
1046     return;
1047 }
1048
1049
1050 sub sig_handler {
1051         my ($kernel, $signal) = @_[KERNEL, ARG0] ;
1052         daemon_log("0 INFO got signal '$signal'", 1);
1053         $kernel->sig_handled();
1054         return;
1055 }
1056
1057
1058 sub msg_to_decrypt {
1059         my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];
1060         my $session_id = $session->ID;
1061         my ($msg, $msg_hash, $module);
1062         my $error = 0;
1063
1064         # fetch new msg out of @msgs_to_decrypt
1065         my $tmp_next_msg = shift @msgs_to_decrypt;
1066     my ($next_msg, $msg_source) = split(/;/, $tmp_next_msg);
1067
1068         # msg is from a new client or gosa
1069         ($msg, $msg_hash, $module) = &input_from_unknown_host($next_msg, $session_id);
1070
1071         # msg is from a gosa-si-server
1072         if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1073                 if (not defined $msg_source)
1074                 {
1075                         # Only needed, to be compatible with older gosa-si-server versions
1076                         ($msg, $msg_hash, $module) = &input_from_known_server($next_msg, $heap->{'remote_ip'}, $session_id);
1077                 }
1078                 else
1079                 {
1080                         ($msg, $msg_hash, $module) = &input_from_known_server($next_msg, $msg_source, $session_id);
1081                 }
1082         }
1083         # msg is from a gosa-si-client
1084         if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1085                 ($msg, $msg_hash, $module) = &input_from_known_client($next_msg, $msg_source, $session_id);
1086         }
1087         # an error occurred
1088         if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1089                 # If an incoming msg could not be decrypted (maybe a wrong key), decide if msg comes from a client
1090                 # or a server.  In case of a client, send a ping. If the client could not understand a msg from its
1091                 # server the client cause a re-registering process. In case of a server, decrease update_time in kown_server_db
1092                 # and trigger a re-registering process for servers
1093                 if (defined $msg_source && $msg_source =~ /:$server_port$/)
1094                 {
1095                         daemon_log("$session_id WARNING: Cannot understand incoming msg from server '$msg_source'. Cause re-registration process for servers.", 3);
1096                         my $update_statement = "UPDATE $known_server_tn SET update_time='19700101000000' WHERE hostname='$msg_source'";
1097                         daemon_log("$session_id DEBUG: $update_statement", 7);
1098                         my $upadte_res = $known_server_db->exec_statement($update_statement);
1099                         $kernel->yield("register_at_foreign_servers");
1100                 }
1101                 elsif (defined $msg_source)
1102                 {
1103                         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);
1104                         #my $remote_ip = $heap->{'remote_ip'};
1105                         #my $remote_port = $heap->{'remote_port'};
1106                         my $ping_msg = "<xml> <header>gosa_ping</header> <source>$server_address</source><target>$msg_source</target></xml>";
1107                         my ($test_error, $test_error_string) = &send_msg_to_target($ping_msg, "$msg_source", "dummy-key", "gosa_ping", $session_id);
1108                         daemon_log("$session_id WARNING: sending msg to cause re-registering: $ping_msg", 3);
1109                 }
1110                 else
1111                 {
1112                         my $foreign_host = defined $msg_source ? $msg_source : $heap->{'remote_ip'};
1113                         daemon_log("$session_id ERROR: incoming message from host '$foreign_host' cannot be understood. Processing aborted: $tmp_next_msg", 1);
1114                 }
1115
1116                 $error++;
1117         }
1118
1119
1120         my $header;
1121         my $target;
1122         my $source;
1123         my $done = 0;
1124         my $sql;
1125         my $res;
1126
1127         # check whether this message should be processed here
1128         if ($error == 0) {
1129                 $header = @{$msg_hash->{'header'}}[0];
1130                 $target = @{$msg_hash->{'target'}}[0];
1131                 $source = @{$msg_hash->{'source'}}[0];
1132                 my $not_found_in_known_clients_db = 0;
1133                 my $not_found_in_known_server_db = 0;
1134                 my $not_found_in_foreign_clients_db = 0;
1135                 my $local_address;
1136                 my $local_mac;
1137                 my ($target_ip, $target_port) = split(':', $target);
1138
1139                 # Determine the local ip address if target is an ip address
1140                 if ($target =~ /^\d+\.\d+\.\d+\.\d+:\d+$/) {
1141                         $local_address = &get_local_ip_for_remote_ip($target_ip).":$server_port";
1142                 } else {
1143                         $local_address = $server_address;
1144                 }
1145
1146                 # Determine the local mac address if target is a mac address
1147                 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) {
1148                         my $loc_ip = &get_local_ip_for_remote_ip($heap->{'remote_ip'});
1149                         my $network_interface= &get_interface_for_ip($loc_ip);
1150                         $local_mac = &get_mac_for_interface($network_interface);
1151                 } else {
1152                         $local_mac = $server_mac_address;
1153                 }
1154
1155                 # target and source is equal to GOSA -> process here
1156                 if (not $done) {
1157                         if ($target eq "GOSA" && $source eq "GOSA") {
1158                                 $done = 1;
1159                                 &daemon_log("$session_id DEBUG: target and source is 'GOSA' -> process here", 7);
1160                         }
1161                 }
1162
1163                 # target is own address without forward_to_gosa-tag -> process here
1164                 if (not $done) {
1165                         #if ((($target eq $local_address) || ($target eq $local_mac) ) && (not exists $msg_hash->{'forward_to_gosa'})) {
1166                         if (($target eq $local_address) && (not exists $msg_hash->{'forward_to_gosa'})) {
1167                                 $done = 1;
1168                                 if ($source eq "GOSA") {
1169                                         $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1170                                 }
1171                                 &daemon_log("$session_id DEBUG: target is own address without forward_to_gosa-tag -> process here", 7);
1172                         }
1173                 }
1174
1175                 # target ist own address with forward_to_gosa-tag not pointing to myself -> process here
1176                 if (not $done) {
1177                         my $forward_to_gosa =  @{$msg_hash->{'forward_to_gosa'}}[0];
1178                         my $gosa_at;
1179                         my $gosa_session_id;
1180                         if (($target eq $local_address) && (defined $forward_to_gosa)){
1181                                 my ($gosa_at, $gosa_session_id) = split(/,/, $forward_to_gosa);
1182                                 if ($gosa_at ne $local_address) {
1183                                         $done = 1;
1184                                         &daemon_log("$session_id DEBUG: target is own address with forward_to_gosa-tag not pointing to myself -> process here", 7);
1185                                 }
1186                         }
1187                 }
1188
1189                 # If header has a 'job_' prefix, do always process message locally
1190                 # which means put it into job queue
1191                 if ((not $done) && ($header =~ /job_/))
1192                 {
1193                         $done = 1;
1194                         &daemon_log("$session_id DEBUG: Header has a 'job_' prefix. Put it into job queue. -> process here", 7);
1195                 }
1196
1197                 # if message should be processed here -> add message to incoming_db
1198                 if ($done) {
1199                         # if a 'job_' or a 'gosa_' message comes from a foreign server, fake module from
1200                         # ServerPackages to GosaPackages so gosa-si-server knows how to process this kind of messages
1201                         if ($header =~ /^gosa_/ || $header =~ /^job_/) {
1202                                 $module = "GosaPackages";
1203                         }
1204
1205                         my $res = $incoming_db->add_dbentry( {table=>$incoming_tn,
1206                                         primkey=>[],
1207                                         headertag=>$header,
1208                                         targettag=>$target,
1209                                         xmlmessage=>&encode_base64($msg),
1210                                         timestamp=>&get_time,
1211                                         module=>$module,
1212                                         sessionid=>$session_id,
1213                                 } );
1214
1215                 }
1216
1217                 # target is own address with forward_to_gosa-tag pointing at myself -> forward to gosa
1218                 if (not $done) {
1219                         my $forward_to_gosa =  @{$msg_hash->{'forward_to_gosa'}}[0];
1220                         my $gosa_at;
1221                         my $gosa_session_id;
1222                         if (($target eq $local_address) && (defined $forward_to_gosa)){
1223                                 my ($gosa_at, $gosa_session_id) = split(/,/, $forward_to_gosa);
1224                                 if ($gosa_at eq $local_address) {
1225                                         my $session_reference = $kernel->ID_id_to_session($gosa_session_id);
1226                                         if( defined $session_reference ) {
1227                                                 $heap = $session_reference->get_heap();
1228                                         }
1229                                         if(exists $heap->{'client'}) {
1230                                                 $msg = &encrypt_msg($msg, $GosaPackages_key);
1231                                                 $heap->{'client'}->put($msg);
1232                                                 &daemon_log("$session_id INFO: incoming '$header' message forwarded to GOsa", 5);
1233                                         }
1234                                         $done = 1;
1235                                         &daemon_log("$session_id DEBUG: target is own address with forward_to_gosa-tag pointing at myself -> forward to gosa", 7);
1236                                 }
1237                         }
1238
1239                 }
1240
1241                 # target is a client address in known_clients -> forward to client
1242                 if (not $done) {
1243                         $sql = "SELECT * FROM $known_clients_tn WHERE (hostname='$target' OR macaddress LIKE '$target')";
1244                         $res = $known_clients_db->select_dbentry($sql);
1245                         if (keys(%$res) > 0) {
1246                                 &daemon_log("$session_id DEBUG: target is a client address in known_clients -> forward to client", 7);
1247                                 $done = 1;
1248                                 my $hostkey = $res->{1}->{'hostkey'};
1249                                 my $hostname = $res->{1}->{'hostname'};
1250                                 $msg =~ s/<target>\S*<\/target>/<target>$hostname<\/target>/;
1251                                 $msg =~ s/<header>gosa_/<header>/;
1252                                 my $error= &send_msg_to_target($msg, $hostname, $hostkey, $header, $session_id);
1253                                 if ($error) {
1254                                         &daemon_log("$session_id ERROR: Some problems occurred while trying to send msg to client '$hostkey': $msg", 1);
1255                                 }
1256                         } else {
1257                                 $not_found_in_known_clients_db = 1;
1258                         }
1259                 }
1260
1261                 # target is a client address in foreign_clients -> forward to registration server
1262                 if (not $done) {
1263                         $sql = "SELECT * FROM $foreign_clients_tn WHERE (hostname='$target' OR macaddress LIKE '$target')";
1264                         $res = $foreign_clients_db->select_dbentry($sql);
1265                         if (keys(%$res) > 0) {
1266                                 my $hostname = $res->{1}->{'hostname'};
1267                                 my ($host_ip, $host_port) = split(/:/, $hostname);
1268                                 my $local_address =  &get_local_ip_for_remote_ip($host_ip).":$server_port";
1269                                 my $regserver = $res->{1}->{'regserver'};
1270                                 my $sql = "SELECT * FROM $known_server_tn WHERE hostname='$regserver'";
1271                                 my $res = $known_server_db->select_dbentry($sql);
1272                                 if (keys(%$res) > 0) {
1273                                         my $regserver_key = $res->{1}->{'hostkey'};
1274                                         $msg =~ s/<source>GOSA<\/source>/<source>$local_address<\/source>/;
1275                                         $msg =~ s/<target>$target<\/target>/<target>$hostname<\/target>/;
1276                                         if ($source eq "GOSA") {
1277                                                 $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1278                                         }
1279                                         my $error= &send_msg_to_target($msg, $regserver, $regserver_key, $header, $session_id);
1280                                         if ($error) {
1281                                                 &daemon_log("$session_id ERROR: some problems occurred while trying to send msg to registration server: $msg", 1);
1282                                         }
1283                                 }
1284                                 $done = 1;
1285                                 &daemon_log("$session_id DEBUG: target is a client address in foreign_clients -> forward to registration server", 7);
1286                         } else {
1287                                 $not_found_in_foreign_clients_db = 1;
1288                         }
1289                 }
1290
1291                 # target is a server address -> forward to server
1292                 if (not $done) {
1293                         $sql = "SELECT * FROM $known_server_tn WHERE (hostname='$target' OR macaddress LIKE '$target')";
1294                         $res = $known_server_db->select_dbentry($sql);
1295                         if (keys(%$res) > 0) {
1296                                 my $hostkey = $res->{1}->{'hostkey'};
1297
1298                                 if ($source eq "GOSA") {
1299                                         $msg =~ s/<source>GOSA<\/source>/<source>$local_address<\/source>/;
1300                                         $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1301
1302                                 }
1303
1304                                 &send_msg_to_target($msg, $target, $hostkey, $header, $session_id);
1305                                 $done = 1;
1306                                 &daemon_log("$session_id DEBUG: target is a server address -> forward to server", 7);
1307                         } else {
1308                                 $not_found_in_known_server_db = 1;
1309                         }
1310                 }
1311
1312
1313                 # target is not in foreign_clients_db, known_server_db or known_clients_db, maybe it is a complete new one -> process here
1314                 if ( $not_found_in_foreign_clients_db
1315                         && $not_found_in_known_server_db
1316                         && $not_found_in_known_clients_db) {
1317                         &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);
1318             if ($header =~ /^gosa_/ || $header =~ /^job_/) {
1319                 $module = "GosaPackages";
1320             }
1321                         my $res = $incoming_db->add_dbentry( {table=>$incoming_tn,
1322                                         primkey=>[],
1323                                         headertag=>$header,
1324                                         targettag=>$target,
1325                                         xmlmessage=>&encode_base64($msg),
1326                                         timestamp=>&get_time,
1327                                         module=>$module,
1328                                         sessionid=>$session_id,
1329                                 } );
1330                         $done = 1;
1331                 }
1332
1333
1334                 if (not $done) {
1335                         daemon_log("$session_id ERROR: do not know what to do with this message: $msg", 1);
1336                         if ($source eq "GOSA") {
1337                                 my %data = ('error_msg' => &encode_base64($msg), 'error_string' => "Do not know what to do with this message!");
1338                                 my $error_msg = &build_msg("error", $local_address, "GOSA", \%data );
1339
1340                                 my $session_reference = $kernel->ID_id_to_session($session_id);
1341                                 if( defined $session_reference ) {
1342                                         $heap = $session_reference->get_heap();
1343                                 }
1344                                 if(exists $heap->{'client'}) {
1345                                         $error_msg = &encrypt_msg($error_msg, $GosaPackages_key);
1346                                         $heap->{'client'}->put($error_msg);
1347                                 }
1348                         }
1349                 }
1350
1351         }
1352
1353         return;
1354 }
1355
1356
1357 sub next_task {
1358     my ($session, $heap, $task) = @_[SESSION, HEAP, ARG0, ARG1];
1359     my $running_task = POE::Wheel::Run->new(
1360             Program => sub { process_task($session, $heap, $task) },
1361             StdioFilter => POE::Filter::Reference->new(),
1362             StdoutEvent  => "task_result",
1363             StderrEvent  => "task_debug",
1364             CloseEvent   => "task_done",
1365             );
1366     $heap->{task}->{ $running_task->ID } = $running_task;
1367 }
1368
1369 sub handle_task_result {
1370     my ($kernel, $heap, $result) = @_[KERNEL, HEAP, ARG0];
1371     my $client_answer = $result->{'answer'};
1372     if( $client_answer =~ s/session_id=(\d+)$// ) {
1373         my $session_id = $1;
1374         if( defined $session_id ) {
1375             my $session_reference = $kernel->ID_id_to_session($session_id);
1376             if( defined $session_reference ) {
1377                 $heap = $session_reference->get_heap();
1378             }
1379         }
1380
1381         if(exists $heap->{'client'}) {
1382             $heap->{'client'}->put($client_answer);
1383         }
1384     }
1385     $kernel->sig(CHLD => "child_reap");
1386 }
1387
1388 sub handle_task_debug {
1389     my $result = $_[ARG0];
1390     print STDERR "$result\n";
1391 }
1392
1393 sub handle_task_done {
1394     my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
1395     delete $heap->{task}->{$task_id};
1396         if (exists $heap->{ldap_handle}->{$task_id}) {
1397                 &release_ldap_handle($heap->{ldap_handle}->{$task_id});
1398         }
1399 }
1400
1401 sub process_task {
1402     no strict "refs";
1403     #CHECK: Not @_[...]?
1404     my ($session, $heap, $task) = @_;
1405     my $error = 0;
1406     my $answer_l;
1407     my ($answer_header, @answer_target_l, $answer_source);
1408     my $client_answer = "";
1409
1410     # prepare all variables needed to process message
1411     #my $msg = $task->{'xmlmessage'};
1412     my $msg = &decode_base64($task->{'xmlmessage'});
1413     my $incoming_id = $task->{'id'};
1414     my $module = $task->{'module'};
1415     my $header =  $task->{'headertag'};
1416     my $session_id = $task->{'sessionid'};
1417                 my $msg_hash;
1418                 eval {
1419         $msg_hash = $xml->XMLin($msg, ForceArray=>1);
1420                 };
1421                 daemon_log("ERROR: XML failure '$@'") if ($@);
1422     my $source = @{$msg_hash->{'source'}}[0];
1423
1424     # set timestamp of incoming client uptodate, so client will not
1425     # be deleted from known_clients because of expiration
1426     my $cur_time = &get_time();
1427     my $sql = "UPDATE $known_clients_tn SET timestamp='$cur_time' WHERE hostname='$source'";
1428     my $res = $known_clients_db->exec_statement($sql);
1429
1430     ######################
1431     # process incoming msg
1432     if( $error == 0) {
1433         daemon_log("$session_id INFO: Incoming msg (session_id=$session_id) with header '".@{$msg_hash->{'header'}}[0]."'", 5);
1434         daemon_log("$session_id DEBUG: Processing module ".$module, 7);
1435         $answer_l = &{ $module."::process_incoming_msg" }($msg, $msg_hash, $session_id);
1436
1437         if ( 0 < @{$answer_l} ) {
1438             my $answer_str = join("\n", @{$answer_l});
1439             while ($answer_str =~ /<header>(\w+)<\/header>/g) {
1440                 daemon_log("$session_id INFO: got answer message with header '$1'", 5);
1441             }
1442             daemon_log("$session_id DEBUG: $module: got answer from module: \n".$answer_str,9);
1443         } else {
1444             daemon_log("$session_id DEBUG: $module: got no answer from module!" ,7);
1445         }
1446
1447     }
1448     if( !$answer_l ) { $error++ };
1449
1450     ########
1451     # answer
1452     if( $error == 0 ) {
1453
1454         foreach my $answer ( @{$answer_l} ) {
1455             # check outgoing msg to xml validity
1456             my $answer_hash = &check_outgoing_xml_validity($answer, $session_id);
1457             if( not defined $answer_hash ) { next; }
1458
1459             $answer_header = @{$answer_hash->{'header'}}[0];
1460             @answer_target_l = @{$answer_hash->{'target'}};
1461             $answer_source = @{$answer_hash->{'source'}}[0];
1462
1463             # deliver msg to all targets
1464             foreach my $answer_target ( @answer_target_l ) {
1465
1466                 # targets of msg are all gosa-si-clients in known_clients_db
1467                 if( $answer_target eq "*" ) {
1468                     # answer is for all clients
1469                     my $sql_statement= "SELECT * FROM known_clients";
1470                     my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1471                     while( my ($hit_num, $hit) = each %{ $query_res } ) {
1472                         my $host_name = $hit->{hostname};
1473                         my $host_key = $hit->{hostkey};
1474                         my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1475                         &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1476                     }
1477                 }
1478
1479                 # targets of msg are all gosa-si-server in known_server_db
1480                 elsif( $answer_target eq "KNOWN_SERVER" ) {
1481                     # answer is for all server in known_server
1482                     my $sql_statement= "SELECT * FROM $known_server_tn";
1483                     my $query_res = $known_server_db->select_dbentry( $sql_statement );
1484                     while( my ($hit_num, $hit) = each %{ $query_res } ) {
1485                         my $host_name = $hit->{hostname};
1486                         my $host_key = $hit->{hostkey};
1487                         $answer =~ s/<target>\S+<\/target>/<target>$host_name<\/target>/g;
1488                         my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1489                         &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1490                     }
1491                 }
1492
1493                 # target of msg is GOsa
1494                                 elsif( $answer_target eq "GOSA" ) {
1495                                         my $session_id = ($1) if $answer =~ /<session_id>(\d+?)<\/session_id>/;
1496                                         my $add_on = "";
1497                     if( defined $session_id ) {
1498                         $add_on = ".session_id=$session_id";
1499                     }
1500                     # answer is for GOSA and has to returned to connected client
1501                     my $gosa_answer = &encrypt_msg($answer, $GosaPackages_key);
1502                     $client_answer = $gosa_answer.$add_on;
1503                 }
1504
1505                 # target of msg is job queue at this host
1506                 elsif( $answer_target eq "JOBDB") {
1507                     $answer =~ /<header>(\S+)<\/header>/;
1508                     my $header;
1509                     if( defined $1 ) { $header = $1; }
1510                     my $error = &send_msg_to_target($answer, $server_address, $GosaPackages_key, $header, $session_id);
1511                     &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1512                 }
1513
1514                 # Target of msg is a mac address
1515                 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 ) {
1516                     daemon_log("$session_id INFO: target is mac address '$answer_target', looking for host in known_clients and foreign_clients", 5);
1517
1518                     # Looking for macaddress in known_clients
1519                     my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$answer_target'";
1520                     my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1521                     my $found_ip_flag = 0;
1522                     while( my ($hit_num, $hit) = each %{ $query_res } ) {
1523                         my $host_name = $hit->{hostname};
1524                         my $host_key = $hit->{hostkey};
1525                         $answer =~ s/$answer_target/$host_name/g;
1526                         daemon_log("$session_id INFO: found host '$host_name', associated to '$answer_target'", 5);
1527                         my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1528                         &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1529                         $found_ip_flag++ ;
1530                     }
1531
1532                     # Looking for macaddress in foreign_clients
1533                     if ($found_ip_flag == 0) {
1534                         my $sql = "SELECT * FROM $foreign_clients_tn WHERE macaddress LIKE '$answer_target'";
1535                         my $res = $foreign_clients_db->select_dbentry($sql);
1536                         while( my ($hit_num, $hit) = each %{ $res } ) {
1537                             my $host_name = $hit->{hostname};
1538                             my $reg_server = $hit->{regserver};
1539                             daemon_log("$session_id INFO: found host '$host_name' with mac '$answer_target', registered at '$reg_server'", 5);
1540
1541                             # Fetch key for reg_server
1542                             my $reg_server_key;
1543                             my $sql = "SELECT * FROM $known_server_tn WHERE hostname='$reg_server'";
1544                             my $res = $known_server_db->select_dbentry($sql);
1545                             if (exists $res->{1}) {
1546                                 $reg_server_key = $res->{1}->{'hostkey'};
1547                             } else {
1548                                 daemon_log("$session_id ERROR: cannot find hostkey for '$host_name' in '$known_server_tn'", 1);
1549                                 daemon_log("$session_id ERROR: unable to forward answer to correct registration server, processing is aborted!", 1);
1550                                 $reg_server_key = undef;
1551                             }
1552
1553                             # Send answer to server where client is registered
1554                             if (defined $reg_server_key) {
1555                                 $answer =~ s/$answer_target/$host_name/g;
1556                                 my $error = &send_msg_to_target($answer, $reg_server, $reg_server_key, $answer_header, $session_id);
1557                                 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1558                                 $found_ip_flag++ ;
1559                             }
1560                         }
1561                     }
1562
1563                     # No mac to ip matching found
1564                     if( $found_ip_flag == 0) {
1565                         daemon_log("$session_id WARNING: no host found in known_clients or foreign_clients with mac address '$answer_target'", 3);
1566                         &reactivate_job_with_delay($session_id, $answer_target, $answer_header, 30);
1567                     }
1568
1569                 # Answer is for one specific host
1570                 } else {
1571                     # get encrypt_key
1572                     my $encrypt_key = &get_encrypt_key($answer_target);
1573                     if( not defined $encrypt_key ) {
1574                         # unknown target
1575                         daemon_log("$session_id WARNING: unknown target '$answer_target'", 3);
1576                         next;
1577                     }
1578                     my $error = &send_msg_to_target($answer, $answer_target, $encrypt_key, $answer_header,$session_id);
1579                     &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1580                 }
1581             }
1582         }
1583     }
1584
1585     my $filter = POE::Filter::Reference->new();
1586     my %result = (
1587             status => "seems ok to me",
1588             answer => $client_answer,
1589             );
1590
1591     my $output = $filter->put( [ \%result ] );
1592     print @$output;
1593
1594
1595 }
1596
1597 sub session_start {
1598     my ($kernel) = $_[KERNEL];
1599     $global_kernel = $kernel;
1600     $kernel->yield('register_at_foreign_servers');
1601         $kernel->yield('create_fai_server_db', $fai_server_tn );
1602         $kernel->yield('create_fai_release_db', $fai_release_tn );
1603     $kernel->yield('watch_for_next_tasks');
1604         $kernel->sig(USR1 => "sig_handler");
1605         $kernel->sig(USR2 => "recreate_packages_db");
1606         $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
1607         $kernel->delay_set('watch_for_done_jobs', $job_queue_loop_delay);
1608     $kernel->delay_set('watch_for_modified_jobs', $modified_jobs_loop_delay);
1609         $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
1610     $kernel->delay_set('watch_for_delivery_messages', $messaging_db_loop_delay);
1611         $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
1612     $kernel->delay_set('watch_for_old_known_clients', $job_queue_loop_delay);
1613
1614     # Start opsi check
1615     if ($opsi_enabled eq "true") {
1616         $kernel->delay_set('watch_for_opsi_jobs', $job_queue_opsi_delay);
1617     }
1618
1619 }
1620
1621
1622 sub watch_for_done_jobs {
1623         #CHECK: $heap for what?
1624         my ($kernel,$heap) = @_[KERNEL, HEAP];
1625
1626         my $sql_statement = "SELECT * FROM ".$job_queue_tn." WHERE ((status='done') AND (modified='0'))";
1627         my $res = $job_db->select_dbentry( $sql_statement );
1628
1629         while( my ($id, $hit) = each %{$res} ) {
1630                 my $jobdb_id = $hit->{id};
1631                 my $sql_statement = "DELETE FROM $job_queue_tn WHERE id=$jobdb_id";
1632                 my $res = $job_db->del_dbentry($sql_statement);
1633         }
1634
1635         $kernel->delay_set('watch_for_done_jobs',$job_queue_loop_delay);
1636 }
1637
1638
1639 sub watch_for_opsi_jobs {
1640     my ($kernel) = $_[KERNEL];
1641
1642     # 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
1643     # opsi install job is to parse the xml message. There is still the correct header.
1644     my $sql_statement = "SELECT * FROM ".$job_queue_tn." WHERE ((xmlmessage LIKE '%opsi_install_client</header>%') AND (status='processing') AND (siserver='localhost'))";
1645         my $res = $job_db->select_dbentry( $sql_statement );
1646
1647     # Ask OPSI for an update of the running jobs
1648     while (my ($id, $hit) = each %$res ) {
1649         # Determine current parameters of the job
1650         my $hostId = $hit->{'plainname'};
1651         my $macaddress = $hit->{'macaddress'};
1652         my $progress = $hit->{'progress'};
1653
1654         my $result= {};
1655
1656         # For hosts, only return the products that are or get installed
1657         my $callobj;
1658         $callobj = {
1659             method  => 'getProductStates_hash',
1660             params  => [ $hostId ],
1661             id  => 1,
1662         };
1663
1664         my $hres = $opsi_client->call($opsi_url, $callobj);
1665         #my ($hres_err, $hres_err_string) = &check_opsi_res($hres);
1666         if (not &check_opsi_res($hres)) {
1667             my $htmp= $hres->result->{$hostId};
1668
1669             # Check state != not_installed or action == setup -> load and add
1670             my $products= 0;
1671             my $installed= 0;
1672             my $installing = 0;
1673             my $error= 0;
1674             my @installed_list;
1675             my @error_list;
1676             my $act_status = "none";
1677             foreach my $product (@{$htmp}){
1678
1679                 if ($product->{'installationStatus'} ne "not_installed" or
1680                         $product->{'actionRequest'} eq "setup"){
1681
1682                     # Increase number of products for this host
1683                     $products++;
1684
1685                     if ($product->{'installationStatus'} eq "failed"){
1686                         $result->{$product->{'productId'}}= "error";
1687                         unshift(@error_list, $product->{'productId'});
1688                         $error++;
1689                     }
1690                     if ($product->{'installationStatus'} eq "installed" && $product->{'actionRequest'}  eq "none"){
1691                         $result->{$product->{'productId'}}= "installed";
1692                         unshift(@installed_list, $product->{'productId'});
1693                         $installed++;
1694                     }
1695                     if ($product->{'installationStatus'} eq "installing"){
1696                         $result->{$product->{'productId'}}= "installing";
1697                         $installing++;
1698                         $act_status = "installing - ".$product->{'productId'};
1699                     }
1700                 }
1701             }
1702
1703             # Estimate "rough" progress, avoid division by zero
1704             if ($products == 0) {
1705                 $result->{'progress'}= 0;
1706             } else {
1707                 $result->{'progress'}= int($installed * 100 / $products);
1708             }
1709
1710             # Set updates in job queue
1711             if ((not $error) && (not $installing) && ($installed)) {
1712                 $act_status = "installed - ".join(", ", @installed_list);
1713             }
1714             if ($error) {
1715                 $act_status = "error - ".join(", ", @error_list);
1716             }
1717             if ($progress ne $result->{'progress'} ) {
1718                 # Updating progress and result
1719                 my $update_statement = "UPDATE $job_queue_tn SET modified='1', progress='".$result->{'progress'}."', result='$act_status' WHERE macaddress LIKE '$macaddress' AND siserver='localhost'";
1720                 my $update_res = $job_db->update_dbentry($update_statement);
1721             }
1722             if ($progress eq 100) {
1723                 # Updateing status
1724                 my $done_statement = "UPDATE $job_queue_tn SET modified='1', ";
1725                 if ($error) {
1726                     $done_statement .= "status='error'";
1727                 } else {
1728                     $done_statement .= "status='done'";
1729                 }
1730                 $done_statement .= " WHERE macaddress LIKE '$macaddress' AND siserver='localhost'";
1731                 my $done_res = $job_db->update_dbentry($done_statement);
1732             }
1733
1734
1735         }
1736     }
1737
1738     $kernel->delay_set('watch_for_opsi_jobs', $job_queue_opsi_delay);
1739 }
1740
1741
1742 # If a job got an update or was modified anyway, send to all other si-server an update message of this jobs.
1743 sub watch_for_modified_jobs {
1744     my ($kernel,$heap) = @_[KERNEL, HEAP];
1745
1746     my $sql_statement = "SELECT * FROM $job_queue_tn WHERE (modified='1')";
1747     my $res = $job_db->select_dbentry( $sql_statement );
1748
1749     # if db contains no jobs which should be update, do nothing
1750     if (keys %$res != 0) {
1751
1752         if ($job_synchronization  eq "true") {
1753             # make out of the db result a gosa-si message
1754             my $update_msg = &db_res2si_msg ($res, "foreign_job_updates", "KNOWN_SERVER", "MY_LOCAL_ADDRESS");
1755
1756             # update all other SI-server
1757             &inform_all_other_si_server($update_msg);
1758         }
1759
1760         # set jobs all jobs to modified = 0, wait until the next modification for updates of other si-server
1761         $sql_statement = "UPDATE $job_queue_tn SET modified='0' ";
1762         $res = $job_db->update_dbentry($sql_statement);
1763     }
1764
1765     $kernel->delay_set('watch_for_modified_jobs', $modified_jobs_loop_delay);
1766 }
1767
1768
1769 sub watch_for_new_jobs {
1770         if($watch_for_new_jobs_in_progress == 0) {
1771                 $watch_for_new_jobs_in_progress = 1;
1772                 my ($kernel,$heap) = @_[KERNEL, HEAP];
1773
1774                 # check gosa job queue for jobs with executable timestamp
1775                 my $timestamp = &get_time();
1776                 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE siserver='localhost' AND status='waiting' AND (CAST(timestamp AS UNSIGNED)) < $timestamp ORDER BY timestamp";
1777                 my $res = $job_db->exec_statement( $sql_statement );
1778
1779                 # Merge all new jobs that would do the same actions
1780                 my @drops;
1781                 my $hits;
1782                 foreach my $hit (reverse @{$res} ) {
1783                         my $macaddress= lc @{$hit}[8];
1784                         my $headertag= @{$hit}[5];
1785                         if(
1786                                 defined($hits->{$macaddress}) &&
1787                                 defined($hits->{$macaddress}->{$headertag}) &&
1788                                 defined($hits->{$macaddress}->{$headertag}[0])
1789                         ) {
1790                                 push @drops, "DELETE FROM $job_queue_tn WHERE id = $hits->{$macaddress}->{$headertag}[0]";
1791                         }
1792                         $hits->{$macaddress}->{$headertag}= $hit;
1793                 }
1794
1795                 # Delete new jobs with a matching job in state 'processing'
1796                 foreach my $macaddress (keys %{$hits}) {
1797                         foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
1798                                 my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
1799                                 if(defined($jobdb_id)) {
1800                                         my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND headertag='$jobdb_headertag' AND status='processing'";
1801                                         my $res = $job_db->exec_statement( $sql_statement );
1802                                         foreach my $hit (@{$res}) {
1803                                                 push @drops, "DELETE FROM $job_queue_tn WHERE id=$jobdb_id";
1804                                         }
1805                                 } else {
1806                                         daemon_log("J ERROR: Job without id exists for macaddress $macaddress!", 1);
1807                                 }
1808                         }
1809                 }
1810
1811                 # Commit deletion
1812                 $job_db->exec_statementlist(\@drops);
1813
1814                 # Look for new jobs that could be executed
1815                 foreach my $macaddress (keys %{$hits}) {
1816
1817                         # Look if there is an executing job
1818                         my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND status='processing'";
1819                         my $res = $job_db->exec_statement( $sql_statement );
1820
1821                         # Skip new jobs for host if there is a processing job
1822                         if(defined($res) and defined @{$res}[0]) {
1823                                 # Prevent race condition if there is a trigger_activate job waiting and a goto-activation job processing
1824                                 my $row = @{$res}[0] if (ref $res eq 'ARRAY');
1825                                 if(@{$row}[5] eq 'trigger_action_reinstall') {
1826                                         my $sql_statement_2 =  "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND status='waiting' AND headertag = 'trigger_activate_new'";
1827                                         my $res_2 = $job_db->exec_statement( $sql_statement_2 );
1828                                         if(defined($res_2) and defined @{$res_2}[0]) {
1829                                                 # Set status from goto-activation to 'waiting' and update timestamp
1830                                                 $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'");
1831                                         }
1832                                 }
1833                                 next;
1834                         }
1835
1836                         foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
1837                                 my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
1838                                 if(defined($jobdb_id)) {
1839                                         my $job_msg = @{$hits->{$macaddress}->{$jobdb_headertag}}[7];
1840
1841                                         daemon_log("J DEBUG: its time to execute $job_msg", 7);
1842                                         my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$macaddress'";
1843                                         my $res_hash = $known_clients_db->select_dbentry( $sql_statement );
1844
1845                                         # expect macaddress is unique!!!!!!
1846                                         my $target = $res_hash->{1}->{hostname};
1847
1848                                         # change header
1849                                         $job_msg =~ s/<header>job_/<header>gosa_/;
1850
1851                                         # add sqlite_id
1852                                         $job_msg =~ s/<\/xml>$/<jobdb_id>$jobdb_id<\/jobdb_id><\/xml>/;
1853
1854                                         $job_msg =~ /<header>(\S+)<\/header>/;
1855                                         my $header = $1 ;
1856                                         my $func_error = &send_msg_to_target($job_msg, $server_address, $GosaPackages_key, $header, "J");
1857
1858                                         # update status in job queue to ...
1859                     # ... 'processing', for jobs: 'reinstall', 'update'
1860                     if (($header =~ /gosa_trigger_action_reinstall/)
1861                             || ($header =~ /gosa_trigger_activate_new/)
1862                             || ($header =~ /gosa_trigger_action_update/)) {
1863                         my $sql_statement = "UPDATE $job_queue_tn SET status='processing' WHERE id=$jobdb_id";
1864                         my $dbres = $job_db->update_dbentry($sql_statement);
1865                     }
1866
1867                     # ... 'done', for all other jobs, they are no longer needed in the jobqueue
1868                     else {
1869                         my $sql_statement = "UPDATE $job_queue_tn SET status='done' WHERE id=$jobdb_id";
1870                         my $dbres = $job_db->update_dbentry($sql_statement);
1871                     }
1872
1873
1874                                         # We don't want parallel processing
1875                                         last;
1876                                 }
1877                         }
1878                 }
1879
1880                 $watch_for_new_jobs_in_progress = 0;
1881                 $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
1882         }
1883 }
1884
1885
1886 sub watch_for_new_messages {
1887     my ($kernel,$heap) = @_[KERNEL, HEAP];
1888     my @coll_user_msg;   # collection list of outgoing messages
1889
1890     # check messaging_db for new incoming messages with executable timestamp
1891     my $timestamp = &get_time();
1892     my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( (CAST(timestamp AS UNSIGNED))<$timestamp AND flag='n' AND direction='in' )";
1893     my $res = $messaging_db->exec_statement( $sql_statement );
1894         foreach my $hit (@{$res}) {
1895
1896         # create outgoing messages
1897         my $message_to = @{$hit}[3];
1898         # translate message_to to plain login name
1899         my @message_to_l = split(/,/, $message_to);
1900                 my %receiver_h;
1901                 foreach my $receiver (@message_to_l) {
1902                         if ($receiver =~ /^u_([\s\S]*)$/) {
1903                                 $receiver_h{$1} = 0;
1904                         } elsif ($receiver =~ /^g_([\s\S]*)$/) {
1905                                 my $group_name = $1;
1906                                 # fetch all group members from ldap and add them to receiver hash
1907                                 my $ldap_handle = &get_ldap_handle();
1908                                 if (defined $ldap_handle) {
1909                                                 my $mesg = $ldap_handle->search(
1910                                                                                 base => $ldap_base,
1911                                                                                 scope => 'sub',
1912                                                                                 attrs => ['memberUid'],
1913                                                                                 filter => "cn=$group_name",
1914                                                                                 );
1915                                                 if ($mesg->count) {
1916                                                                 my @entries = $mesg->entries;
1917                                                                 foreach my $entry (@entries) {
1918                                                                                 my @receivers= $entry->get_value("memberUid");
1919                                                                                 foreach my $receiver (@receivers) {
1920                                                                                                 $receiver_h{$receiver} = 0;
1921                                                                                 }
1922                                                                 }
1923                                                 }
1924                                                 # translating errors ?
1925                                                 if ($mesg->code) {
1926                                                                 daemon_log("M ERROR: unable to translate group '$group_name' to user list for message delivery: $mesg->error", 1);
1927                                                 }
1928                                                 &release_ldap_handle($ldap_handle);
1929                                 # ldap handle error ?
1930                                 } else {
1931                                         daemon_log("M ERROR: unable to translate group '$group_name' to user list for message delivery: no ldap handle available", 1);
1932                                 }
1933                         } else {
1934                                 my $sbjct = &encode_base64(@{$hit}[1]);
1935                                 my $msg = &encode_base64(@{$hit}[7]);
1936                                 &daemon_log("M WARNING: unknown receiver '$receiver' for a user-message '$sbjct - $msg'", 3);
1937                         }
1938                 }
1939                 my @receiver_l = keys(%receiver_h);
1940
1941         my $message_id = @{$hit}[0];
1942
1943         #add each outgoing msg to messaging_db
1944         my $receiver;
1945         foreach $receiver (@receiver_l) {
1946             my $sql_statement = "INSERT INTO $messaging_tn (id, subject, message_from, message_to, flag, direction, delivery_time, message, timestamp) ".
1947                 "VALUES ('".
1948                 $message_id."', '".    # id
1949                 @{$hit}[1]."', '".     # subject
1950                 @{$hit}[2]."', '".     # message_from
1951                 $receiver."', '".      # message_to
1952                 "none"."', '".         # flag
1953                 "out"."', '".          # direction
1954                 @{$hit}[6]."', '".     # delivery_time
1955                 @{$hit}[7]."', '".     # message
1956                 $timestamp."'".     # timestamp
1957                 ")";
1958             &daemon_log("M DEBUG: $sql_statement", 1);
1959             my $res = $messaging_db->exec_statement($sql_statement);
1960             &daemon_log("M INFO: message '".@{$hit}[0]."' is prepared for delivery to receiver '$receiver'", 5);
1961         }
1962
1963         # set incoming message to flag d=deliverd
1964         $sql_statement = "UPDATE $messaging_tn SET flag='p' WHERE id='$message_id'";
1965         &daemon_log("M DEBUG: $sql_statement", 7);
1966         $res = $messaging_db->update_dbentry($sql_statement);
1967         &daemon_log("M INFO: message '$message_id' is set to flag 'p' (processed)", 5);
1968     }
1969
1970     $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
1971     return;
1972 }
1973
1974 sub watch_for_delivery_messages {
1975     my ($kernel, $heap) = @_[KERNEL, HEAP];
1976
1977     # select outgoing messages
1978     my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( flag='p' AND direction='out' )";
1979     #&daemon_log("0 DEBUG: $sql", 7);
1980     my $res = $messaging_db->exec_statement( $sql_statement );
1981
1982     # build out msg for each    usr
1983     foreach my $hit (@{$res}) {
1984         my $receiver = @{$hit}[3];
1985         my $msg_id = @{$hit}[0];
1986         my $subject = @{$hit}[1];
1987         my $message = @{$hit}[7];
1988
1989         # resolve usr -> host where usr is logged in
1990         my $sql = "SELECT * FROM $login_users_tn WHERE (user='$receiver')";
1991         #&daemon_log("0 DEBUG: $sql", 7);
1992         my $res = $login_users_db->exec_statement($sql);
1993
1994         # receiver is logged in nowhere
1995         if (not ref(@$res[0]) eq "ARRAY") { next; }
1996
1997         # receiver ist logged in at a client registered at local server
1998                 my $send_succeed = 0;
1999                 foreach my $hit (@$res) {
2000                                 my $receiver_host = @$hit[0];
2001                 my $delivered2host = 0;
2002                                 &daemon_log("M DEBUG: user '$receiver' is logged in at host '$receiver_host'", 7);
2003
2004                                 # Looking for host in know_clients_db
2005                                 my $sql = "SELECT * FROM $known_clients_tn WHERE (hostname='$receiver_host')";
2006                                 my $res = $known_clients_db->exec_statement($sql);
2007
2008                 # Host is known in known_clients_db
2009                 if (ref(@$res[0]) eq "ARRAY") {
2010                     my $receiver_key = @{@{$res}[0]}[2];
2011                     my %data = ('subject' => $subject, 'message' => $message, 'usr' => $receiver);
2012                     my $out_msg = &build_msg("usr_msg", $server_address, $receiver_host, \%data );
2013                     my $error = &send_msg_to_target($out_msg, $receiver_host, $receiver_key, "usr_msg", 0);
2014                     if ($error == 0 ) {
2015                         $send_succeed++ ;
2016                         $delivered2host++ ;
2017                         &daemon_log("M DEBUG: send message for user '$receiver' to host '$receiver_host'", 7);
2018                     } else {
2019                         &daemon_log("M DEBUG: cannot send message for user '$receiver' to host '$receiver_host'", 7);
2020                     }
2021                 }
2022
2023                 # Message already send, do not need to do anything more, otherwise ...
2024                 if ($delivered2host) { next;}
2025
2026                 # ...looking for host in foreign_clients_db
2027                 $sql = "SELECT * FROM $foreign_clients_tn WHERE (hostname='$receiver_host')";
2028                 $res = $foreign_clients_db->exec_statement($sql);
2029
2030                                 # Host is known in foreign_clients_db
2031                                 if (ref(@$res[0]) eq "ARRAY") {
2032                     my $registration_server = @{@{$res}[0]}[2];
2033
2034                     # Fetch encryption key for registration server
2035                     my $sql = "SELECT * FROM $known_server_tn WHERE (hostname='$registration_server')";
2036                     my $res = $known_server_db->exec_statement($sql);
2037                     if (ref(@$res[0]) eq "ARRAY") {
2038                         my $registration_server_key = @{@{$res}[0]}[3];
2039                         my %data = ('subject' => $subject, 'message' => $message, 'usr' => $receiver);
2040                         my $out_msg = &build_msg("usr_msg", $server_address, $receiver_host, \%data );
2041                         my $error = &send_msg_to_target($out_msg, $registration_server, $registration_server_key, "usr_msg", 0);
2042                         if ($error == 0 ) {
2043                             $send_succeed++ ;
2044                             $delivered2host++ ;
2045                             &daemon_log("M DEBUG: send message for user '$receiver' to server '$registration_server'", 7);
2046                         } else {
2047                             &daemon_log("M ERROR: cannot send message for user '$receiver' to server '$registration_server'", 1);
2048                         }
2049
2050                     } else {
2051                         &daemon_log("M ERROR: host '$receiver_host' is reported to be ".
2052                                 "registrated at server '$registration_server', ".
2053                                 "but no data available in known_server_db ", 1);
2054                     }
2055                 }
2056
2057                 if (not $delivered2host) {
2058                     &daemon_log("M ERROR: unable to send user message to host '$receiver_host'", 1);
2059                 }
2060                 }
2061
2062                 if ($send_succeed) {
2063                                 # set outgoing msg at db to deliverd
2064                                 my $sql = "UPDATE $messaging_tn SET flag='d' WHERE (id='$msg_id' AND direction='out' AND message_to='$receiver')";
2065                                 my $res = $messaging_db->exec_statement($sql);
2066                 &daemon_log("M INFO: send message for user '$receiver' to logged in hosts", 5);
2067                 } else {
2068             &daemon_log("M WARNING: failed to deliver message for user '$receiver'", 3);
2069         }
2070         }
2071
2072     $kernel->delay_set('watch_for_delivery_messages', $messaging_db_loop_delay);
2073     return;
2074 }
2075
2076
2077 sub watch_for_done_messages {
2078     my ($kernel,$heap) = @_[KERNEL, HEAP];
2079
2080     my $sql = "SELECT * FROM $messaging_tn WHERE (flag='p' AND direction='in')";
2081     #&daemon_log("0 DEBUG: $sql", 7);
2082     my $res = $messaging_db->exec_statement($sql);
2083
2084     foreach my $hit (@{$res}) {
2085         my $msg_id = @{$hit}[0];
2086
2087         my $sql = "SELECT * FROM $messaging_tn WHERE (id='$msg_id' AND direction='out' AND (NOT flag='s'))";
2088         #&daemon_log("0 DEBUG: $sql", 7);
2089         my $res = $messaging_db->exec_statement($sql);
2090
2091         # not all usr msgs have been seen till now
2092         if ( ref(@$res[0]) eq "ARRAY") { next; }
2093
2094         $sql = "DELETE FROM $messaging_tn WHERE (id='$msg_id')";
2095         #&daemon_log("0 DEBUG: $sql", 7);
2096         $res = $messaging_db->exec_statement($sql);
2097
2098     }
2099
2100     $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
2101     return;
2102 }
2103
2104
2105 sub watch_for_old_known_clients {
2106     my ($kernel,$heap) = @_[KERNEL, HEAP];
2107
2108     my $sql_statement = "SELECT * FROM $known_clients_tn";
2109     my $res = $known_clients_db->select_dbentry( $sql_statement );
2110
2111     my $cur_time = int(&get_time());
2112
2113     while ( my ($hit_num, $hit) = each %$res) {
2114         my $expired_timestamp = int($hit->{'timestamp'});
2115         $expired_timestamp =~ /(\d{4})(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)/;
2116         my $dt = DateTime->new( year   => $1,
2117                 month  => $2,
2118                 day    => $3,
2119                 hour   => $4,
2120                 minute => $5,
2121                 second => $6,
2122                 );
2123
2124         $dt->add( seconds => 2 * int($hit->{'keylifetime'}) );
2125         $expired_timestamp = $dt->ymd('').$dt->hms('');
2126         if ($cur_time > $expired_timestamp) {
2127             my $hostname = $hit->{'hostname'};
2128             my $del_sql = "DELETE FROM $known_clients_tn WHERE hostname='$hostname'";
2129             my $del_res = $known_clients_db->exec_statement($del_sql);
2130
2131             &main::daemon_log("0 INFO: timestamp '".$hit->{'timestamp'}."' of client '$hostname' is expired('$expired_timestamp'), client will be deleted from known_clients_db", 5);
2132         }
2133
2134     }
2135
2136     $kernel->delay_set('watch_for_old_known_clients', $job_queue_loop_delay);
2137 }
2138
2139
2140 sub watch_for_next_tasks {
2141     my ($kernel,$heap) = @_[KERNEL, HEAP];
2142
2143     my $sql = "SELECT * FROM $incoming_tn";
2144     my $res = $incoming_db->select_dbentry($sql);
2145
2146     while ( my ($hit_num, $hit) = each %$res) {
2147         my $headertag = $hit->{'headertag'};
2148         if ($headertag =~ /^answer_(\d+)/) {
2149             # do not start processing, this message is for a still running POE::Wheel
2150             next;
2151         }
2152         my $message_id = $hit->{'id'};
2153         my $session_id = $hit->{'sessionid'};
2154         &daemon_log("$session_id DEBUG: start processing for message with incoming id: '$message_id'", 7);
2155
2156         $kernel->yield('next_task', $hit);
2157
2158         my $sql = "DELETE FROM $incoming_tn WHERE id=$message_id";
2159         my $res = $incoming_db->exec_statement($sql);
2160     }
2161
2162     $kernel->delay_set('watch_for_next_tasks', 1);
2163 }
2164
2165
2166 sub get_ldap_handle {
2167         my ($session_id) = @_;
2168         my $heap;
2169
2170         if (not defined $session_id ) { $session_id = 0 };
2171         if ($session_id =~ /[^0-9]*/) { $session_id = 0 };
2172
2173         my ($package, $file, $row, $subroutine, $hasArgs, $wantArray, $evalText, $isRequire) = caller(1);
2174         my $caller_text = "subroutine $subroutine";
2175         if ($subroutine eq "(eval)") {
2176                 $caller_text = "eval block within file '$file' for '$evalText'";
2177         }
2178         daemon_log("$session_id INFO: new ldap handle for '$caller_text' required!", 7);
2179
2180 get_handle:
2181         my $ldap_handle = Net::LDAP->new( $ldap_uri );
2182         if (not ref $ldap_handle) {
2183                 daemon_log("$session_id ERROR: Connection to LDAP URI '$ldap_uri' failed! Retrying!", 1);
2184                 usleep(100000);
2185                 goto get_handle;
2186         } else {
2187                 daemon_log("$session_id DEBUG: Connection to LDAP URI '$ldap_uri' established.", 6);
2188         }
2189
2190         $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);
2191         return $ldap_handle;
2192 }
2193
2194
2195 sub release_ldap_handle {
2196         my ($ldap_handle) = @_ ;
2197         if(ref $ldap_handle) {
2198           $ldap_handle->disconnect();
2199   }
2200         &main::daemon_log("0 DEBUG: Released a ldap handle!", 6);
2201         return;
2202 }
2203
2204
2205 sub change_fai_state {
2206         my ($st, $targets, $session_id) = @_;
2207         $session_id = 0 if not defined $session_id;
2208         # Set FAI state to localboot
2209         my %mapActions= (
2210                 reboot    => '',
2211                 update    => 'softupdate',
2212                 localboot => 'localboot',
2213                 reinstall => 'install',
2214                 rescan    => '',
2215                 wake      => '',
2216                 memcheck  => 'memcheck',
2217                 sysinfo   => 'sysinfo',
2218                 install   => 'install',
2219         );
2220
2221         # Return if this is unknown
2222         if (!exists $mapActions{ $st }){
2223                 daemon_log("$session_id ERROR: unknown action '$st', can not translate ot FAIstate", 1);
2224                 return;
2225         }
2226
2227         my $state= $mapActions{ $st };
2228
2229         # Build search filter for hosts
2230         my $search= "(&(objectClass=GOhard)";
2231         foreach (@{$targets}){
2232                 $search.= "(macAddress=$_)";
2233         }
2234         $search.= ")";
2235
2236         # If there's any host inside of the search string, procress them
2237         if (!($search =~ /macAddress/)){
2238                 daemon_log("$session_id ERROR: no macAddress found in filter statement for LDAP search: '$search'", 1);
2239                 return;
2240         }
2241
2242         my $ldap_handle = &get_ldap_handle($session_id);
2243         # Perform search for Unit Tag
2244         my $mesg = $ldap_handle->search(
2245                 base   => $ldap_base,
2246                 scope  => 'sub',
2247                 attrs  => ['dn', 'FAIstate', 'objectClass'],
2248                 filter => "$search"
2249         );
2250
2251         if ($mesg->count) {
2252                 my @entries = $mesg->entries;
2253                 if (0 == @entries) {
2254                         daemon_log("$session_id ERROR: ldap search failed: ldap_base=$ldap_base, filter=$search", 1);
2255                 }
2256
2257                 foreach my $entry (@entries) {
2258                         # Only modify entry if it is not set to '$state'
2259                         if ($entry->get_value("FAIstate") ne "$state"){
2260                                 daemon_log("$session_id INFO: Setting FAIstate to '$state' for ".$entry->dn, 5);
2261                                 my $result;
2262                                 my %tmp = map { $_ => 1 } $entry->get_value("objectClass");
2263                                 if (exists $tmp{'FAIobject'}){
2264                                         if ($state eq ''){
2265                                                 $result= $ldap_handle->modify($entry->dn, changes => [ delete => [ FAIstate => [] ] ]);
2266                                         } else {
2267                                                 $result= $ldap_handle->modify($entry->dn, changes => [ replace => [ FAIstate => $state ] ]);
2268                                         }
2269                                 } elsif ($state ne ''){
2270                                         $result= $ldap_handle->modify($entry->dn, changes => [ add => [ objectClass => 'FAIobject' ], add => [ FAIstate => $state ] ]);
2271                                 }
2272
2273                                 # Errors?
2274                                 if ($result->code){
2275                                         daemon_log("$session_id Error: Setting FAIstate to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
2276                                 }
2277                         } else {
2278                                 daemon_log("$session_id DEBUG FAIstate at host '".$entry->dn."' already at state '$st'", 7);
2279                         }
2280                 }
2281         } else {
2282                 daemon_log("$session_id ERROR: LDAP search failed: ldap_base=$ldap_base, filter=$search", 1);
2283         }
2284         &release_ldap_handle($ldap_handle);
2285
2286         return;
2287 }
2288
2289
2290 sub change_goto_state {
2291     my ($st, $targets, $session_id) = @_;
2292     $session_id = 0  if not defined $session_id;
2293
2294     # Switch on or off?
2295     my $state= $st eq 'active' ? 'active': 'locked';
2296
2297     my $ldap_handle = &get_ldap_handle($session_id);
2298     if( defined($ldap_handle) ) {
2299
2300       # Build search filter for hosts
2301       my $search= "(&(objectClass=GOhard)";
2302       foreach (@{$targets}){
2303         $search.= "(macAddress=$_)";
2304       }
2305       $search.= ")";
2306
2307       # If there's any host inside of the search string, procress them
2308       if (!($search =~ /macAddress/)){
2309               &release_ldap_handle($ldap_handle);
2310         return;
2311       }
2312
2313       # Perform search for Unit Tag
2314       my $mesg = $ldap_handle->search(
2315           base   => $ldap_base,
2316           scope  => 'sub',
2317           attrs  => ['dn', 'gotoMode'],
2318           filter => "$search"
2319           );
2320
2321       if ($mesg->count) {
2322         my @entries = $mesg->entries;
2323         foreach my $entry (@entries) {
2324
2325           # Only modify entry if it is not set to '$state'
2326           if ($entry->get_value("gotoMode") ne $state){
2327
2328             daemon_log("$session_id INFO: Setting gotoMode to '$state' for ".$entry->dn, 5);
2329             my $result;
2330             $result= $ldap_handle->modify($entry->dn, changes => [replace => [ gotoMode => $state ] ]);
2331
2332             # Errors?
2333             if ($result->code){
2334               &daemon_log("$session_id Error: Setting gotoMode to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
2335             }
2336
2337           }
2338         }
2339       } else {
2340                 daemon_log("$session_id ERROR: LDAP search failed in function change_goto_state: ldap_base=$ldap_base, filter=$search", 1);
2341           }
2342
2343     }
2344         &release_ldap_handle($ldap_handle);
2345         return;
2346 }
2347
2348
2349 sub run_recreate_packages_db {
2350     my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];
2351     my $session_id = $session->ID;
2352         &main::daemon_log("$session_id INFO: Recreating FAI Packages DB ('$fai_release_tn', '$fai_server_tn', '$packages_list_tn')", 5);
2353         $kernel->yield('create_fai_release_db', $fai_release_tn);
2354         $kernel->yield('create_fai_server_db', $fai_server_tn);
2355         return;
2356 }
2357
2358
2359 sub run_create_fai_server_db {
2360     my ($kernel, $session, $heap, $table_name) = @_[KERNEL, SESSION, HEAP, ARG0];
2361     my $session_id = $session->ID;
2362     my $task = POE::Wheel::Run->new(
2363             Program => sub { &create_fai_server_db($table_name,$kernel, undef, $session_id) },
2364             StdoutEvent  => "session_run_result",
2365             StderrEvent  => "session_run_debug",
2366             CloseEvent   => "session_run_done",
2367             );
2368
2369     $heap->{task}->{ $task->ID } = $task;
2370     return;
2371 }
2372
2373
2374 sub create_fai_server_db {
2375         my ($table_name, $kernel, $dont_create_packages_list, $session_id) = @_;
2376         my $result;
2377
2378         if (not defined $session_id) { $session_id = 0; }
2379         my $ldap_handle = &get_ldap_handle($session_id);
2380         if(defined($ldap_handle)) {
2381                 daemon_log("$session_id INFO: create_fai_server_db: start", 5);
2382                 my $mesg= $ldap_handle->search(
2383                         base   => $ldap_base,
2384                         scope  => 'sub',
2385                         attrs  => ['FAIrepository', 'gosaUnitTag'],
2386                         filter => "(&(FAIrepository=*)(objectClass=FAIrepositoryServer))",
2387                 );
2388                 if($mesg->{'resultCode'} == 0 &&
2389                         $mesg->count != 0) {
2390                         foreach my $entry (@{$mesg->{entries}}) {
2391                                 if($entry->exists('FAIrepository')) {
2392                                         # Add an entry for each Repository configured for server
2393                                         foreach my $repo(@{$entry->get_value('FAIrepository', asref => 1)}) {
2394                                                 my($tmp_url,$tmp_server,$tmp_release,$tmp_sections) = split(/\|/, $repo);
2395                                                 my $tmp_tag= $entry->get_value('gosaUnitTag') || "";
2396                                                 $result= $fai_server_db->add_dbentry( {
2397                                                                 table => $table_name,
2398                                                                 primkey => ['server', 'fai_release', 'tag'],
2399                                                                 server => $tmp_url,
2400                                                                 fai_release => $tmp_release,
2401                                                                 sections => $tmp_sections,
2402                                                                 tag => (length($tmp_tag)>0)?$tmp_tag:"",
2403                                                         } );
2404                                         }
2405                                 }
2406                         }
2407                 }
2408                 daemon_log("$session_id INFO: create_fai_server_db: finished", 5);
2409                 &release_ldap_handle($ldap_handle);
2410
2411                 # TODO: Find a way to post the 'create_packages_list_db' event
2412                 if(not defined($dont_create_packages_list)) {
2413                         &create_packages_list_db(undef, $session_id);
2414                 }
2415         }
2416
2417         return $result;
2418 }
2419
2420
2421 sub run_create_fai_release_db {
2422         my ($kernel, $session, $heap, $table_name) = @_[KERNEL, SESSION, HEAP, ARG0];
2423         my $session_id = $session->ID;
2424         my $task = POE::Wheel::Run->new(
2425                 Program => sub { &create_fai_release_db($table_name, $session_id) },
2426                 StdoutEvent  => "session_run_result",
2427                 StderrEvent  => "session_run_debug",
2428                 CloseEvent   => "session_run_done",
2429         );
2430
2431         $heap->{task}->{ $task->ID } = $task;
2432         return;
2433 }
2434
2435
2436 sub create_fai_release_db {
2437         my ($table_name, $session_id) = @_;
2438         my $result;
2439
2440         # used for logging
2441         if (not defined $session_id) { $session_id = 0; }
2442
2443         my $ldap_handle = &get_ldap_handle($session_id);
2444         if(defined($ldap_handle)) {
2445                 daemon_log("$session_id INFO: create_fai_release_db: start",5);
2446                 my $mesg= $ldap_handle->search(
2447                         base   => $ldap_base,
2448                         scope  => 'sub',
2449                         attrs  => [],
2450                         filter => "(&(objectClass=organizationalUnit)(ou=fai))",
2451                 );
2452                 if(($mesg->code == 0) && ($mesg->count != 0))
2453                 {
2454                         daemon_log("$session_id DEBUG: create_fai_release_db: count " . $mesg->count,8);
2455
2456                         # Walk through all possible FAI container ou's
2457                         my @sql_list;
2458                         my $timestamp= &get_time();
2459                         foreach my $ou (@{$mesg->{entries}}) {
2460                                 my $tmp_classes= resolve_fai_classes($ou->dn, $ldap_handle, $session_id);
2461                                 if(defined($tmp_classes) && ref($tmp_classes) eq 'HASH') {
2462                                         my @tmp_array=get_fai_release_entries($tmp_classes);
2463                                         if(@tmp_array) {
2464                                                 foreach my $entry (@tmp_array) {
2465                                                         if(defined($entry) && ref($entry) eq 'HASH') {
2466                                                                 my $sql=
2467                                                                 "INSERT INTO $table_name "
2468                                                                 ."(timestamp, fai_release, class, type, state) VALUES ("
2469                                                                 .$timestamp.","
2470                                                                 ."'".$entry->{'release'}."',"
2471                                                                 ."'".$entry->{'class'}."',"
2472                                                                 ."'".$entry->{'type'}."',"
2473                                                                 ."'".$entry->{'state'}."')";
2474                                                                 push @sql_list, $sql;
2475                                                         }
2476                                                 }
2477                                         }
2478                                 }
2479                         }
2480
2481                         daemon_log("$session_id DEBUG: create_fai_release_db: Inserting ".scalar @sql_list." entries to DB",8);
2482             &release_ldap_handle($ldap_handle);
2483                         if(@sql_list) {
2484                                 unshift @sql_list, "VACUUM";
2485                                 unshift @sql_list, "DELETE FROM $table_name";
2486                                 $fai_release_db->exec_statementlist(\@sql_list);
2487                         }
2488                         daemon_log("$session_id DEBUG: create_fai_release_db: Done with inserting",7);
2489                 } else {
2490                         daemon_log("$session_id INFO: create_fai_release_db: error: " . $mesg->code, 5);
2491                 }
2492                 daemon_log("$session_id INFO: create_fai_release_db: finished",5);
2493         }
2494         return $result;
2495 }
2496
2497 sub get_fai_types {
2498         my $tmp_classes = shift || return undef;
2499         my @result;
2500
2501         foreach my $type(keys %{$tmp_classes}) {
2502                 if(defined($tmp_classes->{$type}[0]) && (!($tmp_classes->{$type}[0] =~ /^.*?removed.*?$/))) {
2503                         my $entry = {
2504                                 type => $type,
2505                                 state => $tmp_classes->{$type}[0],
2506                         };
2507                         push @result, $entry;
2508                 }
2509         }
2510
2511         return @result;
2512 }
2513
2514 sub get_fai_state {
2515         my $result = "";
2516         my $tmp_classes = shift || return $result;
2517
2518         foreach my $type(keys %{$tmp_classes}) {
2519                 if(defined($tmp_classes->{$type}[0])) {
2520                         $result = $tmp_classes->{$type}[0];
2521
2522                 # State is equal for all types in class
2523                         last;
2524                 }
2525         }
2526
2527         return $result;
2528 }
2529
2530 sub resolve_fai_classes {
2531         my ($fai_base, $ldap_handle, $session_id) = @_;
2532         if (not defined $session_id) { $session_id = 0; }
2533         my $result;
2534         my @possible_fai_classes= ("FAIscript", "FAIhook", "FAIpartitionTable", "FAItemplate", "FAIvariable", "FAIprofile", "FAIpackageList");
2535         my $fai_filter= "(|(&(objectClass=FAIclass)(|(objectClass=".join(")(objectClass=", @possible_fai_classes).")))(objectClass=FAIbranch))";
2536         my $fai_classes;
2537
2538         daemon_log("$session_id DEBUG: Searching for FAI entries in base $fai_base",7);
2539         my $mesg= $ldap_handle->search(
2540                 base   => $fai_base,
2541                 scope  => 'sub',
2542                 attrs  => ['cn','objectClass','FAIstate'],
2543                 filter => $fai_filter,
2544         );
2545         daemon_log("$session_id DEBUG: Found ".$mesg->count()." FAI entries",7);
2546
2547         if($mesg->{'resultCode'} == 0 &&
2548                 $mesg->count != 0) {
2549                 foreach my $entry (@{$mesg->{entries}}) {
2550                         if($entry->exists('cn')) {
2551                                 my $tmp_dn= $entry->dn();
2552                                 $tmp_dn= substr( $tmp_dn, 0, length($tmp_dn)
2553                                         - length($fai_base) - 1 );
2554
2555                                 # Skip classname and ou dn parts for class
2556                                 my $tmp_release = ($1) if $tmp_dn =~ /^[^,]+,[^,]+,(.*?)$/;
2557
2558                                 # Skip classes without releases
2559                                 if((!defined($tmp_release)) || length($tmp_release)==0) {
2560                                         next;
2561                                 }
2562
2563                                 my $tmp_cn= $entry->get_value('cn');
2564                                 my $tmp_state= $entry->get_value('FAIstate');
2565
2566                                 my $tmp_type;
2567                                 # Get FAI type
2568                                 for my $oclass(@{$entry->get_value('objectClass', asref => 1)}) {
2569                                         if(grep $_ eq $oclass, @possible_fai_classes) {
2570                                                 $tmp_type= $oclass;
2571                                                 last;
2572                                         }
2573                                 }
2574
2575                                 if($tmp_release =~ /^.*?,.*?$/ && (!($tmp_release =~ /^.*?\\,.*?$/))) {
2576                                         # A Subrelease
2577                                         my @sub_releases = split(/,/, $tmp_release);
2578
2579                                         # Walk through subreleases and build hash tree
2580                                         my $hash;
2581                                         while(my $tmp_sub_release = pop @sub_releases) {
2582                                                 $hash .= "\{'$tmp_sub_release'\}->";
2583                                         }
2584                                         eval('push @{$fai_classes->'.$hash.'{$tmp_cn}->{$tmp_type}}, (defined($tmp_state) && length($tmp_state)>0)?$tmp_state:"";');
2585                                 } else {
2586                                         # A branch, no subrelease
2587                                         push @{$fai_classes->{$tmp_release}->{$tmp_cn}->{$tmp_type}}, (defined($tmp_state) && length($tmp_state)>0)?$tmp_state:"";
2588                                 }
2589                         } elsif (!$entry->exists('cn')) {
2590                                 my $tmp_dn= $entry->dn();
2591                                 $tmp_dn= substr( $tmp_dn, 0, length($tmp_dn)
2592                                         - length($fai_base) - 1 );
2593                                 my $tmp_release = ($1) if $tmp_dn =~ /^(.*?)$/;
2594
2595                                 # Skip classes without releases
2596                                 if((!defined($tmp_release)) || length($tmp_release)==0) {
2597                                         next;
2598                                 }
2599
2600                                 if($tmp_release =~ /^.*?,.*?$/ && (!($tmp_release =~ /^.*?\\,.*?$/))) {
2601                                         # A Subrelease
2602                                         my @sub_releases= split(/,/, $tmp_release);
2603
2604                                         # Walk through subreleases and build hash tree
2605                                         my $hash;
2606                                         while(my $tmp_sub_release = pop @sub_releases) {
2607                                                 $hash .= "\{'$tmp_sub_release'\}->";
2608                                         }
2609                                         # Remove the last two characters
2610                                         chop($hash);
2611                                         chop($hash);
2612
2613                                         eval('$fai_classes->'.$hash.'= {}');
2614                                 } else {
2615                                         # A branch, no subrelease
2616                                         if(!exists($fai_classes->{$tmp_release})) {
2617                                                 $fai_classes->{$tmp_release} = {};
2618                                         }
2619                                 }
2620                         }
2621                 }
2622
2623                 # The hash is complete, now we can honor the copy-on-write based missing entries
2624                 foreach my $release (keys %$fai_classes) {
2625                         $result->{$release}= deep_copy(apply_fai_inheritance($fai_classes->{$release}));
2626                 }
2627         }
2628         return $result;
2629 }
2630
2631 sub apply_fai_inheritance {
2632        my $fai_classes = shift || return {};
2633        my $tmp_classes;
2634
2635        # Get the classes from the branch
2636        foreach my $class (keys %{$fai_classes}) {
2637                # Skip subreleases
2638                if($class =~ /^ou=.*$/) {
2639                        next;
2640                } else {
2641                        $tmp_classes->{$class}= deep_copy($fai_classes->{$class});
2642                }
2643        }
2644
2645        # Apply to each subrelease
2646        foreach my $subrelease (keys %{$fai_classes}) {
2647                if($subrelease =~ /ou=/) {
2648                        foreach my $tmp_class (keys %{$tmp_classes}) {
2649                                if(!exists($fai_classes->{$subrelease}->{$tmp_class})) {
2650                                        $fai_classes->{$subrelease}->{$tmp_class} =
2651                                        deep_copy($tmp_classes->{$tmp_class});
2652                                } else {
2653                                        foreach my $type (keys %{$tmp_classes->{$tmp_class}}) {
2654                                                if(!exists($fai_classes->{$subrelease}->{$tmp_class}->{$type})) {
2655                                                        $fai_classes->{$subrelease}->{$tmp_class}->{$type}=
2656                                                        deep_copy($tmp_classes->{$tmp_class}->{$type});
2657                                                }
2658                                        }
2659                                }
2660                        }
2661                }
2662        }
2663
2664        # Find subreleases in deeper levels
2665        foreach my $subrelease (keys %{$fai_classes}) {
2666                if($subrelease =~ /ou=/) {
2667                        foreach my $subsubrelease (keys %{$fai_classes->{$subrelease}}) {
2668                                if($subsubrelease =~ /ou=/) {
2669                                        apply_fai_inheritance($fai_classes->{$subrelease});
2670                                }
2671                        }
2672                }
2673        }
2674
2675        return $fai_classes;
2676 }
2677
2678 sub get_fai_release_entries {
2679         my $tmp_classes = shift || return;
2680         my $parent = shift || "";
2681         my @result = shift || ();
2682
2683         foreach my $entry (keys %{$tmp_classes}) {
2684                 if(defined($entry)) {
2685                         if($entry =~ /^ou=.*$/) {
2686                                 my $release_name = $entry;
2687                                 $release_name =~ s/ou=//g;
2688                                 if(length($parent)>0) {
2689                                         $release_name = $parent."/".$release_name;
2690                                 }
2691                                 my @bufentries = get_fai_release_entries($tmp_classes->{$entry}, $release_name, @result);
2692                                 foreach my $bufentry(@bufentries) {
2693                                         push @result, $bufentry;
2694                                 }
2695                         } else {
2696                                 my @types = get_fai_types($tmp_classes->{$entry});
2697                                 foreach my $type (@types) {
2698                                         push @result,
2699                                         {
2700                                                 'class' => $entry,
2701                                                 'type' => $type->{'type'},
2702                                                 'release' => $parent,
2703                                                 'state' => $type->{'state'},
2704                                         };
2705                                 }
2706                         }
2707                 }
2708         }
2709
2710         return @result;
2711 }
2712
2713 sub deep_copy {
2714         my $this = shift;
2715         if (not ref $this) {
2716                 $this;
2717         } elsif (ref $this eq "ARRAY") {
2718                 [map deep_copy($_), @$this];
2719         } elsif (ref $this eq "HASH") {
2720                 +{map { $_ => deep_copy($this->{$_}) } keys %$this};
2721         } else { die "what type is $_?" }
2722 }
2723
2724
2725 sub session_run_result {
2726     my ($kernel, $heap, $client_answer) = @_[KERNEL, HEAP, ARG0];
2727     $kernel->sig(CHLD => "child_reap");
2728 }
2729
2730 sub session_run_debug {
2731     my $result = $_[ARG0];
2732     print STDERR "$result\n";
2733 }
2734
2735 sub session_run_done {
2736     my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
2737     delete $heap->{task}->{$task_id};
2738         if (exists $heap->{ldap_handle}->{$task_id}) {
2739                 &release_ldap_handle($heap->{ldap_handle}->{$task_id});
2740         }
2741         delete $heap->{ldap_handle}->{$task_id};
2742 }
2743
2744
2745 sub create_sources_list {
2746         my $session_id = shift || 0;
2747         my $result="/tmp/gosa_si_tmp_sources_list";
2748
2749         # Remove old file
2750         if(stat($result)) {
2751                 unlink($result);
2752                 &main::daemon_log("$session_id DEBUG: remove an old version of '$result'", 7);
2753         }
2754
2755         my $fh;
2756         open($fh, ">$result");
2757         if (not defined $fh) {
2758                 &main::daemon_log("$session_id DEBUG: cannot open '$result' for writing", 7);
2759                 return undef;
2760         }
2761         if(defined($main::ldap_server_dn) and length($main::ldap_server_dn) > 0) {
2762                 my $ldap_handle = &get_ldap_handle($session_id);
2763                 my $mesg=$ldap_handle->search(
2764                         base    => $main::ldap_server_dn,
2765                         scope   => 'base',
2766                         attrs   => 'FAIrepository',
2767                         filter  => 'objectClass=FAIrepositoryServer'
2768                 );
2769                 if($mesg->count) {
2770                         foreach my $entry(@{$mesg->{'entries'}}) {
2771                                 foreach my $value(@{$entry->get_value('FAIrepository', asref => 1)}) {
2772                                         my ($server, $tag, $release, $sections)= split /\|/, $value;
2773                                         my $line = "deb $server $release";
2774                                         $sections =~ s/,/ /g;
2775                                         $line.= " $sections";
2776                                         print $fh $line."\n";
2777                                 }
2778                         }
2779                 }
2780                 &release_ldap_handle($ldap_handle);
2781         } else {
2782                 if (defined $main::ldap_server_dn){
2783                         &main::daemon_log("$session_id ERROR: something wrong with ldap_server_dn '$main::ldap_server_dn', abort create_sources_list", 1);
2784                 } else {
2785                         &main::daemon_log("$session_id ERROR: no ldap_server_dn found, abort create_sources_list", 1);
2786                 }
2787         }
2788         close($fh);
2789
2790         return $result;
2791 }
2792
2793
2794 sub run_create_packages_list_db {
2795     my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];
2796         my $session_id = $session->ID;
2797         my $task = POE::Wheel::Run->new(
2798                                         Priority => +20,
2799                                         Program => sub {&create_packages_list_db(undef, $session_id)},
2800                                         StdoutEvent  => "session_run_result",
2801                                         StderrEvent  => "session_run_debug",
2802                                         CloseEvent   => "session_run_done",
2803                                         );
2804         $heap->{task}->{ $task->ID } = $task;
2805 }
2806
2807
2808 sub create_packages_list_db {
2809         my ($sources_file, $session_id) = @_;
2810
2811         # it should not be possible to trigger a recreation of packages_list_db
2812         # while packages_list_db is under construction, so set flag packages_list_under_construction
2813         # which is tested befor recreation can be started
2814         if (-r $packages_list_under_construction) {
2815                 daemon_log("$session_id WARNING: packages_list_db is right now under construction, please wait until this process is finished", 3);
2816                 return;
2817         } else {
2818                 daemon_log("$session_id INFO: create_packages_list_db: start", 5);
2819                 # set packages_list_under_construction to true
2820                 system("touch $packages_list_under_construction");
2821                 @packages_list_statements=();
2822         }
2823
2824         if (not defined $session_id) { $session_id = 0; }
2825
2826         if (not defined $sources_file) {
2827                 &main::daemon_log("$session_id INFO: no sources_file given for creating packages list so trigger creation of it", 5);
2828                 $sources_file = &create_sources_list($session_id);
2829         }
2830
2831         if (not defined $sources_file) {
2832                 &main::daemon_log("$session_id ERROR: no sources_file given under '$sources_file', skip create_packages_list_db", 1);
2833                 unlink($packages_list_under_construction);
2834                 return;
2835         }
2836
2837         my $line;
2838
2839         open(CONFIG, "<$sources_file") or do {
2840                 daemon_log( "$session_id ERROR: create_packages_list_db: Failed to open '$sources_file'", 1);
2841                 unlink($packages_list_under_construction);
2842                 return;
2843         };
2844
2845         # Read lines
2846         while ($line = <CONFIG>){
2847                 # Unify
2848                 chop($line);
2849                 $line =~ s/^\s+//;
2850                 $line =~ s/^\s+/ /;
2851
2852                 # Strip comments
2853                 $line =~ s/#.*$//g;
2854
2855                 # Skip empty lines
2856                 if ($line =~ /^\s*$/){
2857                         next;
2858                 }
2859
2860                 # Interpret deb line
2861                 if ($line =~ /^deb [^\s]+\s[^\s]+\s[^\s]+/){
2862                         my( $baseurl, $dist, $sections ) = ($line =~ /^deb\s([^\s]+)\s+([^\s]+)\s+(.*)$/);
2863                         my $section;
2864                         foreach $section (split(' ', $sections)){
2865                                 &parse_package_info( $baseurl, $dist, $section, $session_id );
2866                         }
2867                 }
2868         }
2869
2870         close (CONFIG);
2871
2872         if(keys(%repo_dirs)) {
2873                 find(\&cleanup_and_extract, keys( %repo_dirs ));
2874                 &main::strip_packages_list_statements();
2875                 $packages_list_db->exec_statementlist(\@packages_list_statements);
2876         }
2877         unlink($packages_list_under_construction);
2878         daemon_log("$session_id INFO: create_packages_list_db: finished", 5);
2879         return;
2880 }
2881
2882 # This function should do some intensive task to minimize the db-traffic
2883 sub strip_packages_list_statements {
2884         my @existing_entries= @{$packages_list_db->exec_statement("SELECT * FROM $main::packages_list_tn")};
2885         my @new_statement_list=();
2886         my $hash;
2887         my $insert_hash;
2888         my $update_hash;
2889         my $delete_hash;
2890         my $known_packages_hash;
2891         my $local_timestamp=get_time();
2892
2893         foreach my $existing_entry (@existing_entries) {
2894                 $hash->{@{$existing_entry}[0]}->{@{$existing_entry}[1]}->{@{$existing_entry}[2]}= $existing_entry;
2895         }
2896
2897         foreach my $statement (@packages_list_statements) {
2898                 if($statement =~ /^INSERT/i) {
2899                         # Assign the values from the insert statement
2900                         my ($distribution,$package,$version,$section,$description,$template,$timestamp) = ($1,$2,$3,$4,$5,$6,$7) if $statement =~
2901                         /^INSERT\s+?INTO\s+?$main::packages_list_tn\s+?VALUES\s*?\('(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)'\s*?\)$/si;
2902                         if(exists($hash->{$distribution}->{$package}->{$version})) {
2903                                 # If section or description has changed, update the DB
2904                                 if(
2905                                         (! (@{$hash->{$distribution}->{$package}->{$version}}[3] eq $section)) or
2906                                         (! (@{$hash->{$distribution}->{$package}->{$version}}[4] eq $description))
2907                                 ) {
2908                                         @{$update_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,undef);
2909                                 } else {
2910                                         # package is already present in database. cache this knowledge for later use
2911                                         @{$known_packages_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,$template);
2912                                 }
2913                         } else {
2914                                 # Insert a non-existing entry to db
2915                                 @{$insert_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,$template);
2916                         }
2917                 } elsif ($statement =~ /^UPDATE/i) {
2918                         my ($template,$package,$version) = ($1,$2,$3) if $statement =~
2919                         /^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;
2920                         foreach my $distribution (keys %{$hash}) {
2921                                 if(exists($insert_hash->{$distribution}->{$package}->{$version})) {
2922                                         # update the insertion hash to execute only one query per package (insert instead insert+update)
2923                                         @{$insert_hash->{$distribution}->{$package}->{$version}}[5]= $template;
2924                                 } elsif(exists($hash->{$distribution}->{$package}->{$version})) {
2925                                         if( ! (@{$hash->{$distribution}->{$package}->{$version}}[5] eq $template)) {
2926                                                 my $section;
2927                                                 my $description;
2928                                                 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[3]) and
2929                                                         length(@{$update_hash->{$distribution}->{$package}->{$version}}[3]) > 0 ) {
2930                                                         $section= @{$update_hash->{$distribution}->{$package}->{$version}}[3];
2931                                                 }
2932                                                 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[4])) {
2933                                                         $description= @{$update_hash->{$distribution}->{$package}->{$version}}[4];
2934                                                 }
2935                                                 @{$update_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,$template);
2936                                         }
2937                                 }
2938                         }
2939                 }
2940         }
2941
2942         # Check for orphaned entries
2943         foreach my $existing_entry (@existing_entries) {
2944                 my $distribution= @{$existing_entry}[0];
2945                 my $package= @{$existing_entry}[1];
2946                 my $version= @{$existing_entry}[2];
2947                 my $section= @{$existing_entry}[3];
2948
2949                 if(
2950                         exists($insert_hash->{$distribution}->{$package}->{$version}) ||
2951                         exists($update_hash->{$distribution}->{$package}->{$version}) ||
2952                         exists($known_packages_hash->{$distribution}->{$package}->{$version})
2953                 ) {
2954                         next;
2955                 } else {
2956                         # Insert entry to delete hash
2957                         @{$delete_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section);
2958                 }
2959         }
2960
2961         # unroll the insert hash
2962         foreach my $distribution (keys %{$insert_hash}) {
2963                 foreach my $package (keys %{$insert_hash->{$distribution}}) {
2964                         foreach my $version (keys %{$insert_hash->{$distribution}->{$package}}) {
2965                                 push @new_statement_list, "INSERT INTO $main::packages_list_tn VALUES ('$distribution','$package','$version',"
2966                                 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[3]',"
2967                                 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[4]',"
2968                                 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[5]',"
2969                                 ."'$local_timestamp')";
2970                         }
2971                 }
2972         }
2973
2974         # unroll the update hash
2975         foreach my $distribution (keys %{$update_hash}) {
2976                 foreach my $package (keys %{$update_hash->{$distribution}}) {
2977                         foreach my $version (keys %{$update_hash->{$distribution}->{$package}}) {
2978                                 my $set = "";
2979                                 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[3])) {
2980                                         $set .= "section = '@{$update_hash->{$distribution}->{$package}->{$version}}[3]', ";
2981                                 }
2982                                 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[4])) {
2983                                         $set .= "description = '@{$update_hash->{$distribution}->{$package}->{$version}}[4]', ";
2984                                 }
2985                                 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[5])) {
2986                                         $set .= "template = '@{$update_hash->{$distribution}->{$package}->{$version}}[5]', ";
2987                                 }
2988                                 if(defined($set) and length($set) > 0) {
2989                                         $set .= "timestamp = '$local_timestamp'";
2990                                 } else {
2991                                         next;
2992                                 }
2993                                 push @new_statement_list,
2994                                 "UPDATE $main::packages_list_tn SET $set WHERE"
2995                                 ." distribution = '$distribution'"
2996                                 ." AND package = '$package'"
2997                                 ." AND version = '$version'";
2998                         }
2999                 }
3000         }
3001
3002         # unroll the delete hash
3003         foreach my $distribution (keys %{$delete_hash}) {
3004                 foreach my $package (keys %{$delete_hash->{$distribution}}) {
3005                         foreach my $version (keys %{$delete_hash->{$distribution}->{$package}}) {
3006                                 my $section = @{$delete_hash->{$distribution}->{$package}->{$version}}[3];
3007                                 push @new_statement_list, "DELETE FROM $main::packages_list_tn WHERE distribution='$distribution' AND package='$package' AND version='$version' AND section='$section'";
3008                         }
3009                 }
3010         }
3011
3012         unshift(@new_statement_list, "VACUUM");
3013
3014         @packages_list_statements = @new_statement_list;
3015 }
3016
3017
3018 sub parse_package_info {
3019     my ($baseurl, $dist, $section, $session_id)= @_;
3020     my ($package);
3021     if (not defined $session_id) { $session_id = 0; }
3022     my ($path) = ($baseurl =~ m%://[^/]*(.*)$%);
3023     $repo_dirs{ "${repo_path}/pool" } = 1;
3024
3025     foreach $package ("Packages.gz"){
3026         daemon_log("$session_id DEBUG: create_packages_list: fetch $baseurl, $dist, $section", 7);
3027         get_package( "$baseurl/dists/$dist/$section/binary-$arch/$package", "$outdir/$dist/$section", $session_id );
3028         parse_package( "$outdir/$dist/$section", $dist, $path, $session_id );
3029     }
3030
3031 }
3032
3033
3034 sub get_package {
3035     my ($url, $dest, $session_id)= @_;
3036     if (not defined $session_id) { $session_id = 0; }
3037
3038     my $tpath = dirname($dest);
3039     -d "$tpath" || mkpath "$tpath";
3040
3041     # This is ugly, but I've no time to take a look at "how it works in perl"
3042     if(0 == system("wget '$url' -O '$dest' 2>/dev/null") ) {
3043         system("gunzip -cd '$dest' > '$dest.in'");
3044         daemon_log("$session_id DEBUG: run command: gunzip -cd '$dest' > '$dest.in'", 7);
3045         unlink($dest);
3046         daemon_log("$session_id DEBUG: delete file '$dest'", 7);
3047     } else {
3048         daemon_log("$session_id ERROR: create_packages_list_db: get_packages: fetching '$url' into '$dest' failed!", 1);
3049     }
3050     return 0;
3051 }
3052
3053
3054 sub parse_package {
3055     my ($path, $dist, $srv_path, $session_id)= @_;
3056     if (not defined $session_id) { $session_id = 0;}
3057     my ($package, $version, $section, $description);
3058     my $PACKAGES;
3059     my $timestamp = &get_time();
3060
3061     if(not stat("$path.in")) {
3062         daemon_log("$session_id ERROR: create_packages_list: parse_package: file '$path.in' is not readable",1);
3063         return;
3064     }
3065
3066     open($PACKAGES, "<$path.in");
3067     if(not defined($PACKAGES)) {
3068         daemon_log("$session_id ERROR: create_packages_list_db: parse_package: cannot open '$path.in'",1);
3069         return;
3070     }
3071
3072     # Read lines
3073     while (<$PACKAGES>){
3074         my $line = $_;
3075         # Unify
3076         chop($line);
3077
3078         # Use empty lines as a trigger
3079         if ($line =~ /^\s*$/){
3080             my $sql = "INSERT INTO packages_list VALUES ('$dist', '$package', '$version', '$section', '$description', '', '$timestamp')";
3081             push(@packages_list_statements, $sql);
3082             $package = "none";
3083             $version = "none";
3084             $section = "none";
3085             $description = "none";
3086             next;
3087         }
3088
3089         # Trigger for package name
3090         if ($line =~ /^Package:\s/){
3091             ($package)= ($line =~ /^Package: (.*)$/);
3092             next;
3093         }
3094
3095         # Trigger for version
3096         if ($line =~ /^Version:\s/){
3097             ($version)= ($line =~ /^Version: (.*)$/);
3098             next;
3099         }
3100
3101         # Trigger for description
3102         if ($line =~ /^Description:\s/){
3103             ($description)= &encode_base64(($line =~ /^Description: (.*)$/));
3104             next;
3105         }
3106
3107         # Trigger for section
3108         if ($line =~ /^Section:\s/){
3109             ($section)= ($line =~ /^Section: (.*)$/);
3110             next;
3111         }
3112
3113         # Trigger for filename
3114         if ($line =~ /^Filename:\s/){
3115             my ($filename) = ($line =~ /^Filename: (.*)$/);
3116             store_fileinfo( $package, $filename, $dist, $srv_path, $version, $repo_path );
3117             next;
3118         }
3119     }
3120
3121     close( $PACKAGES );
3122     unlink( "$path.in" );
3123 }
3124
3125
3126 sub store_fileinfo {
3127     my( $package, $file, $dist, $path, $vers, $srvdir) = @_;
3128
3129     my %fileinfo = (
3130         'package' => $package,
3131         'dist' => $dist,
3132         'version' => $vers,
3133     );
3134
3135     $repo_files{ "${srvdir}/$file" } = \%fileinfo;
3136 }
3137
3138
3139 sub cleanup_and_extract {
3140         my $fileinfo = $repo_files{ $File::Find::name };
3141
3142         if( defined $fileinfo ) {
3143                 my $dir = "$outdir/$fileinfo->{ 'dist' }/debconf.d";
3144                 my $sql;
3145                 my $package = $fileinfo->{ 'package' };
3146                 my $newver = $fileinfo->{ 'version' };
3147
3148                 mkpath($dir);
3149                 system( "dpkg -e '$File::Find::name' '$dir/DEBIAN'" );
3150
3151                 if( -f "$dir/DEBIAN/templates" ) {
3152
3153                         daemon_log("0 DEBUG: Found debconf templates in '$package' - $newver", 7);
3154
3155                         my $tmpl= ""; {
3156                                 local $/=undef;
3157                                 open FILE, "$dir/DEBIAN/templates";
3158                                 $tmpl = &encode_base64(<FILE>);
3159                                 close FILE;
3160                         }
3161                         rmtree("$dir/DEBIAN/templates");
3162
3163                         $sql= "update $main::packages_list_tn set template = '$tmpl' where package = '$package' and version = '$newver';";
3164                         push @packages_list_statements, $sql;
3165                 }
3166         }
3167
3168         return;
3169 }
3170
3171
3172 sub register_at_foreign_servers {
3173     my ($kernel) = $_[KERNEL];
3174
3175         # Update status and update-time of all si-server with expired update_time and
3176         # block them for race conditional registration processes of other si-servers.
3177         my $act_time = &get_time();
3178         my $block_statement = "UPDATE $known_server_tn SET status='new_server',update_time='19700101000000' WHERE (CAST(update_time AS UNSIGNED))<$act_time ";
3179         &daemon_log("0 DEBUG: $block_statement", 7);
3180         my $block_res = $known_server_db->exec_statement($block_statement);
3181
3182         # Fetch all si-server from db where update_time is younger than act_time
3183         my $fetch_statement = "SELECT * FROM $known_server_tn WHERE update_time='19700101000000'";
3184         &daemon_log("0 DEBUG: $fetch_statement", 7);
3185         my $fetch_res = $known_server_db->exec_statement($fetch_statement);
3186
3187     # Detect already connected clients. Will be added to registration msg later.
3188     my $client_sql = "SELECT * FROM $known_clients_tn";
3189     my $client_res = $known_clients_db->exec_statement($client_sql);
3190
3191         # Send registration messag to all fetched si-server
3192     foreach my $hit (@$fetch_res) {
3193         my $hostname = @$hit[0];
3194         my $hostkey = &create_passwd;
3195
3196         # Add already connected clients to registration message
3197         my $myhash = &create_xml_hash('new_server', $server_address, $hostname);
3198         &add_content2xml_hash($myhash, 'key', $hostkey);
3199         map(&add_content2xml_hash($myhash, 'client', @{$_}[0].",".@{$_}[4]), @$client_res);
3200
3201         # Add locally loaded gosa-si modules to registration message
3202         my $loaded_modules = {};
3203         while (my ($package, $pck_info) = each %$known_modules) {
3204                         next if ((!defined(@$pck_info[2])) || (!(ref (@$pck_info[2]) eq 'HASH')));
3205                         foreach my $act_module (keys(%{@$pck_info[2]})) {
3206                                 $loaded_modules->{$act_module} = "";
3207                         }
3208                 }
3209         map(&add_content2xml_hash($myhash, "loaded_modules", $_), keys(%$loaded_modules));
3210
3211         # Add macaddress to registration message
3212         my ($host_ip, $host_port) = split(/:/, $hostname);
3213         my $local_ip = &get_local_ip_for_remote_ip($host_ip);
3214         my $network_interface= &get_interface_for_ip($local_ip);
3215         my $host_mac = &get_mac_for_interface($network_interface);
3216         &add_content2xml_hash($myhash, 'macaddress', $host_mac);
3217
3218         # Build registration message and send it
3219         my $foreign_server_msg = &create_xml_string($myhash);
3220         my $error = &send_msg_to_target($foreign_server_msg, $hostname, $ServerPackages_key, "new_server", 0);
3221     }
3222
3223
3224         # After n sec perform a check of all server registration processes
3225     $kernel->delay_set("control_server_registration", 2);
3226
3227         return;
3228 }
3229
3230
3231 sub control_server_registration {
3232         my ($kernel) = $_[KERNEL];
3233
3234         # Check if all registration processes succeed or not
3235         my $select_statement = "SELECT * FROM $known_server_tn WHERE status='new_server'";
3236         &daemon_log("0 DEBUG $select_statement", 7);
3237         my $select_res = $known_server_db->exec_statement($select_statement);
3238
3239         # If at least one registration process failed, maybe in case of a race condition
3240         # with a foreign registration process
3241         if (@$select_res > 0)
3242         {
3243                 # Release block statement 'new_server' to make the server accessible
3244                 # for foreign registration processes
3245                 my $update_statement = "UPDATE $known_server_tn SET status='waiting' WHERE status='new_server'";
3246                 &daemon_log("0 DEBUG: $update_statement", 7);
3247                 my $update_res = $known_server_db->exec_statement($update_statement);
3248
3249                 # Set a random delay to avoid the registration race condition
3250                 my $new_foreign_servers_register_delay = int(rand(4))+1;
3251                 $kernel->delay_set("register_at_foreign_servers", $new_foreign_servers_register_delay);
3252         }
3253         # If all registration processes succeed
3254         else
3255         {
3256                 $kernel->delay_set("register_at_foreign_servers", $foreign_servers_register_delay);
3257         }
3258
3259         return;
3260 }
3261
3262
3263 #==== MAIN = main ==============================================================
3264 #  parse commandline options
3265 Getopt::Long::Configure( "bundling" );
3266 GetOptions("h|help" => \&usage,
3267         "c|config=s" => \$cfg_file,
3268         "f|foreground" => \$foreground,
3269         "v|verbose+" => \$verbose,
3270         "no-arp+" => \$no_arp,
3271            );
3272
3273 #  read and set config parameters
3274 &check_cmdline_param ;
3275 &read_configfile($cfg_file, %cfg_defaults);
3276 &check_pid;
3277
3278 $SIG{CHLD} = 'IGNORE';
3279
3280 # forward error messages to logfile
3281 if( ! $foreground ) {
3282   open( STDIN,  '+>/dev/null' );
3283   open( STDOUT, '+>&STDIN'    );
3284   open( STDERR, '+>&STDIN'    );
3285 }
3286
3287 # Just fork, if we are not in foreground mode
3288 if( ! $foreground ) {
3289     chdir '/'                 or die "Can't chdir to /: $!";
3290     $pid = fork;
3291     setsid                    or die "Can't start a new session: $!";
3292     umask 0;
3293 } else {
3294     $pid = $$;
3295 }
3296
3297 # Do something useful - put our PID into the pid_file
3298 if( 0 != $pid ) {
3299     open( LOCK_FILE, ">$pid_file" );
3300     print LOCK_FILE "$pid\n";
3301     close( LOCK_FILE );
3302     if( !$foreground ) {
3303         exit( 0 )
3304     };
3305 }
3306
3307 # parse head url and revision from svn
3308 my $server_status_hash = { 'developmental'=>'revision', 'stable'=>'release'};
3309 $server_version =~ /^\$HeadURL: (\S+) \$:\$Rev: (\d+) \$$/;
3310 $server_headURL = defined $1 ? $1 : 'unknown' ;
3311 $server_revision = defined $2 ? $2 : 'unknown' ;
3312 if ($server_headURL =~ /\/tag\// ||
3313         $server_headURL =~ /\/branches\// ) {
3314     $server_status = "stable";
3315 } else {
3316     $server_status = "developmental" ;
3317 }
3318 # Prepare log file and set permissions
3319 $root_uid = getpwnam('root');
3320 $adm_gid = getgrnam('adm');
3321 open(FH, ">>$log_file");
3322 close FH;
3323 chmod(0440, $log_file);
3324 chown($root_uid, $adm_gid, $log_file);
3325 chown($root_uid, $adm_gid, "/var/lib/gosa-si");
3326
3327 daemon_log(" ", 1);
3328 daemon_log("$0 started!", 1);
3329 daemon_log("status: $server_status", 1);
3330 daemon_log($server_status_hash->{$server_status}.": $server_revision", 1);
3331
3332 # Buildup data bases
3333 {
3334     no strict "refs";
3335
3336     if ($db_module eq "DBmysql") {
3337         # connect to incoming_db
3338         $incoming_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3339
3340         # connect to gosa-si job queue
3341         $job_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3342
3343         # connect to known_clients_db
3344         $known_clients_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3345
3346         # connect to foreign_clients_db
3347         $foreign_clients_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3348
3349         # connect to known_server_db
3350         $known_server_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3351
3352         # connect to login_usr_db
3353         $login_users_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3354
3355         # connect to fai_server_db
3356         $fai_server_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3357
3358         # connect to fai_release_db
3359         $fai_release_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3360
3361         # connect to packages_list_db
3362         $packages_list_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3363
3364         # connect to messaging_db
3365         $messaging_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3366
3367     } elsif ($db_module eq "DBsqlite") {
3368         # connect to incoming_db
3369         unlink($incoming_file_name);
3370         $incoming_db = GOSA::DBsqlite->new($incoming_file_name);
3371         chmod(0640, $incoming_file_name);
3372         chown($root_uid, $adm_gid, $incoming_file_name);
3373
3374         # connect to gosa-si job queue
3375         $job_db = GOSA::DBsqlite->new($job_queue_file_name);
3376         chmod(0640, $job_queue_file_name);
3377         chown($root_uid, $adm_gid, $job_queue_file_name);
3378
3379         # connect to known_clients_db
3380         #unlink($known_clients_file_name);
3381         $known_clients_db = GOSA::DBsqlite->new($known_clients_file_name);
3382         chmod(0640, $known_clients_file_name);
3383         chown($root_uid, $adm_gid, $known_clients_file_name);
3384
3385         # connect to foreign_clients_db
3386         #unlink($foreign_clients_file_name);
3387         $foreign_clients_db = GOSA::DBsqlite->new($foreign_clients_file_name);
3388         chmod(0640, $foreign_clients_file_name);
3389         chown($root_uid, $adm_gid, $foreign_clients_file_name);
3390
3391         # connect to known_server_db
3392         #unlink($known_server_file_name);
3393         $known_server_db = GOSA::DBsqlite->new($known_server_file_name);
3394         chmod(0640, $known_server_file_name);
3395         chown($root_uid, $adm_gid, $known_server_file_name);
3396
3397         # connect to login_usr_db
3398         #unlink($login_users_file_name);
3399         $login_users_db = GOSA::DBsqlite->new($login_users_file_name);
3400         chmod(0640, $login_users_file_name);
3401         chown($root_uid, $adm_gid, $login_users_file_name);
3402
3403         # connect to fai_server_db
3404         unlink($fai_server_file_name);
3405         $fai_server_db = GOSA::DBsqlite->new($fai_server_file_name);
3406         chmod(0640, $fai_server_file_name);
3407         chown($root_uid, $adm_gid, $fai_server_file_name);
3408
3409         # connect to fai_release_db
3410         unlink($fai_release_file_name);
3411         $fai_release_db = GOSA::DBsqlite->new($fai_release_file_name);
3412         chmod(0640, $fai_release_file_name);
3413         chown($root_uid, $adm_gid, $fai_release_file_name);
3414
3415         # connect to packages_list_db
3416         unlink($packages_list_under_construction);
3417         $packages_list_db = GOSA::DBsqlite->new($packages_list_file_name);
3418         chmod(0640, $packages_list_file_name);
3419         chown($root_uid, $adm_gid, $packages_list_file_name);
3420
3421         # connect to messaging_db
3422         #unlink($messaging_file_name);
3423         $messaging_db = GOSA::DBsqlite->new($messaging_file_name);
3424         chmod(0640, $messaging_file_name);
3425         chown($root_uid, $adm_gid, $messaging_file_name);
3426     }
3427 }
3428
3429
3430 # Creating tables
3431 $messaging_db->create_table($messaging_tn, \@messaging_col_names);
3432 $packages_list_db->create_table($packages_list_tn, \@packages_list_col_names);
3433 $fai_release_db->create_table($fai_release_tn, \@fai_release_col_names);
3434 $fai_server_db->create_table($fai_server_tn, \@fai_server_col_names);
3435 $login_users_db->create_table($login_users_tn, \@login_users_col_names);
3436 $known_server_db->create_table($known_server_tn, \@known_server_col_names);
3437 $foreign_clients_db->create_table($foreign_clients_tn, \@foreign_clients_col_names);
3438 $known_clients_db->create_table($known_clients_tn, \@known_clients_col_names);
3439 $incoming_db->create_table($incoming_tn, \@incoming_col_names);
3440 $job_db->create_table($job_queue_tn, \@job_queue_col_names);
3441
3442 # create xml object used for en/decrypting
3443 $xml = new XML::Simple();
3444
3445
3446 # foreign servers
3447 my @foreign_server_list;
3448
3449 # add foreign server from cfg file
3450 if ($foreign_server_string ne "") {
3451     my @cfg_foreign_server_list = split(",", $foreign_server_string);
3452     foreach my $foreign_server (@cfg_foreign_server_list) {
3453         push(@foreign_server_list, $foreign_server);
3454     }
3455
3456     daemon_log("0 INFO: found foreign server in config file: ".join(", ", @foreign_server_list), 5);
3457 }
3458
3459 # Perform a DNS lookup for server registration if flag is true
3460 if ($dns_lookup eq "true") {
3461     # Add foreign server from dns
3462     my @tmp_servers;
3463     if (not $server_domain) {
3464         # Try our DNS Searchlist
3465         for my $domain(get_dns_domains()) {
3466             chomp($domain);
3467             my ($tmp_domains, $error_string) = &get_server_addresses($domain);
3468             if(@$tmp_domains) {
3469                 for my $tmp_server(@$tmp_domains) {
3470                     push @tmp_servers, $tmp_server;
3471                 }
3472             }
3473         }
3474         if(@tmp_servers && length(@tmp_servers)==0) {
3475             daemon_log("0 WARNING: no foreign gosa-si-server found in DNS for domain '$server_domain'", 3);
3476         }
3477     } else {
3478         @tmp_servers = &get_server_addresses($server_domain);
3479         if( 0 == @tmp_servers ) {
3480             daemon_log("0 WARNING: no foreign gosa-si-server found in DNS for domain '$server_domain'", 3);
3481         }
3482     }
3483
3484     daemon_log("0 INFO: found foreign server via DNS ".join(", ", @tmp_servers), 5);
3485
3486     foreach my $server (@tmp_servers) {
3487         unshift(@foreign_server_list, $server);
3488     }
3489 } else {
3490     daemon_log("0 INFO: DNS lookup for server registration is disabled", 5);
3491 }
3492
3493
3494 # eliminate duplicate entries
3495 @foreign_server_list = &del_doubles(@foreign_server_list);
3496 my $all_foreign_server = join(", ", @foreign_server_list);
3497 daemon_log("0 INFO: found foreign server in config file and DNS: '$all_foreign_server'", 5);
3498
3499 # add all found foreign servers to known_server
3500 my $cur_timestamp = &get_time();
3501 foreach my $foreign_server (@foreign_server_list) {
3502
3503         # do not add myself to known_server_db
3504         if (&is_local($foreign_server)) { next; }
3505         ######################################
3506
3507     my $res = $known_server_db->add_dbentry( {table=>$known_server_tn,
3508             primkey=>['hostname'],
3509             hostname=>$foreign_server,
3510             macaddress=>"",
3511             status=>'not_yet_registered',
3512             hostkey=>"none",
3513             loaded_modules => "none",
3514             timestamp=>$cur_timestamp,
3515                         update_time=>'19700101000000',
3516             } );
3517 }
3518
3519
3520 # Import all modules
3521 &import_modules;
3522
3523 # Check wether all modules are gosa-si valid passwd check
3524 &password_check;
3525
3526 # Prepare for using Opsi
3527 if ($opsi_enabled eq "true") {
3528     use JSON::RPC::Client;
3529     use XML::Quote qw(:all);
3530     $opsi_url= "https://".$opsi_admin.":".$opsi_password."@".$opsi_server.":4447/rpc";
3531     $opsi_client = new JSON::RPC::Client;
3532 }
3533
3534
3535 POE::Component::Server::TCP->new(
3536         Alias => "TCP_SERVER",
3537         Port => $server_port,
3538         ClientInput => sub {
3539                 my ($kernel, $input, $heap, $session) = @_[KERNEL, ARG0, HEAP, SESSION];
3540         my $session_id = $session->ID;
3541                 if ($input =~ /;([\d\.]+:[\d]+)$/)
3542                 {
3543                         &daemon_log("$session_id DEBUG: incoming message from '$1'", 7);
3544                 }
3545                 else
3546                 {
3547                         my $remote_ip = $heap->{'remote_ip'};
3548                         &daemon_log("$session_id DEBUG: incoming message from '$remote_ip'", 7);
3549                 }
3550                 push(@msgs_to_decrypt, $input);
3551                 $kernel->yield("msg_to_decrypt");
3552         },
3553         InlineStates => {
3554                 msg_to_decrypt => \&msg_to_decrypt,
3555                 next_task => \&next_task,
3556                 task_result => \&handle_task_result,
3557                 task_done   => \&handle_task_done,
3558                 task_debug  => \&handle_task_debug,
3559                 child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!"  },
3560         }
3561 );
3562
3563 daemon_log("0 INFO: start socket for incoming xml messages at port '$server_port' ", 1);
3564
3565 # create session for repeatedly checking the job queue for jobs
3566 POE::Session->create(
3567         inline_states => {
3568                 _start => \&session_start,
3569         register_at_foreign_servers => \&register_at_foreign_servers,
3570                 control_server_registration => \&control_server_registration,
3571         sig_handler => \&sig_handler,
3572         next_task => \&next_task,
3573         task_result => \&handle_task_result,
3574         task_done   => \&handle_task_done,
3575         task_debug  => \&handle_task_debug,
3576         watch_for_next_tasks => \&watch_for_next_tasks,
3577         watch_for_new_messages => \&watch_for_new_messages,
3578         watch_for_delivery_messages => \&watch_for_delivery_messages,
3579         watch_for_done_messages => \&watch_for_done_messages,
3580                 watch_for_new_jobs => \&watch_for_new_jobs,
3581         watch_for_modified_jobs => \&watch_for_modified_jobs,
3582         watch_for_done_jobs => \&watch_for_done_jobs,
3583         watch_for_opsi_jobs => \&watch_for_opsi_jobs,
3584         watch_for_old_known_clients => \&watch_for_old_known_clients,
3585         create_packages_list_db => \&run_create_packages_list_db,
3586         create_fai_server_db => \&run_create_fai_server_db,
3587         create_fai_release_db => \&run_create_fai_release_db,
3588                 recreate_packages_db => \&run_recreate_packages_db,
3589         session_run_result => \&session_run_result,
3590         session_run_debug => \&session_run_debug,
3591         session_run_done => \&session_run_done,
3592         child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!"  },
3593         }
3594 );
3595
3596
3597 POE::Kernel->run();
3598 exit;
3599