gosa-si/gosa-si-server

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