gosa-si/gosa-si-server

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