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 use strict;
  25 use warnings;
  26 use Getopt::Long;
  27 use Config::IniFiles;
  28 use POSIX;
  29
  30 use Fcntl;
  31 use IO::Socket::INET;
  32 use IO::Handle;
  33 use IO::Select;
  34 use Symbol qw(qualify_to_ref);
  35 use Crypt::Rijndael;
  36 use MIME::Base64;
  37 use Digest::MD5  qw(md5 md5_hex md5_base64);
  38 use XML::Simple;
  39 use Data::Dumper;
  40 use Sys::Syslog qw( :DEFAULT setlogsock);
  41 use Cwd;
  42 use File::Spec;
  43 use File::Basename;
  44 use File::Find;
  45 use File::Copy;
  46 use File::Path;
  47 use GOSA::DBsqlite;
  48 use GOSA::GosaSupportDaemon;
  49 use POE qw(Component::Server::TCP Wheel::Run Filter::Reference);
  50 use Net::LDAP;
  51 use Net::LDAP::Util qw(:escape);
  52
  53 my $modules_path = "/usr/lib/gosa-si/modules";
  54 use lib "/usr/lib/gosa-si/modules";
  55
  56 # TODO es gibt eine globale funktion get_ldap_handle
  57 # - ist in einer session dieses ldap handle schon vorhanden, wird es zurückgegeben
  58 # - ist es nicht vorhanden, wird es erzeugt, im heap für spätere ldap anfragen gespeichert und zurückgegeben
  59 # - sessions die kein ldap handle brauchen, sollen auch keins haben
  60 # - wird eine session geschlossen, muss das ldap verbindung vorher beendet werden
  61 our $global_kernel;
  62
  63 my (%cfg_defaults, $foreground, $verbose, $ping_timeout);
  64 my ($bus_activ, $bus, $msg_to_bus, $bus_cipher);
  65 my ($server);
  66 my ($gosa_server, $job_queue_timeout, $job_queue_loop_delay);
  67 my ($messaging_db_loop_delay);
  68 my ($known_modules);
  69 my ($pid_file, $procid, $pid, $log_file);
  70 my ($arp_activ, $arp_fifo);
  71 my ($xml);
  72 my $sources_list;
  73 my $max_clients;
  74 my %repo_files=();
  75 my $repo_path;
  76 my %repo_dirs=();
  77 # variables declared in config file are always set to 'our'
  78 our (%cfg_defaults, $log_file, $pid_file,
  79     $server_ip, $server_port, $SIPackages_key,
  80     $arp_activ, $gosa_unit_tag,
  81     $GosaPackages_key, $gosa_ip, $gosa_port, $gosa_timeout,
  82 );
  83
  84 # additional variable which should be globaly accessable
  85 our $server_address;
  86 our $server_mac_address;
  87 our $bus_address;
  88 our $gosa_address;
  89 our $no_bus;
  90 our $no_arp;
  91 our $verbose;
  92 our $forground;
  93 our $cfg_file;
  94 #our ($ldap_handle, $ldap_uri, $ldap_base, $ldap_admin_dn, $ldap_admin_password, $ldap_server_dn);
  95 our ($ldap_uri, $ldap_base, $ldap_admin_dn, $ldap_admin_password, $ldap_server_dn);
  96
  97
  98 # specifies the verbosity of the daemon_log
  99 $verbose = 0 ;
 100
 101 # if foreground is not null, script will be not forked to background
 102 $foreground = 0 ;
 103
 104 # specifies the timeout seconds while checking the online status of a registrating client
 105 $ping_timeout = 5;
 106
 107 $no_bus = 0;
 108 $bus_activ = "true";
 109 $no_arp = 0;
 110 my $packages_list_under_construction = 0;
 111
 112 our $prg= basename($0);
 113
 114 # holds all gosa jobs
 115 our $job_db;
 116 our $job_queue_tn = 'jobs';
 117 my $job_queue_file_name;
 118 my @job_queue_col_names = ("id INTEGER PRIMARY KEY",
 119                 "timestamp DEFAULT 'none'",
 120                 "status DEFAULT 'none'",
 121                 "result DEFAULT 'none'",
 122                 "progress DEFAULT 'none'",
 123         "headertag DEFAULT 'none'",
 124                 "targettag DEFAULT 'none'",
 125                 "xmlmessage DEFAULT 'none'",
 126                 "macaddress DEFAULT 'none'",
 127                 "plainname DEFAULT 'none'",
 128                 );
 129
 130 # holds all other gosa-sd as well as the gosa-sd-bus
 131 our $known_server_db;
 132 our $known_server_tn = "known_server";
 133 my $known_server_file_name;
 134 my @known_server_col_names = ("hostname", "status", "hostkey", "timestamp");
 135
 136 # holds all registrated clients
 137 our $known_clients_db;
 138 our $known_clients_tn = "known_clients";
 139 my $known_clients_file_name;
 140 my @known_clients_col_names = ("hostname", "status", "hostkey", "timestamp", "macaddress", "events");
 141
 142 # holds all logged in user at each client
 143 our $login_users_db;
 144 our $login_users_tn = "login_users";
 145 my $login_users_file_name;
 146 my @login_users_col_names = ("client", "user", "timestamp");
 147
 148 # holds all fai server, the debian release and tag
 149 our $fai_server_db;
 150 our $fai_server_tn = "fai_server";
 151 my $fai_server_file_name;
 152 our @fai_server_col_names = ("timestamp", "server", "release", "sections", "tag");
 153
 154 our $fai_release_db;
 155 our $fai_release_tn = "fai_release";
 156 my $fai_release_file_name;
 157 our @fai_release_col_names = ("timestamp", "release", "class", "type", "state");
 158
 159 # holds all packages available from different repositories
 160 our $packages_list_db;
 161 our $packages_list_tn = "packages_list";
 162 my $packages_list_file_name;
 163 our @packages_list_col_names = ("distribution", "package", "version", "section", "description", "template", "timestamp");
 164 my $outdir = "/tmp/packages_list_db";
 165 my $arch = "i386";
 166
 167 # holds all messages which should be delivered to a user
 168 our $messaging_db;
 169 our $messaging_tn = "messaging";
 170 our @messaging_col_names = ("id INTEGER", "subject", "message_from", "message_to",
 171         "flag", "direction", "delivery_time", "message", "timestamp" );
 172 my $messaging_file_name;
 173
 174 # path to directory to store client install log files
 175 our $client_fai_log_dir = "/var/log/fai";
 176
 177 # queue which stores taskes until one of the $max_children children are ready to process the task
 178 my @tasks = qw();
 179 my $max_children = 2;
 180
 181
 182 %cfg_defaults = (
 183 "general" => {
 184     "log-file" => [\$log_file, "/var/run/".$prg.".log"],
 185     "pid-file" => [\$pid_file, "/var/run/".$prg.".pid"],
 186     },
 187 "bus" => {
 188     "activ" => [\$bus_activ, "true"],
 189     },
 190 "server" => {
 191     "port" => [\$server_port, "20081"],
 192     "known-clients" => [\$known_clients_file_name, '/var/lib/gosa-si/clients.db' ],
 193     "known-servers" => [\$known_server_file_name, '/var/lib/gosa-si/servers.db'],
 194     "login-users" => [\$login_users_file_name, '/var/lib/gosa-si/users.db'],
 195     "fai-server" => [\$fai_server_file_name, '/var/lib/gosa-si/fai_server.db'],
 196     "fai-release" => [\$fai_release_file_name, '/var/lib/gosa-si/fai_release.db'],
 197     "packages-list" => [\$packages_list_file_name, '/var/lib/gosa-si/packages.db'],
 198     "messaging" => [\$messaging_file_name, '/var/lib/gosa-si/messaging.db'],
 199     "source-list" => [\$sources_list, '/etc/apt/sources.list'],
 200     "repo-path" => [\$repo_path, '/srv/www/repository'],
 201     "ldap-uri" => [\$ldap_uri, ""],
 202     "ldap-base" => [\$ldap_base, ""],
 203     "ldap-admin-dn" => [\$ldap_admin_dn, ""],
 204     "ldap-admin-password" => [\$ldap_admin_password, ""],
 205     "gosa-unit-tag" => [\$gosa_unit_tag, ""],
 206     "max-clients" => [\$max_clients, 10],
 207     },
 208 "GOsaPackages" => {
 209     "ip" => [\$gosa_ip, "0.0.0.0"],
 210     "port" => [\$gosa_port, "20082"],
 211     "job-queue" => [\$job_queue_file_name, '/var/lib/gosa-si/jobs.db'],
 212     "job-queue-loop-delay" => [\$job_queue_loop_delay, 3],
 213     "messaging-db-loop-delay" => [\$messaging_db_loop_delay, 3],
 214     "key" => [\$GosaPackages_key, "none"],
 215     },
 216 "SIPackages" => {
 217     "key" => [\$SIPackages_key, "none"],
 218     },
 219 );
 220
 221
 222 #===  FUNCTION  ================================================================
 223 #         NAME:  usage
 224 #   PARAMETERS:  nothing
 225 #      RETURNS:  nothing
 226 #  DESCRIPTION:  print out usage text to STDERR
 227 #===============================================================================
 228 sub usage {
 229     print STDERR << "EOF" ;
 230 usage: $prg [-hvf] [-c config]
 231
 232            -h        : this (help) message
 233            -c <file> : config file
 234            -f        : foreground, process will not be forked to background
 235            -v        : be verbose (multiple to increase verbosity)
 236            -no-bus   : starts $prg without connection to bus
 237            -no-arp   : starts $prg without connection to arp module
 238
 239 EOF
 240     print "\n" ;
 241 }
 242
 243
 244 #===  FUNCTION  ================================================================
 245 #         NAME:  read_configfile
 246 #   PARAMETERS:  cfg_file - string -
 247 #      RETURNS:  nothing
 248 #  DESCRIPTION:  read cfg_file and set variables
 249 #===============================================================================
 250 sub read_configfile {
 251     my $cfg;
 252     if( defined( $cfg_file) && ( (-s $cfg_file) > 0 )) {
 253         if( -r $cfg_file ) {
 254             $cfg = Config::IniFiles->new( -file => $cfg_file );
 255         } else {
 256             print STDERR "Couldn't read config file!\n";
 257         }
 258     } else {
 259         $cfg = Config::IniFiles->new() ;
 260     }
 261     foreach my $section (keys %cfg_defaults) {
 262         foreach my $param (keys %{$cfg_defaults{ $section }}) {
 263             my $pinfo = $cfg_defaults{ $section }{ $param };
 264             ${@$pinfo[ 0 ]} = $cfg->val( $section, $param, @$pinfo[ 1 ] );
 265         }
 266     }
 267 }
 268
 269
 270 #===  FUNCTION  ================================================================
 271 #         NAME:  logging
 272 #   PARAMETERS:  level - string - default 'info'
 273 #                msg - string -
 274 #                facility - string - default 'LOG_DAEMON'
 275 #      RETURNS:  nothing
 276 #  DESCRIPTION:  function for logging
 277 #===============================================================================
 278 sub daemon_log {
 279     # log into log_file
 280     my( $msg, $level ) = @_;
 281     if(not defined $msg) { return }
 282     if(not defined $level) { $level = 1 }
 283     if(defined $log_file){
 284         open(LOG_HANDLE, ">>$log_file");
 285         if(not defined open( LOG_HANDLE, ">>$log_file" )) {
 286             print STDERR "cannot open $log_file: $!";
 287             return }
 288             chomp($msg);
 289                         $msg =~s/\n//g;   # no newlines are allowed in log messages, this is important for later log parsing
 290             if($level <= $verbose){
 291                 my ($seconds, $minutes, $hours, $monthday, $month,
 292                         $year, $weekday, $yearday, $sommertime) = localtime(time);
 293                 $hours = $hours < 10 ? $hours = "0".$hours : $hours;
 294                 $minutes = $minutes < 10 ? $minutes = "0".$minutes : $minutes;
 295                 $seconds = $seconds < 10 ? $seconds = "0".$seconds : $seconds;
 296                 my @monthnames = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
 297                 $month = $monthnames[$month];
 298                 $monthday = $monthday < 10 ? $monthday = "0".$monthday : $monthday;
 299                 $year+=1900;
 300                 my $name = $prg;
 301
 302                 my $log_msg = "$month $monthday $hours:$minutes:$seconds $name $msg\n";
 303                 print LOG_HANDLE $log_msg;
 304                 if( $foreground ) {
 305                     print STDERR $log_msg;
 306                 }
 307             }
 308         close( LOG_HANDLE );
 309     }
 310 }
 311
 312
 313 #===  FUNCTION  ================================================================
 314 #         NAME:  check_cmdline_param
 315 #   PARAMETERS:  nothing
 316 #      RETURNS:  nothing
 317 #  DESCRIPTION:  validates commandline parameter
 318 #===============================================================================
 319 sub check_cmdline_param () {
 320     my $err_config;
 321     my $err_counter = 0;
 322         if(not defined($cfg_file)) {
 323                 $cfg_file = "/etc/gosa-si/server.conf";
 324                 if(! -r $cfg_file) {
 325                         $err_config = "please specify a config file";
 326                         $err_counter += 1;
 327                 }
 328     }
 329     if( $err_counter > 0 ) {
 330         &usage( "", 1 );
 331         if( defined( $err_config)) { print STDERR "$err_config\n"}
 332         print STDERR "\n";
 333         exit( -1 );
 334     }
 335 }
 336
 337
 338 #===  FUNCTION  ================================================================
 339 #         NAME:  check_pid
 340 #   PARAMETERS:  nothing
 341 #      RETURNS:  nothing
 342 #  DESCRIPTION:  handels pid processing
 343 #===============================================================================
 344 sub check_pid {
 345     $pid = -1;
 346     # Check, if we are already running
 347     if( open(LOCK_FILE, "<$pid_file") ) {
 348         $pid = <LOCK_FILE>;
 349         if( defined $pid ) {
 350             chomp( $pid );
 351             if( -f "/proc/$pid/stat" ) {
 352                 my($stat) = `cat /proc/$pid/stat` =~ m/$pid \((.+)\).*/;
 353                 if( $stat ) {
 354                                         daemon_log("ERROR: Already running",1);
 355                     close( LOCK_FILE );
 356                     exit -1;
 357                 }
 358             }
 359         }
 360         close( LOCK_FILE );
 361         unlink( $pid_file );
 362     }
 363
 364     # create a syslog msg if it is not to possible to open PID file
 365     if (not sysopen(LOCK_FILE, $pid_file, O_WRONLY|O_CREAT|O_EXCL, 0644)) {
 366         my($msg) = "Couldn't obtain lockfile '$pid_file' ";
 367         if (open(LOCK_FILE, '<', $pid_file)
 368                 && ($pid = <LOCK_FILE>))
 369         {
 370             chomp($pid);
 371             $msg .= "(PID $pid)\n";
 372         } else {
 373             $msg .= "(unable to read PID)\n";
 374         }
 375         if( ! ($foreground) ) {
 376             openlog( $0, "cons,pid", "daemon" );
 377             syslog( "warning", $msg );
 378             closelog();
 379         }
 380         else {
 381             print( STDERR " $msg " );
 382         }
 383         exit( -1 );
 384     }
 385 }
 386
 387 #===  FUNCTION  ================================================================
 388 #         NAME:  import_modules
 389 #   PARAMETERS:  module_path - string - abs. path to the directory the modules
 390 #                are stored
 391 #      RETURNS:  nothing
 392 #  DESCRIPTION:  each file in module_path which ends with '.pm' and activation
 393 #                state is on is imported by "require 'file';"
 394 #===============================================================================
 395 sub import_modules {
 396     daemon_log(" ", 1);
 397
 398     if (not -e $modules_path) {
 399         daemon_log("ERROR: cannot find directory or directory is not readable: $modules_path", 1);
 400     }
 401
 402     opendir (DIR, $modules_path) or die "ERROR while loading modules from directory $modules_path : $!\n";
 403     while (defined (my $file = readdir (DIR))) {
 404         if (not $file =~ /(\S*?).pm$/) {
 405             next;
 406         }
 407                 my $mod_name = $1;
 408
 409         if( $file =~ /ArpHandler.pm/ ) {
 410             if( $no_arp > 0 ) {
 411                 next;
 412             }
 413         }
 414
 415         eval { require $file; };
 416         if ($@) {
 417             daemon_log("ERROR: gosa-si-server could not load module $file", 1);
 418             daemon_log("$@", 5);
 419                 } else {
 420                         my $info = eval($mod_name.'::get_module_info()');
 421                         # Only load module if get_module_info() returns a non-null object
 422                         if( $info ) {
 423                                 my ($input_address, $input_key, $input, $input_active, $input_type) = @{$info};
 424                                 $known_modules->{$mod_name} = $info;
 425                                 daemon_log("INFO: module $mod_name loaded", 5);
 426                         }
 427                 }
 428     }
 429     close (DIR);
 430 }
 431
 432
 433 #===  FUNCTION  ================================================================
 434 #         NAME:  sig_int_handler
 435 #   PARAMETERS:  signal - string - signal arose from system
 436 #      RETURNS:  noting
 437 #  DESCRIPTION:  handels tasks to be done befor signal becomes active
 438 #===============================================================================
 439 sub sig_int_handler {
 440     my ($signal) = @_;
 441
 442 #       if (defined($ldap_handle)) {
 443 #               $ldap_handle->disconnect;
 444 #       }
 445     # TODO alle verbliebenden ldap verbindungen aus allen heaps beenden
 446
 447
 448     daemon_log("shutting down gosa-si-server", 1);
 449     system("kill `ps -C gosa-si-server -o pid=`");
 450 }
 451 $SIG{INT} = \&sig_int_handler;
 452
 453
 454 sub check_key_and_xml_validity {
 455     my ($crypted_msg, $module_key, $session_id) = @_;
 456     my $msg;
 457     my $msg_hash;
 458     my $error_string;
 459     eval{
 460         $msg = &decrypt_msg($crypted_msg, $module_key);
 461
 462         if ($msg =~ /<xml>/i){
 463             $msg =~ s/\s+/ /g;  # just for better daemon_log
 464             daemon_log("$session_id DEBUG: decrypted_msg: \n$msg", 8);
 465             $msg_hash = $xml->XMLin($msg, ForceArray=>1);
 466
 467             ##############
 468             # check header
 469             if( not exists $msg_hash->{'header'} ) { die "no header specified"; }
 470             my $header_l = $msg_hash->{'header'};
 471             if( 1 > @{$header_l} ) { die 'empty header tag'; }
 472             if( 1 < @{$header_l} ) { die 'more than one header specified'; }
 473             my $header = @{$header_l}[0];
 474             if( 0 == length $header) { die 'empty string in header tag'; }
 475
 476             ##############
 477             # check source
 478             if( not exists $msg_hash->{'source'} ) { die "no source specified"; }
 479             my $source_l = $msg_hash->{'source'};
 480             if( 1 > @{$source_l} ) { die 'empty source tag'; }
 481             if( 1 < @{$source_l} ) { die 'more than one source specified'; }
 482             my $source = @{$source_l}[0];
 483             if( 0 == length $source) { die 'source error'; }
 484
 485             ##############
 486             # check target
 487             if( not exists $msg_hash->{'target'} ) { die "no target specified"; }
 488             my $target_l = $msg_hash->{'target'};
 489             if( 1 > @{$target_l} ) { die 'empty target tag'; }
 490         }
 491     };
 492     if($@) {
 493         daemon_log("$session_id DEBUG: do not understand the message: $@", 7);
 494         $msg = undef;
 495         $msg_hash = undef;
 496     }
 497
 498     return ($msg, $msg_hash);
 499 }
 500
 501
 502 sub check_outgoing_xml_validity {
 503     my ($msg) = @_;
 504
 505     my $msg_hash;
 506     eval{
 507         $msg_hash = $xml->XMLin($msg, ForceArray=>1);
 508
 509         ##############
 510         # check header
 511         my $header_l = $msg_hash->{'header'};
 512         if( 1 != @{$header_l} ) {
 513             die 'no or more than one headers specified';
 514         }
 515         my $header = @{$header_l}[0];
 516         if( 0 == length $header) {
 517             die 'header has length 0';
 518         }
 519
 520         ##############
 521         # check source
 522         my $source_l = $msg_hash->{'source'};
 523         if( 1 != @{$source_l} ) {
 524             die 'no or more than 1 sources specified';
 525         }
 526         my $source = @{$source_l}[0];
 527         if( 0 == length $source) {
 528             die 'source has length 0';
 529         }
 530         unless( $source =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+$/ ||
 531                 $source =~ /^GOSA$/i ) {
 532             die "source '$source' is neither a complete ip-address with port nor 'GOSA'";
 533         }
 534
 535         ##############
 536         # check target
 537         my $target_l = $msg_hash->{'target'};
 538         if( 0 == @{$target_l} ) {
 539             die "no targets specified";
 540         }
 541         foreach my $target (@$target_l) {
 542             if( 0 == length $target) {
 543                 die "target has length 0";
 544             }
 545             unless( $target =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+$/ ||
 546                     $target =~ /^GOSA$/i ||
 547                     $target =~ /^\*$/ ||
 548                     $target =~ /KNOWN_SERVER/i ||
 549                     $target =~ /JOBDB/i ||
 550                     $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 ){
 551                 die "target '$target' is not a complete ip-address with port or a valid target name or a mac-address";
 552             }
 553         }
 554     };
 555     if($@) {
 556         daemon_log("WARNING: outgoing msg is not gosa-si envelope conform", 5);
 557         daemon_log("$@ ".(defined($msg) && length($msg)>0)?$msg:"Empty Message", 8);
 558         $msg_hash = undef;
 559     }
 560
 561     return ($msg_hash);
 562 }
 563
 564
 565 sub input_from_known_server {
 566     my ($input, $remote_ip, $session_id) = @_ ;
 567     my ($msg, $msg_hash, $module);
 568
 569     my $sql_statement= "SELECT * FROM known_server";
 570     my $query_res = $known_server_db->select_dbentry( $sql_statement );
 571
 572     while( my ($hit_num, $hit) = each %{ $query_res } ) {
 573         my $host_name = $hit->{hostname};
 574         if( not $host_name =~ "^$remote_ip") {
 575             next;
 576         }
 577         my $host_key = $hit->{hostkey};
 578         daemon_log("$session_id DEBUG: input_from_known_server: host_name: $host_name", 7);
 579         daemon_log("DEBUG: input_from_known_server: host_key: $host_key", 7);
 580
 581         # check if module can open msg envelope with module key
 582         my ($tmp_msg, $tmp_msg_hash) = &check_key_and_xml_validity($input, $host_key, $session_id);
 583         if( (!$tmp_msg) || (!$tmp_msg_hash) ) {
 584             daemon_log("$session_id DEBUG: input_from_known_server: deciphering raise error", 7);
 585             daemon_log("$@", 8);
 586             next;
 587         }
 588         else {
 589             $msg = $tmp_msg;
 590             $msg_hash = $tmp_msg_hash;
 591             $module = "SIPackages";
 592             last;
 593         }
 594     }
 595
 596     if( (!$msg) || (!$msg_hash) || (!$module) ) {
 597         daemon_log("$session_id DEBUG: Incoming message is not from a known server", 7);
 598     }
 599
 600     return ($msg, $msg_hash, $module);
 601 }
 602
 603
 604 sub input_from_known_client {
 605     my ($input, $remote_ip, $session_id) = @_ ;
 606     my ($msg, $msg_hash, $module);
 607
 608     my $sql_statement= "SELECT * FROM known_clients";
 609     my $query_res = $known_clients_db->select_dbentry( $sql_statement );
 610     while( my ($hit_num, $hit) = each %{ $query_res } ) {
 611         my $host_name = $hit->{hostname};
 612         if( not $host_name =~ /^$remote_ip:\d*$/) {
 613                 next;
 614                 }
 615         my $host_key = $hit->{hostkey};
 616         &daemon_log("$session_id DEBUG: input_from_known_client: host_name: $host_name", 7);
 617         &daemon_log("$session_id DEBUG: input_from_known_client: host_key: $host_key", 7);
 618
 619         # check if module can open msg envelope with module key
 620         ($msg, $msg_hash) = &check_key_and_xml_validity($input, $host_key, $session_id);
 621
 622         if( (!$msg) || (!$msg_hash) ) {
 623             &daemon_log("$session_id DEGUG: input_from_known_client: deciphering raise error", 7);
 624             &daemon_log("$@", 8);
 625             next;
 626         }
 627         else {
 628             $module = "SIPackages";
 629             last;
 630         }
 631     }
 632
 633     if( (!$msg) || (!$msg_hash) || (!$module) ) {
 634         &daemon_log("$session_id DEBUG: Incoming message is not from a known client", 7);
 635     }
 636
 637     return ($msg, $msg_hash, $module);
 638 }
 639
 640
 641 sub input_from_unknown_host {
 642     no strict "refs";
 643     my ($input, $session_id) = @_ ;
 644     my ($msg, $msg_hash, $module);
 645     my $error_string;
 646
 647         my %act_modules = %$known_modules;
 648
 649         while( my ($mod, $info) = each(%act_modules)) {
 650
 651         # check a key exists for this module
 652         my $module_key = ${$mod."_key"};
 653         if( not defined $module_key ) {
 654             if( $mod eq 'ArpHandler' ) {
 655                 next;
 656             }
 657             daemon_log("$session_id ERROR: no key specified in config file for $mod", 1);
 658             next;
 659         }
 660         daemon_log("$session_id DEBUG: $mod: $module_key", 7);
 661
 662         # check if module can open msg envelope with module key
 663         ($msg, $msg_hash) = &check_key_and_xml_validity($input, $module_key, $session_id);
 664         if( (not defined $msg) || (not defined $msg_hash) ) {
 665             next;
 666         }
 667         else {
 668             $module = $mod;
 669             last;
 670         }
 671     }
 672
 673     if( (!$msg) || (!$msg_hash) || (!$module)) {
 674         daemon_log("$session_id DEBUG: Incoming message is not from an unknown host", 7);
 675     }
 676
 677     return ($msg, $msg_hash, $module);
 678 }
 679
 680
 681 sub create_ciphering {
 682     my ($passwd) = @_;
 683         if((!defined($passwd)) || length($passwd)==0) {
 684                 $passwd = "";
 685         }
 686     $passwd = substr(md5_hex("$passwd") x 32, 0, 32);
 687     my $iv = substr(md5_hex('GONICUS GmbH'),0, 16);
 688     my $my_cipher = Crypt::Rijndael->new($passwd , Crypt::Rijndael::MODE_CBC());
 689     $my_cipher->set_iv($iv);
 690     return $my_cipher;
 691 }
 692
 693
 694 sub encrypt_msg {
 695     my ($msg, $key) = @_;
 696     my $my_cipher = &create_ciphering($key);
 697     my $len;
 698     {
 699             use bytes;
 700             $len= 16-length($msg)%16;
 701     }
 702     $msg = "\0"x($len).$msg;
 703     $msg = $my_cipher->encrypt($msg);
 704     chomp($msg = &encode_base64($msg));
 705     # there are no newlines allowed inside msg
 706     $msg=~ s/\n//g;
 707     return $msg;
 708 }
 709
 710
 711 sub decrypt_msg {
 712
 713     my ($msg, $key) = @_ ;
 714     $msg = &decode_base64($msg);
 715     my $my_cipher = &create_ciphering($key);
 716     $msg = $my_cipher->decrypt($msg);
 717     $msg =~ s/\0*//g;
 718     return $msg;
 719 }
 720
 721
 722 sub get_encrypt_key {
 723     my ($target) = @_ ;
 724     my $encrypt_key;
 725     my $error = 0;
 726
 727     # target can be in known_server
 728     if( not defined $encrypt_key ) {
 729         my $sql_statement= "SELECT * FROM known_server WHERE hostname='$target'";
 730         my $query_res = $known_server_db->select_dbentry( $sql_statement );
 731         while( my ($hit_num, $hit) = each %{ $query_res } ) {
 732             my $host_name = $hit->{hostname};
 733             if( $host_name ne $target ) {
 734                 next;
 735             }
 736             $encrypt_key = $hit->{hostkey};
 737             last;
 738         }
 739     }
 740
 741     # target can be in known_client
 742     if( not defined $encrypt_key ) {
 743         my $sql_statement= "SELECT * FROM known_clients WHERE hostname='$target'";
 744         my $query_res = $known_clients_db->select_dbentry( $sql_statement );
 745         while( my ($hit_num, $hit) = each %{ $query_res } ) {
 746             my $host_name = $hit->{hostname};
 747             if( $host_name ne $target ) {
 748                 next;
 749             }
 750             $encrypt_key = $hit->{hostkey};
 751             last;
 752         }
 753     }
 754
 755     return $encrypt_key;
 756 }
 757
 758
 759 #===  FUNCTION  ================================================================
 760 #         NAME:  open_socket
 761 #   PARAMETERS:  PeerAddr string something like 192.168.1.1 or 192.168.1.1:10000
 762 #                [PeerPort] string necessary if port not appended by PeerAddr
 763 #      RETURNS:  socket IO::Socket::INET
 764 #  DESCRIPTION:  open a socket to PeerAddr
 765 #===============================================================================
 766 sub open_socket {
 767     my ($PeerAddr, $PeerPort) = @_ ;
 768     if(defined($PeerPort)){
 769         $PeerAddr = $PeerAddr.":".$PeerPort;
 770     }
 771     my $socket;
 772     $socket = new IO::Socket::INET(PeerAddr => $PeerAddr,
 773             Porto => "tcp",
 774             Type => SOCK_STREAM,
 775             Timeout => 5,
 776             );
 777     if(not defined $socket) {
 778         return;
 779     }
 780 #    &daemon_log("DEBUG: open_socket: $PeerAddr", 7);
 781     return $socket;
 782 }
 783
 784
 785 #===  FUNCTION  ================================================================
 786 #         NAME:  get_ip
 787 #   PARAMETERS:  interface name (i.e. eth0)
 788 #      RETURNS:  (ip address)
 789 #  DESCRIPTION:  Uses ioctl to get ip address directly from system.
 790 #===============================================================================
 791 sub get_ip {
 792         my $ifreq= shift;
 793         my $result= "";
 794         my $SIOCGIFADDR= 0x8915;       # man 2 ioctl_list
 795         my $proto= getprotobyname('ip');
 796
 797         socket SOCKET, PF_INET, SOCK_DGRAM, $proto
 798                 or die "socket: $!";
 799
 800         if(ioctl SOCKET, $SIOCGIFADDR, $ifreq) {
 801                 my ($if, $sin)    = unpack 'a16 a16', $ifreq;
 802                 my ($port, $addr) = sockaddr_in $sin;
 803                 my $ip            = inet_ntoa $addr;
 804
 805                 if ($ip && length($ip) > 0) {
 806                         $result = $ip;
 807                 }
 808         }
 809
 810         return $result;
 811 }
 812
 813
 814 sub get_local_ip_for_remote_ip {
 815         my $remote_ip= shift;
 816         my $result="0.0.0.0";
 817
 818         if($remote_ip =~ /^(\d\d?\d?\.){3}\d\d?\d?$/) {
 819                 if($remote_ip eq "127.0.0.1") {
 820                         $result = "127.0.0.1";
 821                 } else {
 822                         my $PROC_NET_ROUTE= ('/proc/net/route');
 823
 824                         open(PROC_NET_ROUTE, "<$PROC_NET_ROUTE")
 825                                 or die "Could not open $PROC_NET_ROUTE";
 826
 827                         my @ifs = <PROC_NET_ROUTE>;
 828
 829                         close(PROC_NET_ROUTE);
 830
 831                         # Eat header line
 832                         shift @ifs;
 833                         chomp @ifs;
 834                         foreach my $line(@ifs) {
 835                                 my ($Iface,$Destination,$Gateway,$Flags,$RefCnt,$Use,$Metric,$Mask,$MTU,$Window,$IRTT)=split(/\s/, $line);
 836                                 my $destination;
 837                                 my $mask;
 838                                 my ($d,$c,$b,$a)=unpack('a2 a2 a2 a2', $Destination);
 839                                 $destination= sprintf("%d.%d.%d.%d", hex($a), hex($b), hex($c), hex($d));
 840                                 ($d,$c,$b,$a)=unpack('a2 a2 a2 a2', $Mask);
 841                                 $mask= sprintf("%d.%d.%d.%d", hex($a), hex($b), hex($c), hex($d));
 842                                 if(new NetAddr::IP($remote_ip)->within(new NetAddr::IP($destination, $mask))) {
 843                                         # destination matches route, save mac and exit
 844                                         $result= &get_ip($Iface);
 845                                         last;
 846                                 }
 847                         }
 848                 }
 849         } else {
 850                 daemon_log("get_local_ip_for_remote_ip was called with a non-ip parameter: $remote_ip", 1);
 851         }
 852         return $result;
 853 }
 854
 855
 856 sub send_msg_to_target {
 857     my ($msg, $address, $encrypt_key, $msg_header, $session_id) = @_ ;
 858     my $error = 0;
 859     my $header;
 860     my $new_status;
 861     my $act_status;
 862     my ($sql_statement, $res);
 863
 864     if( $msg_header ) {
 865         $header = "'$msg_header'-";
 866     } else {
 867         $header = "";
 868     }
 869
 870         # Patch the source ip
 871         if($msg =~ /<source>0\.0\.0\.0:\d*?<\/source>/) {
 872                 my $remote_ip = &get_local_ip_for_remote_ip(sprintf("%s", $address =~ /^([0-9\.]*?):.*$/));
 873                 $msg =~ s/<source>(0\.0\.0\.0):(\d*?)<\/source>/<source>$remote_ip:$2<\/source>/s;
 874         }
 875
 876     # encrypt xml msg
 877     my $crypted_msg = &encrypt_msg($msg, $encrypt_key);
 878
 879     # opensocket
 880     my $socket = &open_socket($address);
 881     if( !$socket ) {
 882         daemon_log("$session_id ERROR: cannot send ".$header."msg to $address , host not reachable", 1);
 883         $error++;
 884     }
 885
 886     if( $error == 0 ) {
 887         # send xml msg
 888         print $socket $crypted_msg."\n";
 889
 890         daemon_log("$session_id INFO: send ".$header."msg to $address", 5);
 891         #daemon_log("DEBUG: message:\n$msg", 9);
 892
 893     }
 894
 895     # close socket in any case
 896     if( $socket ) {
 897         close $socket;
 898     }
 899
 900     if( $error > 0 ) { $new_status = "down"; }
 901     else { $new_status = $msg_header; }
 902
 903
 904     # known_clients
 905     $sql_statement = "SELECT * FROM known_clients WHERE hostname='$address'";
 906     $res = $known_clients_db->select_dbentry($sql_statement);
 907     if( keys(%$res) > 0) {
 908         $act_status = $res->{1}->{'status'};
 909         if( $act_status eq "down" ) {
 910             $sql_statement = "DELETE FROM known_clients WHERE hostname='$address'";
 911             $res = $known_clients_db->del_dbentry($sql_statement);
 912             daemon_log("$session_id WARNING: failed 2x to send msg to host '$address', delete host from known_clients", 3);
 913         } else {
 914             $sql_statement = "UPDATE known_clients SET status='$new_status' WHERE hostname='$address'";
 915             $res = $known_clients_db->update_dbentry($sql_statement);
 916             if($new_status eq "down"){
 917                 daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
 918             } else {
 919                 daemon_log("$session_id INFO: set '$address' from status '$act_status' to '$new_status'", 5);
 920             }
 921         }
 922     }
 923
 924     # known_server
 925     $sql_statement = "SELECT * FROM known_server WHERE hostname='$address'";
 926     $res = $known_server_db->select_dbentry($sql_statement);
 927     if( keys(%$res) > 0 ) {
 928         $act_status = $res->{1}->{'status'};
 929         if( $act_status eq "down" ) {
 930             $sql_statement = "DELETE FROM known_server WHERE hostname='$address'";
 931             $res = $known_server_db->del_dbentry($sql_statement);
 932             daemon_log("$session_id WARNING: failed 2x to a send msg to host '$address', delete host from known_server", 3);
 933         }
 934         else {
 935             $sql_statement = "UPDATE known_server SET status='$new_status' WHERE hostname='$address'";
 936             $res = $known_server_db->update_dbentry($sql_statement);
 937             if($new_status eq "down"){
 938                 daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
 939             }
 940             else {
 941                 daemon_log("$session_id INFO: set '$address' from status '$act_status' to '$new_status'", 5);
 942             }
 943         }
 944     }
 945     return $error;
 946 }
 947
 948
 949 sub update_jobdb_status_for_send_msgs {
 950     my ($answer, $error) = @_;
 951     if( $answer =~ /<jobdb_id>(\d+)<\/jobdb_id>/ ) {
 952         my $jobdb_id = $1;
 953
 954         # sending msg faild
 955         if( $error ) {
 956             if (not $answer =~ /<header>trigger_action_reinstall<\/header>/) {
 957                 my $sql_statement = "UPDATE $job_queue_tn ".
 958                     "SET status='error', result='can not deliver msg, please consult log file' ".
 959                     "WHERE id='$jobdb_id'";
 960                 my $res = $job_db->update_dbentry($sql_statement);
 961             }
 962
 963         # sending msg was successful
 964         } else {
 965             my $sql_statement = "UPDATE $job_queue_tn ".
 966                 "SET status='done' ".
 967                 "WHERE id='$jobdb_id' AND status='processed'";
 968             my $res = $job_db->update_dbentry($sql_statement);
 969         }
 970     }
 971 }
 972
 973 sub _start {
 974     my ($kernel) = $_[KERNEL];
 975     &trigger_db_loop($kernel);
 976     $global_kernel = $kernel;
 977         $kernel->yield('create_fai_server_db', $fai_server_tn );
 978         $kernel->yield('create_fai_release_db', $fai_release_tn );
 979         $kernel->sig(USR1 => "sig_handler");
 980         $kernel->sig(USR2 => "create_packages_list_db");
 981 }
 982
 983 sub sig_handler {
 984         my ($kernel, $signal) = @_[KERNEL, ARG0] ;
 985         daemon_log("0 INFO got signal '$signal'", 1);
 986         $kernel->sig_handled();
 987         return;
 988 }
 989
 990 sub next_task {
 991     my ($session, $heap) = @_[SESSION, HEAP];
 992
 993     while ( keys( %{ $heap->{task} } ) < $max_children ) {
 994         my $next_task = shift @tasks;
 995         last unless defined $next_task;
 996
 997         my $task = POE::Wheel::Run->new(
 998                 Program => sub { process_task($session, $heap, $next_task) },
 999                 StdioFilter => POE::Filter::Reference->new(),
1000                 StdoutEvent  => "task_result",
1001                 StderrEvent  => "task_debug",
1002                 CloseEvent   => "task_done",
1003                );
1004
1005         $heap->{task}->{ $task->ID } = $task;
1006     }
1007 }
1008
1009 sub handle_task_result {
1010     my ($kernel, $heap, $result) = @_[KERNEL, HEAP, ARG0];
1011     my $client_answer = $result->{'answer'};
1012     if( $client_answer =~ s/session_id=(\d+)$// ) {
1013         my $session_id = $1;
1014         if( defined $session_id ) {
1015             my $session_reference = $kernel->ID_id_to_session($session_id);
1016             if( defined $session_reference ) {
1017                 $heap = $session_reference->get_heap();
1018             }
1019         }
1020
1021         if(exists $heap->{'client'}) {
1022             $heap->{'client'}->put($client_answer);
1023         }
1024     }
1025     $kernel->sig(CHLD => "child_reap");
1026 }
1027
1028 sub handle_task_debug {
1029     my $result = $_[ARG0];
1030     print STDERR "$result\n";
1031 }
1032
1033 sub handle_task_done {
1034     my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
1035     delete $heap->{task}->{$task_id};
1036     $kernel->yield("next_task");
1037 }
1038
1039 sub process_task {
1040     no strict "refs";
1041     my ($session, $heap, $input) = @_;
1042     my $session_id = $session->ID;
1043     my ($msg, $msg_hash, $module);
1044     my $error = 0;
1045     my $answer_l;
1046     my ($answer_header, @answer_target_l, $answer_source);
1047     my $client_answer = "";
1048
1049     daemon_log("", 5);
1050     daemon_log("$session_id INFO: Incoming msg with session ID $session_id from '".$heap->{'remote_ip'}."'", 5);
1051     #daemon_log("$session_id DEBUG: Incoming msg:\n$input", 9);
1052
1053     ####################
1054     # check incoming msg
1055     # msg is from a new client or gosa
1056     ($msg, $msg_hash, $module) = &input_from_unknown_host($input, $session_id);
1057     # msg is from a gosa-si-server or gosa-si-bus
1058     if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1059         ($msg, $msg_hash, $module) = &input_from_known_server($input, $heap->{'remote_ip'}, $session_id);
1060     }
1061     # msg is from a gosa-si-client
1062     if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1063         ($msg, $msg_hash, $module) = &input_from_known_client($input, $heap->{'remote_ip'}, $session_id);
1064     }
1065     # an error occurred
1066     if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1067         # if an incoming msg could not be decrypted (maybe a wrong key), send client a ping. If the client
1068         # could not understand a msg from its server the client cause a re-registering process
1069         daemon_log("$session_id INFO cannot understand incoming msg, send 'ping'-msg to all host with ip '".$heap->{remote_ip}."' to cause a re-registering of the client if necessary", 5);
1070         my $sql_statement = "SELECT * FROM $main::known_clients_tn WHERE (hostname LIKE '".$heap->{'remote_ip'}."%')";
1071         my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1072         while( my ($hit_num, $hit) = each %{ $query_res } ) {
1073             my $host_name = $hit->{'hostname'};
1074             my $host_key = $hit->{'hostkey'};
1075             my $ping_msg = "<xml> <header>gosa_ping</header> <source>$server_address</source> <target>$host_name</target></xml>";
1076             my $error = &send_msg_to_target($ping_msg, $host_name, $host_key, "gosa_ping", $session_id);
1077             &update_jobdb_status_for_send_msgs($ping_msg, $error);
1078         }
1079         $error++;
1080     }
1081
1082     ######################
1083     # process incoming msg
1084     if( $error == 0) {
1085         daemon_log("$session_id INFO: Incoming msg with header '".@{$msg_hash->{'header'}}[0].
1086                                 "' from '".$heap->{'remote_ip'}."'", 5);
1087         daemon_log("$session_id DEBUG: Processing module ".$module, 7);
1088         $answer_l = &{ $module."::process_incoming_msg" }($msg, $msg_hash, $session_id);
1089
1090         if ( 0 < @{$answer_l} ) {
1091             my $answer_str = join("\n", @{$answer_l});
1092             daemon_log("$session_id DEBUG: $module: Got answer from module: \n".$answer_str,8);
1093         }
1094     }
1095     if( !$answer_l ) { $error++ };
1096
1097     ########
1098     # answer
1099     if( $error == 0 ) {
1100
1101         foreach my $answer ( @{$answer_l} ) {
1102             # for each answer in answer list
1103
1104             # check outgoing msg to xml validity
1105             my $answer_hash = &check_outgoing_xml_validity($answer);
1106             if( not defined $answer_hash ) {
1107                 next;
1108             }
1109
1110             $answer_header = @{$answer_hash->{'header'}}[0];
1111             @answer_target_l = @{$answer_hash->{'target'}};
1112             $answer_source = @{$answer_hash->{'source'}}[0];
1113
1114             # deliver msg to all targets
1115             foreach my $answer_target ( @answer_target_l ) {
1116
1117                 # targets of msg are all gosa-si-clients in known_clients_db
1118                 if( $answer_target eq "*" ) {
1119                     # answer is for all clients
1120                     my $sql_statement= "SELECT * FROM known_clients";
1121                     my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1122                     while( my ($hit_num, $hit) = each %{ $query_res } ) {
1123                         my $host_name = $hit->{hostname};
1124                         my $host_key = $hit->{hostkey};
1125                         my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1126                         &update_jobdb_status_for_send_msgs($answer, $error);
1127                     }
1128                 }
1129
1130                 # targets of msg are all gosa-si-server in known_server_db
1131                 elsif( $answer_target eq "KNOWN_SERVER" ) {
1132                     # answer is for all server in known_server
1133                     my $sql_statement= "SELECT * FROM known_server";
1134                     my $query_res = $known_server_db->select_dbentry( $sql_statement );
1135                     while( my ($hit_num, $hit) = each %{ $query_res } ) {
1136                         my $host_name = $hit->{hostname};
1137                         my $host_key = $hit->{hostkey};
1138                         $answer =~ s/KNOWN_SERVER/$host_name/g;
1139                         my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1140                         &update_jobdb_status_for_send_msgs($answer, $error);
1141                     }
1142                 }
1143
1144                 # target of msg is GOsa
1145                                 elsif( $answer_target eq "GOSA" ) {
1146                                         my $session_id = ($1) if $answer =~ /<session_id>(\d+?)<\/session_id>/;
1147                                         my $add_on = "";
1148                     if( defined $session_id ) {
1149                         $add_on = ".session_id=$session_id";
1150                     }
1151                     # answer is for GOSA and has to returned to connected client
1152                     my $gosa_answer = &encrypt_msg($answer, $GosaPackages_key);
1153                     $client_answer = $gosa_answer.$add_on;
1154                 }
1155
1156                 # target of msg is job queue at this host
1157                 elsif( $answer_target eq "JOBDB") {
1158                     $answer =~ /<header>(\S+)<\/header>/;
1159                     my $header;
1160                     if( defined $1 ) { $header = $1; }
1161                     my $error = &send_msg_to_target($answer, $server_address, $GosaPackages_key, $header, $session_id);
1162                     &update_jobdb_status_for_send_msgs($answer, $error);
1163                 }
1164
1165                 # target of msg is a mac address
1166                 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 ) {
1167                     daemon_log("$session_id INFO: target is mac address '$answer_target', looking for host in known_clients", 5);
1168                     my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$answer_target'";
1169                     my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1170                     my $found_ip_flag = 0;
1171                     while( my ($hit_num, $hit) = each %{ $query_res } ) {
1172                         my $host_name = $hit->{hostname};
1173                         my $host_key = $hit->{hostkey};
1174                         $answer =~ s/$answer_target/$host_name/g;
1175                         daemon_log("$session_id INFO: found host '$host_name', associated to '$answer_target'", 5);
1176                         my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1177                         &update_jobdb_status_for_send_msgs($answer, $error);
1178                         $found_ip_flag++ ;
1179                     }
1180                     if( $found_ip_flag == 0) {
1181                         daemon_log("$session_id WARNING: no host found in known_clients with mac address '$answer_target'", 3);
1182                         if( $bus_activ eq "true" ) {
1183                             daemon_log("$session_id INFO: try to forward msg '$answer_header' to bus '$bus_address'", 5);
1184                             my $sql_statement = "SELECT * FROM known_server WHERE hostname='$bus_address'";
1185                             my $query_res = $known_server_db->select_dbentry( $sql_statement );
1186                             while( my ($hit_num, $hit) = each %{ $query_res } ) {
1187                                 my $bus_address = $hit->{hostname};
1188                                 my $bus_key = $hit->{hostkey};
1189                                 my $error = &send_msg_to_target($answer, $bus_address, $bus_key, $answer_header, $session_id);
1190                                 &update_jobdb_status_for_send_msgs($answer, $error);
1191                                 last;
1192                             }
1193                         }
1194
1195                     }
1196
1197                 #  answer is for one specific host
1198                 } else {
1199                     # get encrypt_key
1200                     my $encrypt_key = &get_encrypt_key($answer_target);
1201                     if( not defined $encrypt_key ) {
1202                         # unknown target, forward msg to bus
1203                         daemon_log("$session_id WARNING: unknown target '$answer_target'", 3);
1204                         if( $bus_activ eq "true" ) {
1205                             daemon_log("$session_id INFO: try to forward msg '$answer_header' to bus '$bus_address'", 5);
1206                             my $sql_statement = "SELECT * FROM known_server WHERE hostname='$bus_address'";
1207                             my $query_res = $known_server_db->select_dbentry( $sql_statement );
1208                             my $res_length = keys( %{$query_res} );
1209                             if( $res_length == 0 ){
1210                                 daemon_log("$session_id WARNING: send '$answer_header' to '$bus_address' failed, ".
1211                                         "no bus found in known_server", 3);
1212                             }
1213                             else {
1214                                 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1215                                     my $bus_key = $hit->{hostkey};
1216                                     my $error = &send_msg_to_target($answer, $bus_address, $bus_key, $answer_header,$session_id );
1217                                     &update_jobdb_status_for_send_msgs($answer, $error);
1218                                 }
1219                             }
1220                         }
1221                         next;
1222                     }
1223                     my $error = &send_msg_to_target($answer, $answer_target, $encrypt_key, $answer_header,$session_id);
1224                     &update_jobdb_status_for_send_msgs($answer, $error);
1225                 }
1226             }
1227         }
1228     }
1229
1230     my $filter = POE::Filter::Reference->new();
1231     my %result = (
1232             status => "seems ok to me",
1233             answer => $client_answer,
1234             );
1235
1236     my $output = $filter->put( [ \%result ] );
1237     print @$output;
1238
1239
1240 }
1241
1242
1243 sub trigger_db_loop {
1244         my ($kernel) = @_ ;
1245         $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
1246         $kernel->delay_set('watch_for_done_jobs', $job_queue_loop_delay);
1247     $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
1248     $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
1249 }
1250
1251 sub watch_for_done_jobs {
1252     my ($kernel,$heap) = @_[KERNEL, HEAP];
1253
1254     my $sql_statement = "SELECT * FROM ".$job_queue_tn.
1255         " WHERE status='done'";
1256         my $res = $job_db->select_dbentry( $sql_statement );
1257
1258     while( my ($id, $hit) = each %{$res} ) {
1259         my $jobdb_id = $hit->{id};
1260         my $sql_statement = "DELETE FROM $job_queue_tn WHERE id='$jobdb_id'";
1261         my $res = $job_db->del_dbentry($sql_statement);
1262     }
1263
1264     $kernel->delay_set('watch_for_done_jobs',$job_queue_loop_delay);
1265 }
1266
1267 sub watch_for_new_jobs {
1268         my ($kernel,$heap) = @_[KERNEL, HEAP];
1269
1270         # check gosa job queue for jobs with executable timestamp
1271         my $timestamp = &get_time();
1272         my $sql_statement = "SELECT * FROM $job_queue_tn WHERE status='waiting' AND (CAST (timestamp AS INTEGER)) < $timestamp ORDER BY timestamp";
1273         my $res = $job_db->exec_statement( $sql_statement );
1274
1275         # Merge all new jobs that would do the same actions
1276         my @drops;
1277         my $hits;
1278         foreach my $hit (reverse @{$res} ) {
1279                 my $macaddress= lc @{$hit}[8];
1280                 my $headertag= @{$hit}[5];
1281                 if(defined($hits->{$macaddress}->{$headertag})) {
1282                         push @drops, "DELETE FROM $job_queue_tn WHERE id = '$hits->{$macaddress}->{$headertag}[0]'";
1283                 }
1284                 $hits->{$macaddress}->{$headertag}= $hit;
1285         }
1286
1287         # Delete new jobs with a matching job in state 'processing'
1288         foreach my $macaddress (keys %{$hits}) {
1289                 foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
1290                         my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
1291                         my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND headertag='$jobdb_headertag' AND status='processing'";
1292                         my $res = $job_db->exec_statement( $sql_statement );
1293                         foreach my $hit (@{$res}) {
1294                                 push @drops, "DELETE FROM $job_queue_tn WHERE id = '$jobdb_id'";
1295                         }
1296                 }
1297         }
1298
1299         # Commit deletion
1300         $job_db->exec_statementlist(\@drops);
1301
1302         # Look for new jobs that could be executed
1303         foreach my $macaddress (keys %{$hits}) {
1304
1305                 # Look if there is an executing job
1306                 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND status='processing'";
1307                 my $res = $job_db->exec_statement( $sql_statement );
1308
1309                 # Skip new jobs for host if there is a processing job
1310                 if(defined($res) and defined @{$res}[0]) {
1311                         next;
1312                 }
1313
1314                 foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
1315                         my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
1316                         my $job_msg = @{$hits->{$macaddress}->{$jobdb_headertag}}[7];
1317
1318                         daemon_log("J DEBUG: its time to execute $job_msg", 7);
1319                         my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$macaddress'";
1320                         my $res_hash = $known_clients_db->select_dbentry( $sql_statement );
1321
1322                         # expect macaddress is unique!!!!!!
1323                         my $target = $res_hash->{1}->{hostname};
1324
1325                         # change header
1326                         $job_msg =~ s/<header>job_/<header>gosa_/;
1327
1328                         # add sqlite_id
1329                         $job_msg =~ s/<\/xml>$/<jobdb_id>$jobdb_id<\/jobdb_id><\/xml>/;
1330
1331                         $job_msg =~ /<header>(\S+)<\/header>/;
1332                         my $header = $1 ;
1333                         my $func_error = &send_msg_to_target($job_msg, $server_address, $GosaPackages_key, $header, "J");
1334
1335                         # update status in job queue to 'processing'
1336                         $sql_statement = "UPDATE $job_queue_tn SET status='processing' WHERE id='$jobdb_id'";
1337                         my $res = $job_db->update_dbentry($sql_statement);
1338
1339                         # We don't want parallel processing
1340                         last;
1341                 }
1342         }
1343
1344         $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
1345 }
1346
1347
1348 sub watch_for_new_messages {
1349     my ($kernel,$heap) = @_[KERNEL, HEAP];
1350     my @coll_user_msg;   # collection list of outgoing messages
1351
1352     # check messaging_db for new incoming messages with executable timestamp
1353     my $timestamp = &get_time();
1354     my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( (CAST(timestamp AS INTEGER))<$timestamp AND flag='n' AND direction='in' )";
1355     my $res = $messaging_db->exec_statement( $sql_statement );
1356         foreach my $hit (@{$res}) {
1357
1358         # create outgoing messages
1359         my $message_to = @{$hit}[3];
1360
1361         # translate message_to to plain login name
1362         my @reciever_l = ($message_to);
1363         my $message_id = @{$hit}[0];
1364
1365         #add each outgoing msg to messaging_db
1366         my $reciever;
1367         foreach $reciever (@reciever_l) {
1368             my $sql_statement = "INSERT INTO $messaging_tn (id, subject, message_from, message_to, flag, direction, delivery_time, message, timestamp) ".
1369                 "VALUES ('".
1370                 $message_id."', '".    # id
1371                 @{$hit}[1]."', '".     # subject
1372                 @{$hit}[2]."', '".     # message_from
1373                 $reciever."', '".      # message_to
1374                 "none"."', '".         # flag
1375                 "out"."', '".          # direction
1376                 @{$hit}[6]."', '".     # delivery_time
1377                 @{$hit}[7]."', '".     # message
1378                 $timestamp."'".     # timestamp
1379                 ")";
1380             &daemon_log("M DEBUG: $sql_statement", 1);
1381             my $res = $messaging_db->exec_statement($sql_statement);
1382             &daemon_log("M INFO: message '".@{$hit}[0]."' is prepared for delivery to reciever '$reciever'", 5);
1383         }
1384
1385         # send outgoing messages
1386         my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( flag='p' AND direction='out' )";
1387         my $res = $messaging_db->exec_statement( $sql_statement );
1388         foreach my $hit (@{$res}) {
1389             # add subject, from, to and message to list coll_user_msg
1390             my @user_msg = [@{$hit}[1], @{$hit}[2], $reciever, @{$hit}[7]];
1391             push( @coll_user_msg, \@user_msg);
1392         }
1393
1394         # send outgoing list to myself (gosa-si-server) to deliver each message to user
1395         # reason for this workaround: if to much messages have to be delivered, it can come to
1396         # denial of service problems of the server. so, the incoming message list can be processed
1397         # by a forked child and gosa-si-server is always ready to work.
1398         my $collection_out_msg = &create_xml_hash("collection_user_messages", $server_address, $server_address);
1399         # add to hash 'msg1' => [subject, from, to, message]
1400         # hash to string
1401         # send msg to myself
1402 # TODO
1403
1404         # set incoming message to flag d=deliverd
1405         $sql_statement = "UPDATE $messaging_tn SET flag='p' WHERE id='$message_id'";
1406         &daemon_log("M DEBUG: $sql_statement", 7);
1407         $res = $messaging_db->update_dbentry($sql_statement);
1408         &daemon_log("M INFO: message '$message_id' is set to flag 'p' (processed)", 5);
1409
1410     }
1411
1412     $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
1413
1414
1415     return;
1416 }
1417
1418
1419 sub watch_for_done_messages {
1420     my ($kernel,$heap) = @_[KERNEL, HEAP];
1421
1422     $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
1423     return;
1424 }
1425
1426
1427 sub get_ldap_handle {
1428         my ($session_id) = @_;
1429         my $heap;
1430         my $ldap_handle;
1431
1432         if (not defined $session_id ) { $session_id = 0 };
1433         if ($session_id =~ /[^0-9]*/) { $session_id = 0 };
1434
1435         if ($session_id == 0) {
1436                 daemon_log("$session_id DEBUG: get_ldap_handle invoked without a session_id, create a new ldap_handle", 7);
1437                 $ldap_handle = Net::LDAP->new( $ldap_uri );
1438                 $ldap_handle->bind($ldap_admin_dn, password => $ldap_admin_password);
1439
1440         } else {
1441                 my $session_reference = $global_kernel->ID_id_to_session($session_id);
1442                 if( defined $session_reference ) {
1443                         $heap = $session_reference->get_heap();
1444                 }
1445
1446                 if (not defined $heap) {
1447                         daemon_log("$session_id DEBUG: cannot get heap for session_id '$session_id'", 7);
1448                         return;
1449                 }
1450
1451                 # TODO: This "if" is nonsense, because it doesn't prove that the
1452                 #       used handle is still valid - or if we've to reconnect...
1453                 #if (not exists $heap->{ldap_handle}) {
1454                         $ldap_handle = Net::LDAP->new( $ldap_uri );
1455                         $ldap_handle->bind($ldap_admin_dn, password => $ldap_admin_password);
1456                         $heap->{ldap_handle} = $ldap_handle;
1457                 #}
1458         }
1459         return $ldap_handle;
1460 }
1461
1462
1463 sub change_fai_state {
1464     my ($st, $targets, $session_id) = @_;
1465     $session_id = 0 if not defined $session_id;
1466     # Set FAI state to localboot
1467     my %mapActions= (
1468         reboot    => '',
1469         update    => 'softupdate',
1470         localboot => 'localboot',
1471         reinstall => 'install',
1472         rescan    => '',
1473         wake      => '',
1474         memcheck  => 'memcheck',
1475         sysinfo   => 'sysinfo',
1476         install   => 'install',
1477     );
1478
1479     # Return if this is unknown
1480     if (!exists $mapActions{ $st }){
1481         daemon_log("$session_id ERROR: unknown action '$st', can not translate ot FAIstate", 1);
1482       return;
1483     }
1484
1485     my $state= $mapActions{ $st };
1486
1487     my $ldap_handle = &get_ldap_handle($session_id);
1488     if( defined($ldap_handle) ) {
1489
1490       # Build search filter for hosts
1491         my $search= "(&(objectClass=GOhard)";
1492         foreach (@{$targets}){
1493             $search.= "(macAddress=$_)";
1494         }
1495         $search.= ")";
1496
1497       # If there's any host inside of the search string, procress them
1498         if (!($search =~ /macAddress/)){
1499             daemon_log("$session_id ERROR: no macAddress found in filter statement for LDAP search: '$search'", 1);
1500             return;
1501         }
1502
1503       # Perform search for Unit Tag
1504       my $mesg = $ldap_handle->search(
1505           base   => $ldap_base,
1506           scope  => 'sub',
1507           attrs  => ['dn', 'FAIstate', 'objectClass'],
1508           filter => "$search"
1509           );
1510
1511           if ($mesg->count) {
1512                   my @entries = $mesg->entries;
1513                   foreach my $entry (@entries) {
1514                           # Only modify entry if it is not set to '$state'
1515                           if ($entry->get_value("FAIstate") ne "$state"){
1516                                   daemon_log("$session_id INFO: Setting FAIstate to '$state' for ".$entry->dn, 5);
1517                                   my $result;
1518                                   my %tmp = map { $_ => 1 } $entry->get_value("objectClass");
1519                                   if (exists $tmp{'FAIobject'}){
1520                                           if ($state eq ''){
1521                                                   $result= $ldap_handle->modify($entry->dn, changes => [
1522                                                           delete => [ FAIstate => [] ] ]);
1523                                           } else {
1524                                                   $result= $ldap_handle->modify($entry->dn, changes => [
1525                                                           replace => [ FAIstate => $state ] ]);
1526                                           }
1527                                   } elsif ($state ne ''){
1528                                           $result= $ldap_handle->modify($entry->dn, changes => [
1529                                                   add     => [ objectClass => 'FAIobject' ],
1530                                                   add     => [ FAIstate => $state ] ]);
1531                                   }
1532
1533                                   # Errors?
1534                                   if ($result->code){
1535                                           daemon_log("$session_id Error: Setting FAIstate to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
1536                                   }
1537                           } else {
1538                                   daemon_log("$session_id DEBUG FAIstate at host '".$entry->dn."' already at state '$st'", 7);
1539                           }
1540                   }
1541           }
1542     # if no ldap handle defined
1543     } else {
1544         daemon_log("$session_id ERROR: no LDAP handle defined for update FAIstate", 1);
1545     }
1546
1547 }
1548
1549
1550 sub change_goto_state {
1551     my ($st, $targets, $session_id) = @_;
1552     $session_id = 0  if not defined $session_id;
1553
1554     # Switch on or off?
1555     my $state= $st eq 'active' ? 'active': 'locked';
1556
1557     my $ldap_handle = &get_ldap_handle($session_id);
1558     if( defined($ldap_handle) ) {
1559
1560       # Build search filter for hosts
1561       my $search= "(&(objectClass=GOhard)";
1562       foreach (@{$targets}){
1563         $search.= "(macAddress=$_)";
1564       }
1565       $search.= ")";
1566
1567       # If there's any host inside of the search string, procress them
1568       if (!($search =~ /macAddress/)){
1569         return;
1570       }
1571
1572       # Perform search for Unit Tag
1573       my $mesg = $ldap_handle->search(
1574           base   => $ldap_base,
1575           scope  => 'sub',
1576           attrs  => ['dn', 'gotoMode'],
1577           filter => "$search"
1578           );
1579
1580       if ($mesg->count) {
1581         my @entries = $mesg->entries;
1582         foreach my $entry (@entries) {
1583
1584           # Only modify entry if it is not set to '$state'
1585           if ($entry->get_value("gotoMode") ne $state){
1586
1587             daemon_log("$session_id INFO: Setting gotoMode to '$state' for ".$entry->dn, 5);
1588             my $result;
1589             $result= $ldap_handle->modify($entry->dn, changes => [
1590                                                 replace => [ gotoMode => $state ] ]);
1591
1592             # Errors?
1593             if ($result->code){
1594               &daemon_log("$session_id Error: Setting gotoMode to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
1595             }
1596
1597           }
1598         }
1599       }
1600
1601     }
1602 }
1603
1604
1605 sub run_create_fai_server_db {
1606     my ($kernel, $session, $heap, $table_name) = @_[KERNEL, SESSION, HEAP, ARG0];
1607     my $session_id = $session->ID;
1608     my $task = POE::Wheel::Run->new(
1609             Program => sub { &create_fai_server_db($table_name,$kernel, undef, $session_id) },
1610             StdoutEvent  => "session_run_result",
1611             StderrEvent  => "session_run_debug",
1612             CloseEvent   => "session_run_done",
1613             );
1614
1615     $heap->{task}->{ $task->ID } = $task;
1616     return;
1617 }
1618
1619
1620 sub create_fai_server_db {
1621     my ($table_name, $kernel, $dont_create_packages_list, $session_id) = @_;
1622         my $result;
1623
1624         if (not defined $session_id) { $session_id = 0; }
1625     my $ldap_handle = &get_ldap_handle();
1626         if(defined($ldap_handle)) {
1627                 daemon_log("$session_id INFO: create_fai_server_db: start", 5);
1628                 my $mesg= $ldap_handle->search(
1629                         base   => $ldap_base,
1630                         scope  => 'sub',
1631                         attrs  => ['FAIrepository', 'gosaUnitTag'],
1632                         filter => "(&(FAIrepository=*)(objectClass=FAIrepositoryServer))",
1633                 );
1634                 if($mesg->{'resultCode'} == 0 &&
1635                    $mesg->count != 0) {
1636                    foreach my $entry (@{$mesg->{entries}}) {
1637                            if($entry->exists('FAIrepository')) {
1638                                    # Add an entry for each Repository configured for server
1639                                    foreach my $repo(@{$entry->get_value('FAIrepository', asref => 1)}) {
1640                                                    my($tmp_url,$tmp_server,$tmp_release,$tmp_sections) = split(/\|/, $repo);
1641                                                    my $tmp_tag= $entry->get_value('gosaUnitTag') || "";
1642                                                    $result= $fai_server_db->add_dbentry( {
1643                                                                    table => $table_name,
1644                                                                    primkey => ['server', 'release', 'tag'],
1645                                                                    server => $tmp_url,
1646                                                                    release => $tmp_release,
1647                                                                    sections => $tmp_sections,
1648                                                                    tag => (length($tmp_tag)>0)?$tmp_tag:"",
1649                                                            } );
1650                                            }
1651                                    }
1652                            }
1653                    }
1654                 daemon_log("$session_id INFO: create_fai_server_db: finished", 5);
1655
1656                 # TODO: Find a way to post the 'create_packages_list_db' event
1657                 if(not defined($dont_create_packages_list)) {
1658                         &create_packages_list_db(undef, undef, $session_id);
1659                 }
1660         }
1661
1662     $ldap_handle->disconnect;
1663         return $result;
1664 }
1665
1666
1667 sub run_create_fai_release_db {
1668     my ($session, $heap, $table_name) = @_[SESSION, HEAP, ARG0];
1669         my $session_id = $session->ID;
1670     my $task = POE::Wheel::Run->new(
1671             Program => sub { &create_fai_release_db($table_name, $session_id) },
1672             StdoutEvent  => "session_run_result",
1673             StderrEvent  => "session_run_debug",
1674             CloseEvent   => "session_run_done",
1675             );
1676
1677     $heap->{task}->{ $task->ID } = $task;
1678     return;
1679 }
1680
1681
1682 sub create_fai_release_db {
1683         my ($table_name, $session_id) = @_;
1684         my $result;
1685
1686     # used for logging
1687     if (not defined $session_id) { $session_id = 0; }
1688
1689     my $ldap_handle = &get_ldap_handle();
1690         if(defined($ldap_handle)) {
1691                 daemon_log("$session_id INFO: create_fai_release_db: start",5);
1692                 my $mesg= $ldap_handle->search(
1693                         base   => $ldap_base,
1694                         scope  => 'sub',
1695                         attrs  => [],
1696                         filter => "(&(objectClass=organizationalUnit)(ou=fai))",
1697                 );
1698                 if($mesg->{'resultCode'} == 0 &&
1699                         $mesg->count != 0) {
1700                         # Walk through all possible FAI container ou's
1701                         my @sql_list;
1702                         my $timestamp= &get_time();
1703                         foreach my $ou (@{$mesg->{entries}}) {
1704                                 my $tmp_classes= resolve_fai_classes($ou->dn, $ldap_handle, $session_id);
1705                                 if(defined($tmp_classes) && ref($tmp_classes) eq 'HASH') {
1706                                         my @tmp_array=get_fai_release_entries($tmp_classes);
1707                                         if(@tmp_array) {
1708                                                 foreach my $entry (@tmp_array) {
1709                                                         if(defined($entry) && ref($entry) eq 'HASH') {
1710                                                                 my $sql=
1711                                                                 "INSERT INTO $table_name "
1712                                                                 ."(timestamp, release, class, type, state) VALUES ("
1713                                                                 .$timestamp.","
1714                                                                 ."'".$entry->{'release'}."',"
1715                                                                 ."'".$entry->{'class'}."',"
1716                                                                 ."'".$entry->{'type'}."',"
1717                                                                 ."'".$entry->{'state'}."')";
1718                                                                 push @sql_list, $sql;
1719                                                         }
1720                                                 }
1721                                         }
1722                                 }
1723                         }
1724
1725                         daemon_log("$session_id DEBUG: Inserting ".scalar @sql_list." entries to DB",8);
1726                         if(@sql_list) {
1727                                 unshift @sql_list, "DELETE FROM $table_name";
1728                                 $fai_release_db->exec_statementlist(\@sql_list);
1729                         }
1730                         daemon_log("$session_id DEBUG: Done with inserting",6);
1731                 }
1732                 daemon_log("$session_id INFO: create_fai_release_db: finished",5);
1733         }
1734     $ldap_handle->disconnect;
1735         return $result;
1736 }
1737
1738 sub get_fai_types {
1739         my $tmp_classes = shift || return undef;
1740         my @result;
1741
1742         foreach my $type(keys %{$tmp_classes}) {
1743                 if(defined($tmp_classes->{$type}[0]) && (!($tmp_classes->{$type}[0] =~ /^.*?removed.*?$/))) {
1744                         my $entry = {
1745                                 type => $type,
1746                                 state => $tmp_classes->{$type}[0],
1747                         };
1748                         push @result, $entry;
1749                 }
1750         }
1751
1752         return @result;
1753 }
1754
1755 sub get_fai_state {
1756         my $result = "";
1757         my $tmp_classes = shift || return $result;
1758
1759         foreach my $type(keys %{$tmp_classes}) {
1760                 if(defined($tmp_classes->{$type}[0])) {
1761                         $result = $tmp_classes->{$type}[0];
1762
1763                 # State is equal for all types in class
1764                         last;
1765                 }
1766         }
1767
1768         return $result;
1769 }
1770
1771 sub resolve_fai_classes {
1772         my ($fai_base, $ldap_handle, $session_id) = @_;
1773         if (not defined $session_id) { $session_id = 0; }
1774         my $result;
1775         my @possible_fai_classes= ("FAIscript", "FAIhook", "FAIpartitionTable", "FAItemplate", "FAIvariable", "FAIprofile", "FAIpackageList");
1776         my $fai_filter= "(|(&(objectClass=FAIclass)(|(objectClass=".join(")(objectClass=", @possible_fai_classes).")))(objectClass=FAIbranch))";
1777         my $fai_classes;
1778
1779         daemon_log("$session_id DEBUG: Searching for FAI entries in base $fai_base",6);
1780         my $mesg= $ldap_handle->search(
1781                 base   => $fai_base,
1782                 scope  => 'sub',
1783                 attrs  => ['cn','objectClass','FAIstate'],
1784                 filter => $fai_filter,
1785         );
1786         daemon_log("$session_id DEBUG: Found ".$mesg->count()." FAI entries",6);
1787
1788         if($mesg->{'resultCode'} == 0 &&
1789                 $mesg->count != 0) {
1790                 foreach my $entry (@{$mesg->{entries}}) {
1791                         if($entry->exists('cn')) {
1792                                 my $tmp_dn= $entry->dn();
1793
1794                                 # Skip classname and ou dn parts for class
1795                                 my $tmp_release = ($1) if $tmp_dn =~ /^[^,]+,[^,]+,(.*?),$fai_base$/;
1796
1797                                 # Skip classes without releases
1798                                 if((!defined($tmp_release)) || length($tmp_release)==0) {
1799                                         next;
1800                                 }
1801
1802                                 my $tmp_cn= $entry->get_value('cn');
1803                                 my $tmp_state= $entry->get_value('FAIstate');
1804
1805                                 my $tmp_type;
1806                                 # Get FAI type
1807                                 for my $oclass(@{$entry->get_value('objectClass', asref => 1)}) {
1808                                         if(grep $_ eq $oclass, @possible_fai_classes) {
1809                                                 $tmp_type= $oclass;
1810                                                 last;
1811                                         }
1812                                 }
1813
1814                                 if($tmp_release =~ /^.*?,.*?$/ && (!($tmp_release =~ /^.*?\\,.*?$/))) {
1815                                         # A Subrelease
1816                                         my @sub_releases = split(/,/, $tmp_release);
1817
1818                                         # Walk through subreleases and build hash tree
1819                                         my $hash;
1820                                         while(my $tmp_sub_release = pop @sub_releases) {
1821                                                 $hash .= "\{'$tmp_sub_release'\}->";
1822                                         }
1823                                         eval('push @{$fai_classes->'.$hash.'{$tmp_cn}->{$tmp_type}}, (defined($tmp_state) && length($tmp_state)>0)?$tmp_state:"";');
1824                                 } else {
1825                                         # A branch, no subrelease
1826                                         push @{$fai_classes->{$tmp_release}->{$tmp_cn}->{$tmp_type}}, (defined($tmp_state) && length($tmp_state)>0)?$tmp_state:"";
1827                                 }
1828                         } elsif (!$entry->exists('cn')) {
1829                                 my $tmp_dn= $entry->dn();
1830                                 my $tmp_release = ($1) if $tmp_dn =~ /^(.*?),$fai_base$/;
1831
1832                                 # Skip classes without releases
1833                                 if((!defined($tmp_release)) || length($tmp_release)==0) {
1834                                         next;
1835                                 }
1836
1837                                 if($tmp_release =~ /^.*?,.*?$/ && (!($tmp_release =~ /^.*?\\,.*?$/))) {
1838                                         # A Subrelease
1839                                         my @sub_releases= split(/,/, $tmp_release);
1840
1841                                         # Walk through subreleases and build hash tree
1842                                         my $hash;
1843                                         while(my $tmp_sub_release = pop @sub_releases) {
1844                                                 $hash .= "\{'$tmp_sub_release'\}->";
1845                                         }
1846                                         # Remove the last two characters
1847                                         chop($hash);
1848                                         chop($hash);
1849
1850                                         eval('$fai_classes->'.$hash.'= {}');
1851                                 } else {
1852                                         # A branch, no subrelease
1853                                         if(!exists($fai_classes->{$tmp_release})) {
1854                                                 $fai_classes->{$tmp_release} = {};
1855                                         }
1856                                 }
1857                         }
1858                 }
1859
1860                 # The hash is complete, now we can honor the copy-on-write based missing entries
1861                 foreach my $release (keys %$fai_classes) {
1862                         $result->{$release}= deep_copy(apply_fai_inheritance($fai_classes->{$release}));
1863                 }
1864         }
1865         return $result;
1866 }
1867
1868 sub apply_fai_inheritance {
1869        my $fai_classes = shift || return {};
1870        my $tmp_classes;
1871
1872        # Get the classes from the branch
1873        foreach my $class (keys %{$fai_classes}) {
1874                # Skip subreleases
1875                if($class =~ /^ou=.*$/) {
1876                        next;
1877                } else {
1878                        $tmp_classes->{$class}= deep_copy($fai_classes->{$class});
1879                }
1880        }
1881
1882        # Apply to each subrelease
1883        foreach my $subrelease (keys %{$fai_classes}) {
1884                if($subrelease =~ /ou=/) {
1885                        foreach my $tmp_class (keys %{$tmp_classes}) {
1886                                if(!exists($fai_classes->{$subrelease}->{$tmp_class})) {
1887                                        $fai_classes->{$subrelease}->{$tmp_class} =
1888                                        deep_copy($tmp_classes->{$tmp_class});
1889                                } else {
1890                                        foreach my $type (keys %{$tmp_classes->{$tmp_class}}) {
1891                                                if(!exists($fai_classes->{$subrelease}->{$tmp_class}->{$type})) {
1892                                                        $fai_classes->{$subrelease}->{$tmp_class}->{$type}=
1893                                                        deep_copy($tmp_classes->{$tmp_class}->{$type});
1894                                                }
1895                                        }
1896                                }
1897                        }
1898                }
1899        }
1900
1901        # Find subreleases in deeper levels
1902        foreach my $subrelease (keys %{$fai_classes}) {
1903                if($subrelease =~ /ou=/) {
1904                        foreach my $subsubrelease (keys %{$fai_classes->{$subrelease}}) {
1905                                if($subsubrelease =~ /ou=/) {
1906                                        apply_fai_inheritance($fai_classes->{$subrelease});
1907                                }
1908                        }
1909                }
1910        }
1911
1912        return $fai_classes;
1913 }
1914
1915 sub get_fai_release_entries {
1916         my $tmp_classes = shift || return;
1917         my $parent = shift || "";
1918         my @result = shift || ();
1919
1920         foreach my $entry (keys %{$tmp_classes}) {
1921                 if(defined($entry)) {
1922                         if($entry =~ /^ou=.*$/) {
1923                                 my $release_name = $entry;
1924                                 $release_name =~ s/ou=//g;
1925                                 if(length($parent)>0) {
1926                                         $release_name = $parent."/".$release_name;
1927                                 }
1928                                 my @bufentries = get_fai_release_entries($tmp_classes->{$entry}, $release_name, @result);
1929                                 foreach my $bufentry(@bufentries) {
1930                                         push @result, $bufentry;
1931                                 }
1932                         } else {
1933                                 my @types = get_fai_types($tmp_classes->{$entry});
1934                                 foreach my $type (@types) {
1935                                         push @result,
1936                                         {
1937                                                 'class' => $entry,
1938                                                 'type' => $type->{'type'},
1939                                                 'release' => $parent,
1940                                                 'state' => $type->{'state'},
1941                                         };
1942                                 }
1943                         }
1944                 }
1945         }
1946
1947         return @result;
1948 }
1949
1950 sub deep_copy {
1951         my $this = shift;
1952         if (not ref $this) {
1953                 $this;
1954         } elsif (ref $this eq "ARRAY") {
1955                 [map deep_copy($_), @$this];
1956         } elsif (ref $this eq "HASH") {
1957                 +{map { $_ => deep_copy($this->{$_}) } keys %$this};
1958         } else { die "what type is $_?" }
1959 }
1960
1961
1962 sub session_run_result {
1963     my ($kernel, $heap, $client_answer) = @_[KERNEL, HEAP, ARG0];
1964     $kernel->sig(CHLD => "child_reap");
1965 }
1966
1967 sub session_run_debug {
1968     my $result = $_[ARG0];
1969     print STDERR "$result\n";
1970 }
1971
1972 sub session_run_done {
1973     my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
1974     delete $heap->{task}->{$task_id};
1975 }
1976
1977 sub create_sources_list {
1978     my $ldap_handle = &get_ldap_handle;
1979         my $result="/tmp/gosa_si_tmp_sources_list";
1980
1981         # Remove old file
1982         if(stat($result)) {
1983                 unlink($result);
1984         }
1985
1986         my $fh;
1987         open($fh, ">$result") or return undef;
1988         if(defined($ldap_server_dn) and length($ldap_server_dn) > 0) {
1989                 my $mesg=$ldap_handle->search(
1990                                 base    => $ldap_server_dn,
1991                                 scope   => 'base',
1992                                 attrs   => 'FAIrepository',
1993                                 filter  => 'objectClass=FAIrepositoryServer'
1994                                 );
1995                 if($mesg->count) {
1996                         foreach my $entry(@{$mesg->{'entries'}}) {
1997                                 foreach my $value(@{$entry->get_value('FAIrepository', asref => 1)}) {
1998                                         my ($server, $tag, $release, $sections)= split /\|/, $value;
1999                                         my $line = "deb $server $release";
2000                                         $sections =~ s/,/ /g;
2001                                         $line.= " $sections";
2002                                         print $fh $line."\n";
2003                                 }
2004                         }
2005                 }
2006         }
2007         close($fh);
2008
2009         return $result;
2010 }
2011
2012
2013 sub run_create_packages_list_db {
2014     my ($session, $heap) = @_[SESSION, HEAP];
2015         my $session_id = $session->ID;
2016
2017         my $task = POE::Wheel::Run->new(
2018                                         Program => sub {&create_packages_list_db(undef, undef, $session_id)},
2019                                         StdoutEvent  => "session_run_result",
2020                                         StderrEvent  => "session_run_debug",
2021                                         CloseEvent   => "session_run_done",
2022                                         );
2023         $heap->{task}->{ $task->ID } = $task;
2024 }
2025
2026
2027 sub create_packages_list_db {
2028     my ($ldap_handle, $sources_file, $session_id);
2029
2030         if (not defined $session_id) { $session_id = 0; }
2031         if (not defined $ldap_handle) {
2032                 $ldap_handle= &get_ldap_handle();
2033
2034                 if (not defined $ldap_handle) {
2035                         daemon_log("$session_id ERROR: no ldap_handle available to create_packages_list_db", 1);
2036                         return;
2037                 }
2038         }
2039     if (not defined $sources_file) {
2040         $sources_file = &create_sources_list;
2041     }
2042
2043         # it should not be possible to trigger a recreation of packages_list_db
2044         # while packages_list_db is under construction, so set flag packages_list_under_construction
2045         # which is tested befor recreation can be started
2046         if ($packages_list_under_construction) {
2047                         daemon_log("$session_id WARNING: packages_list_db is right now under construction, please wait untill this process is finished", 3);
2048                         return;
2049         } else {
2050                         daemon_log("$session_id INFO: create_packages_list_db: start", 5);
2051                         # set packages_list_under_construction to true
2052                         $packages_list_under_construction = 1;
2053         }
2054         my $line;
2055
2056     open(CONFIG, "<$sources_file") or do {
2057         daemon_log( "$session_id ERROR: create_packages_list_db: Failed to open '$sources_file'", 1);
2058         return;
2059     };
2060
2061     # Read lines
2062     while ($line = <CONFIG>){
2063         # Unify
2064         chop($line);
2065         $line =~ s/^\s+//;
2066         $line =~ s/^\s+/ /;
2067
2068         # Strip comments
2069         $line =~ s/#.*$//g;
2070
2071         # Skip empty lines
2072         if ($line =~ /^\s*$/){
2073             next;
2074         }
2075
2076         # Interpret deb line
2077         if ($line =~ /^deb [^\s]+\s[^\s]+\s[^\s]+/){
2078             my( $baseurl, $dist, $sections ) = ($line =~ /^deb\s([^\s]+)\s+([^\s]+)\s+(.*)$/);
2079             my $section;
2080             foreach $section (split(' ', $sections)){
2081                 &parse_package_info( $baseurl, $dist, $section, $session_id );
2082             }
2083         }
2084     }
2085
2086     close (CONFIG);
2087
2088     daemon_log("$session_id INFO: create_packages_list_db: finished", 5);
2089         # set packages_list_under_construction to false
2090         $packages_list_under_construction = 0;
2091
2092     return;
2093 }
2094
2095
2096 sub parse_package_info {
2097   my ($baseurl, $dist, $section, $session_id)= @_;
2098   my ($package);
2099         if (not defined $session_id) { $session_id = 0; }
2100   my ($path) = ($baseurl =~ m%://[^/]*(.*)$%);
2101   $repo_dirs{ "${repo_path}/pool" } = 1;
2102
2103   foreach $package ("Packages.gz"){
2104     daemon_log("$session_id DEBUG: create_packages_list: fetch $baseurl, $dist, $section", 7);
2105     get_package( "$baseurl/dists/$dist/$section/binary-$arch/$package", "$outdir/$dist/$section", $session_id );
2106     parse_package( "$outdir/$dist/$section", $dist, $path, $session_id );
2107   }
2108   find(\&cleanup_and_extract, keys( %repo_dirs ));
2109 }
2110
2111
2112 sub get_package {
2113   my ($url, $dest, $session_id)= @_;
2114   if (not defined $session_id) { $session_id = 0; }
2115
2116   my $tpath = dirname($dest);
2117   -d "$tpath" || mkpath "$tpath";
2118
2119   # This is ugly, but I've no time to take a look at "how it works in perl"
2120   if(0 == system("wget '$url' -O '$dest' 2>/dev/null") ) {
2121       system("gunzip -cd '$dest' > '$dest.in'");
2122           daemon_log("$session_id DEBUG: run command: gunzip -cd '$dest' > '$dest.in'", 5);
2123 #      unlink($dest);
2124           daemon_log("$session_id DEBUG: delete file '$dest'", 5);
2125   } else {
2126       daemon_log("$session_id ERROR: create_packages_list_db: get_packages: fetching '$url' failed!", 1);
2127   }
2128   return 0;
2129 }
2130
2131 sub parse_package {
2132     my ($path, $dist, $srv_path, $session_id)= @_;
2133         if (not defined $session_id) { $session_id = 0;}
2134     my ($package, $version, $section, $description);
2135     my @sql_list;
2136     my $PACKAGES;
2137
2138     if(not stat("$path.in")) {
2139         daemon_log("$session_id ERROR: create_packages_list: parse_package: file '$path.in' is not readable",1);
2140         return;
2141     }
2142
2143     open($PACKAGES, "<$path.in");
2144         if(not defined($PACKAGES)) {
2145         daemon_log("$session_id ERROR: create_packages_list_db: parse_package: cannot open '$path.in'",1);
2146         return;
2147     }
2148
2149     # Read lines
2150     while (<$PACKAGES>){
2151         my $line = $_;
2152         # Unify
2153         chop($line);
2154
2155         # Use empty lines as a trigger
2156         if ($line =~ /^\s*$/){
2157             my $sql = "INSERT INTO packages_list VALUES ('$dist', '$package', '$version', '$section', '', 'none', '0')";
2158             push(@sql_list, $sql);
2159             $package = "none";
2160             $version = "none";
2161             $section = "none";
2162             $description = "none";
2163             next;
2164         }
2165
2166         # Trigger for package name
2167         if ($line =~ /^Package:\s/){
2168             ($package)= ($line =~ /^Package: (.*)$/);
2169             next;
2170         }
2171
2172         # Trigger for version
2173         if ($line =~ /^Version:\s/){
2174             ($version)= ($line =~ /^Version: (.*)$/);
2175             next;
2176         }
2177
2178         # Trigger for description
2179         if ($line =~ /^Description:\s/){
2180             ($description)= ($line =~ /^Description: (.*)$/);
2181             next;
2182         }
2183
2184         # Trigger for section
2185         if ($line =~ /^Section:\s/){
2186             ($section)= ($line =~ /^Section: (.*)$/);
2187             next;
2188         }
2189
2190         # Trigger for filename
2191         if ($line =~ /^Filename:\s/){
2192                 my ($filename) = ($line =~ /^Filename: (.*)$/);
2193                 store_fileinfo( $package, $filename, $dist, $srv_path, $version, $repo_path );
2194                 next;
2195         }
2196     }
2197
2198     close( $PACKAGES );
2199 #    unlink( "$path.in" );
2200
2201     $packages_list_db->exec_statementlist(\@sql_list);
2202 }
2203
2204 sub store_fileinfo {
2205   my( $package, $file, $dist, $path, $vers, $srvdir) = @_;
2206
2207   my %fileinfo = (
2208     'package' => $package,
2209     'dist' => $dist,
2210     'version' => $vers,
2211   );
2212
2213   $repo_files{ "${srvdir}/$file" } = \%fileinfo;
2214 }
2215
2216 sub cleanup_and_extract {
2217         my ($session_id) = @_;
2218         if (not defined $session_id) { $session_id  = 0; }
2219                 my $fileinfo = $repo_files{ $File::Find::name };
2220
2221                 if( defined $fileinfo ) {
2222
2223                                 my $dir = "$outdir/$fileinfo->{ 'dist' }/debconf.d";
2224                                 my $sql;
2225                                 my $package = $fileinfo->{ 'package' };
2226                                 my $newver = $fileinfo->{ 'version' };
2227
2228                                 mkpath($dir);
2229                                 system( "dpkg -e '$File::Find::name' '$dir/DEBIAN'" );
2230
2231                                 if( -f "$dir/DEBIAN/templates" ) {
2232
2233                                                 daemon_log("$session_id DEBUG: Found debconf templates in '$package' - $newver", 5);
2234
2235                                                 my $tmpl= "";
2236                                                 {
2237                                                                 local $/=undef;
2238                                                                 open FILE, "$dir/DEBIAN/templates";
2239                                                                 $tmpl = &encode_base64(<FILE>);
2240                                                                 close FILE;
2241                                                 }
2242                                                 rmtree("$dir/DEBIAN/templates");
2243
2244                                                 $sql= "update $main::packages_list_tn set template = '$tmpl' where package = '$package' and version = '$newver';";
2245
2246                                 } else {
2247                                                 $sql= "update $main::packages_list_tn set template = '' where package = '$package' and version = '$newver';";
2248                                 }
2249
2250                                 my $res= $main::packages_list_db->update_dbentry($sql);
2251                 }
2252 }
2253
2254
2255 #==== MAIN = main ==============================================================
2256 #  parse commandline options
2257 Getopt::Long::Configure( "bundling" );
2258 GetOptions("h|help" => \&usage,
2259         "c|config=s" => \$cfg_file,
2260         "f|foreground" => \$foreground,
2261         "v|verbose+" => \$verbose,
2262         "no-bus+" => \$no_bus,
2263         "no-arp+" => \$no_arp,
2264            );
2265
2266 #  read and set config parameters
2267 &check_cmdline_param ;
2268 &read_configfile;
2269 &check_pid;
2270
2271 $SIG{CHLD} = 'IGNORE';
2272
2273 # forward error messages to logfile
2274 if( ! $foreground ) {
2275   open( STDIN,  '+>/dev/null' );
2276   open( STDOUT, '+>&STDIN'    );
2277   open( STDERR, '+>&STDIN'    );
2278 }
2279
2280 # Just fork, if we are not in foreground mode
2281 if( ! $foreground ) {
2282     chdir '/'                 or die "Can't chdir to /: $!";
2283     $pid = fork;
2284     setsid                    or die "Can't start a new session: $!";
2285     umask 0;
2286 } else {
2287     $pid = $$;
2288 }
2289
2290 # Do something useful - put our PID into the pid_file
2291 if( 0 != $pid ) {
2292     open( LOCK_FILE, ">$pid_file" );
2293     print LOCK_FILE "$pid\n";
2294     close( LOCK_FILE );
2295     if( !$foreground ) {
2296         exit( 0 )
2297     };
2298 }
2299
2300 daemon_log(" ", 1);
2301 daemon_log("$0 started!", 1);
2302
2303 if ($no_bus > 0) {
2304     $bus_activ = "false"
2305 }
2306
2307 # connect to gosa-si job queue
2308 $job_db = GOSA::DBsqlite->new($job_queue_file_name);
2309 $job_db->create_table($job_queue_tn, \@job_queue_col_names);
2310
2311 # connect to known_clients_db
2312 $known_clients_db = GOSA::DBsqlite->new($known_clients_file_name);
2313 $known_clients_db->create_table($known_clients_tn, \@known_clients_col_names);
2314
2315 # connect to known_server_db
2316 $known_server_db = GOSA::DBsqlite->new($known_server_file_name);
2317 $known_server_db->create_table($known_server_tn, \@known_server_col_names);
2318
2319 # connect to login_usr_db
2320 $login_users_db = GOSA::DBsqlite->new($login_users_file_name);
2321 $login_users_db->create_table($login_users_tn, \@login_users_col_names);
2322
2323 # connect to fai_server_db and fai_release_db
2324 unlink($fai_server_file_name);
2325 $fai_server_db = GOSA::DBsqlite->new($fai_server_file_name);
2326 $fai_server_db->create_table($fai_server_tn, \@fai_server_col_names);
2327
2328 unlink($fai_release_file_name);
2329 $fai_release_db = GOSA::DBsqlite->new($fai_release_file_name);
2330 $fai_release_db->create_table($fai_release_tn, \@fai_release_col_names);
2331
2332 # connect to packages_list_db
2333 unlink($packages_list_file_name);
2334 $packages_list_db = GOSA::DBsqlite->new($packages_list_file_name);
2335 $packages_list_db->create_table($packages_list_tn, \@packages_list_col_names);
2336
2337 # connect to messaging_db
2338 $messaging_db = GOSA::DBsqlite->new($messaging_file_name);
2339 $messaging_db->create_table($messaging_tn, \@messaging_col_names);
2340
2341
2342 # create xml object used for en/decrypting
2343 $xml = new XML::Simple();
2344
2345 # create socket for incoming xml messages
2346
2347 POE::Component::Server::TCP->new(
2348         Port => $server_port,
2349         ClientInput => sub {
2350         my ($kernel, $input) = @_[KERNEL, ARG0];
2351         push(@tasks, $input);
2352         $kernel->yield("next_task");
2353         },
2354     InlineStates => {
2355         next_task => \&next_task,
2356         task_result => \&handle_task_result,
2357         task_done   => \&handle_task_done,
2358         task_debug  => \&handle_task_debug,
2359         child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!"  },
2360     }
2361 );
2362
2363 daemon_log("start socket for incoming xml messages at port '$server_port' ", 1);
2364
2365 # create session for repeatedly checking the job queue for jobs
2366 POE::Session->create(
2367         inline_states => {
2368                 _start => \&_start,
2369                 sig_handler => \&sig_handler,
2370         watch_for_new_messages => \&watch_for_new_messages,
2371         watch_for_done_messages => \&watch_for_done_messages,
2372                 watch_for_new_jobs => \&watch_for_new_jobs,
2373         watch_for_done_jobs => \&watch_for_done_jobs,
2374         create_packages_list_db => \&run_create_packages_list_db,
2375         create_fai_server_db => \&run_create_fai_server_db,
2376         create_fai_release_db => \&run_create_fai_release_db,
2377         session_run_result => \&session_run_result,
2378         session_run_debug => \&session_run_debug,
2379         session_run_done => \&session_run_done,
2380         child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!"  },
2381         }
2382 );
2383
2384
2385 # import all modules
2386 &import_modules;
2387
2388 # check wether all modules are gosa-si valid passwd check
2389
2390 POE::Kernel->run();
2391 exit;
2392