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