gosa-si/gosa-si-server

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