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