gosa-si/gosa-si-server

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