gosa-si/gosa-si-server

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