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