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