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