Code

Added a few krb5 functions
[gosa.git] / gosa-si / gosa-si-server
index 56b376be716e08c35855bbabf52bd5018f92e056..612e01436e23a97e714b42aeff87bc46e63dad8d 100755 (executable)
 #     REVISION:  ---
 #===============================================================================
 
+
 use strict;
 use warnings;
 use Getopt::Long;
 use Config::IniFiles;
 use POSIX;
-use utf8;
 
 use Fcntl;
 use IO::Socket::INET;
@@ -41,26 +41,39 @@ use Sys::Syslog qw( :DEFAULT setlogsock);
 use Cwd;
 use File::Spec;
 use File::Basename;
+use File::Find;
+use File::Copy;
 use File::Path;
 use GOSA::DBsqlite;
 use GOSA::GosaSupportDaemon;
-use POE qw(Component::Server::TCP);
+use POE qw(Component::Server::TCP Wheel::Run Filter::Reference);
 use Net::LDAP;
 use Net::LDAP::Util qw(:escape);
 
 my $modules_path = "/usr/lib/gosa-si/modules";
 use lib "/usr/lib/gosa-si/modules";
 
+# TODO es gibt eine globale funktion get_ldap_handle
+# - ist in einer session dieses ldap handle schon vorhanden, wird es zurückgegeben
+# - ist es nicht vorhanden, wird es erzeugt, im heap für spätere ldap anfragen gespeichert und zurückgegeben
+# - sessions die kein ldap handle brauchen, sollen auch keins haben
+# - wird eine session geschlossen, muss das ldap verbindung vorher beendet werden
+our $global_kernel;
+
 my (%cfg_defaults, $foreground, $verbose, $ping_timeout);
 my ($bus_activ, $bus, $msg_to_bus, $bus_cipher);
-my ($server, $server_mac_address);
+my ($server);
 my ($gosa_server, $job_queue_timeout, $job_queue_loop_delay);
+my ($messaging_db_loop_delay);
 my ($known_modules);
 my ($pid_file, $procid, $pid, $log_file);
 my ($arp_activ, $arp_fifo);
 my ($xml);
 my $sources_list;
 my $max_clients;
+my %repo_files=();
+my $repo_path;
+my %repo_dirs=();
 # variables declared in config file are always set to 'our'
 our (%cfg_defaults, $log_file, $pid_file, 
     $server_ip, $server_port, $SIPackages_key, 
@@ -70,6 +83,7 @@ our (%cfg_defaults, $log_file, $pid_file,
 
 # additional variable which should be globaly accessable
 our $server_address;
+our $server_mac_address;
 our $bus_address;
 our $gosa_address;
 our $no_bus;
@@ -77,7 +91,8 @@ our $no_arp;
 our $verbose;
 our $forground;
 our $cfg_file;
-our ($ldap_handle, $ldap_uri, $ldap_base, $ldap_admin_dn, $ldap_admin_password );
+#our ($ldap_handle, $ldap_uri, $ldap_base, $ldap_admin_dn, $ldap_admin_password, $ldap_server_dn);
+our ($ldap_uri, $ldap_base, $ldap_admin_dn, $ldap_admin_password, $ldap_server_dn);
 
 
 # specifies the verbosity of the daemon_log
@@ -91,8 +106,10 @@ $ping_timeout = 5;
 
 $no_bus = 0;
 $bus_activ = "true";
-
 $no_arp = 0;
+my $packages_list_under_construction = "/tmp/packages_list_creation_in_progress";
+my @packages_list_statements;
+my $watch_for_new_jobs_in_progress = 0;
 
 our $prg= basename($0);
 
@@ -100,52 +117,70 @@ our $prg= basename($0);
 our $job_db;
 our $job_queue_tn = 'jobs';
 my $job_queue_file_name;
-my @job_queue_col_names = ("id INTEGER", "timestamp", "status", "result", "progress INTEGER", 
-        "headertag", "targettag", "xmlmessage", "macaddress");
+my @job_queue_col_names = ("id INTEGER PRIMARY KEY", 
+               "timestamp DEFAULT 'none'", 
+               "status DEFAULT 'none'", 
+               "result DEFAULT 'none'", 
+               "progress DEFAULT 'none'", 
+        "headertag DEFAULT 'none'", 
+               "targettag DEFAULT 'none'", 
+               "xmlmessage DEFAULT 'none'", 
+               "macaddress DEFAULT 'none'",
+               "plainname DEFAULT 'none'",
+               );
 
 # holds all other gosa-sd as well as the gosa-sd-bus
 our $known_server_db;
 our $known_server_tn = "known_server";
 my $known_server_file_name;
-my @known_server_col_names = ('hostname', 'status', 'hostkey', 'timestamp');
+my @known_server_col_names = ("hostname", "status", "hostkey", "timestamp");
 
 # holds all registrated clients
 our $known_clients_db;
 our $known_clients_tn = "known_clients";
 my $known_clients_file_name;
-my @known_clients_col_names = ('hostname', 'status', 'hostkey', 'timestamp', 'macaddress', 'events');
+my @known_clients_col_names = ("hostname", "status", "hostkey", "timestamp", "macaddress", "events");
 
 # holds all logged in user at each client 
 our $login_users_db;
 our $login_users_tn = "login_users";
 my $login_users_file_name;
-my @login_users_col_names = ('client', 'user', 'timestamp');
+my @login_users_col_names = ("client", "user", "timestamp");
 
 # holds all fai server, the debian release and tag
 our $fai_server_db;
 our $fai_server_tn = "fai_server"; 
 my $fai_server_file_name;
-our @fai_server_col_names = ('timestamp', 'server', 'release', 'tag'); 
+our @fai_server_col_names = ("timestamp", "server", "release", "sections", "tag"); 
+
+our $fai_release_db;
 our $fai_release_tn = "fai_release"; 
-our @fai_release_col_names = ('timestamp', 'release', 'class', 'type', 'state'); 
+my $fai_release_file_name;
+our @fai_release_col_names = ("timestamp", "release", "class", "type", "state"); 
 
 # holds all packages available from different repositories
 our $packages_list_db;
 our $packages_list_tn = "packages_list";
 my $packages_list_file_name;
-our @packages_list_col_names = ('distribution', 'package', 'version', 'section', 'description', 'template', 'timestamp');
+our @packages_list_col_names = ("distribution", "package", "version", "section", "description", "template", "timestamp");
 my $outdir = "/tmp/packages_list_db";
 my $arch = "i386"; 
 
 # holds all messages which should be delivered to a user
 our $messaging_db;
 our $messaging_tn = "messaging"; 
-our @messaging_col_names = ('subject', 'from', 'to', 'flag', 'direction', 'delivery_time', 'message', 'timestamp', 'id INTEGER', );
+our @messaging_col_names = ("id INTEGER", "subject", "message_from", "message_to", 
+        "flag", "direction", "delivery_time", "message", "timestamp" );
 my $messaging_file_name;
 
 # path to directory to store client install log files
 our $client_fai_log_dir = "/var/log/fai"; 
 
+# queue which stores taskes until one of the $max_children children are ready to process the task
+my @tasks = qw();
+my $max_children = 2;
+
+
 %cfg_defaults = (
 "general" => {
     "log-file" => [\$log_file, "/var/run/".$prg.".log"],
@@ -159,10 +194,12 @@ our $client_fai_log_dir = "/var/log/fai";
     "known-clients" => [\$known_clients_file_name, '/var/lib/gosa-si/clients.db' ],
     "known-servers" => [\$known_server_file_name, '/var/lib/gosa-si/servers.db'],
     "login-users" => [\$login_users_file_name, '/var/lib/gosa-si/users.db'],
-    "fai-server" => [\$fai_server_file_name, '/var/lib/gosa-si/fai.db'],
+    "fai-server" => [\$fai_server_file_name, '/var/lib/gosa-si/fai_server.db'],
+    "fai-release" => [\$fai_release_file_name, '/var/lib/gosa-si/fai_release.db'],
     "packages-list" => [\$packages_list_file_name, '/var/lib/gosa-si/packages.db'],
     "messaging" => [\$messaging_file_name, '/var/lib/gosa-si/messaging.db'],
     "source-list" => [\$sources_list, '/etc/apt/sources.list'],
+    "repo-path" => [\$repo_path, '/srv/www/repository'],
     "ldap-uri" => [\$ldap_uri, ""],
     "ldap-base" => [\$ldap_base, ""],
     "ldap-admin-dn" => [\$ldap_admin_dn, ""],
@@ -175,6 +212,7 @@ our $client_fai_log_dir = "/var/log/fai";
     "port" => [\$gosa_port, "20082"],
     "job-queue" => [\$job_queue_file_name, '/var/lib/gosa-si/jobs.db'],
     "job-queue-loop-delay" => [\$job_queue_loop_delay, 3],
+    "messaging-db-loop-delay" => [\$messaging_db_loop_delay, 3],
     "key" => [\$GosaPackages_key, "none"],
     },
 "SIPackages" => {
@@ -213,7 +251,7 @@ EOF
 #===============================================================================
 sub read_configfile {
     my $cfg;
-    if( defined( $cfg_file) && ( length($cfg_file) > 0 )) {
+    if( defined( $cfg_file) && ( (-s $cfg_file) > 0 )) {
         if( -r $cfg_file ) {
             $cfg = Config::IniFiles->new( -file => $cfg_file );
         } else {
@@ -250,6 +288,7 @@ sub daemon_log {
             print STDERR "cannot open $log_file: $!";
             return }
             chomp($msg);
+                       $msg =~s/\n//g;   # no newlines are allowed in log messages, this is important for later log parsing
             if($level <= $verbose){
                 my ($seconds, $minutes, $hours, $monthday, $month,
                         $year, $weekday, $yearday, $sommertime) = localtime(time);
@@ -313,7 +352,8 @@ sub check_pid {
             chomp( $pid );
             if( -f "/proc/$pid/stat" ) {
                 my($stat) = `cat /proc/$pid/stat` =~ m/$pid \((.+)\).*/;
-                if( $0 eq $stat ) {
+                if( $stat ) {
+                                       daemon_log("ERROR: Already running",1);
                     close( LOCK_FILE );
                     exit -1;
                 }
@@ -401,15 +441,20 @@ sub import_modules {
 sub sig_int_handler {
     my ($signal) = @_;
 
+#      if (defined($ldap_handle)) {
+#              $ldap_handle->disconnect;
+#      }
+    # TODO alle verbliebenden ldap verbindungen aus allen heaps beenden
+    
+
     daemon_log("shutting down gosa-si-server", 1);
-    exit(1);
+    system("kill `ps -C gosa-si-server -o pid=`");
 }
 $SIG{INT} = \&sig_int_handler;
 
 
-
 sub check_key_and_xml_validity {
-    my ($crypted_msg, $module_key) = @_;
+    my ($crypted_msg, $module_key, $session_id) = @_;
     my $msg;
     my $msg_hash;
     my $error_string;
@@ -417,7 +462,8 @@ sub check_key_and_xml_validity {
         $msg = &decrypt_msg($crypted_msg, $module_key);
 
         if ($msg =~ /<xml>/i){
-            daemon_log("decrypted_msg: \n$msg", 8);
+            $msg =~ s/\s+/ /g;  # just for better daemon_log
+            daemon_log("$session_id DEBUG: decrypted_msg: \n$msg", 8);
             $msg_hash = $xml->XMLin($msg, ForceArray=>1);
 
             ##############
@@ -446,7 +492,7 @@ sub check_key_and_xml_validity {
         }
     };
     if($@) {
-        daemon_log("WARNING: do not understand the message: $@", 5);
+        daemon_log("$session_id DEBUG: do not understand the message: $@", 7);
         $msg = undef;
         $msg_hash = undef;
     }
@@ -519,7 +565,7 @@ sub check_outgoing_xml_validity {
 
 
 sub input_from_known_server {
-    my ($input, $remote_ip) = @_ ;  
+    my ($input, $remote_ip, $session_id) = @_ ;  
     my ($msg, $msg_hash, $module);
 
     my $sql_statement= "SELECT * FROM known_server";
@@ -531,13 +577,13 @@ sub input_from_known_server {
             next;
         }
         my $host_key = $hit->{hostkey};
-        daemon_log("DEBUG: input_from_known_server: host_name: $host_name", 7);
+        daemon_log("$session_id DEBUG: input_from_known_server: host_name: $host_name", 7);
         daemon_log("DEBUG: input_from_known_server: host_key: $host_key", 7);
 
         # check if module can open msg envelope with module key
-        my ($tmp_msg, $tmp_msg_hash) = &check_key_and_xml_validity($input, $host_key);
+        my ($tmp_msg, $tmp_msg_hash) = &check_key_and_xml_validity($input, $host_key, $session_id);
         if( (!$tmp_msg) || (!$tmp_msg_hash) ) {
-            daemon_log("DEBUG: input_from_known_server: deciphering raise error", 7);
+            daemon_log("$session_id DEBUG: input_from_known_server: deciphering raise error", 7);
             daemon_log("$@", 8);
             next;
         }
@@ -550,7 +596,7 @@ sub input_from_known_server {
     }
 
     if( (!$msg) || (!$msg_hash) || (!$module) ) {
-        daemon_log("DEBUG: Incoming message is not from a known server", 7);
+        daemon_log("$session_id DEBUG: Incoming message is not from a known server", 7);
     }
   
     return ($msg, $msg_hash, $module);
@@ -558,7 +604,7 @@ sub input_from_known_server {
 
 
 sub input_from_known_client {
-    my ($input, $remote_ip) = @_ ;  
+    my ($input, $remote_ip, $session_id) = @_ ;  
     my ($msg, $msg_hash, $module);
 
     my $sql_statement= "SELECT * FROM known_clients";
@@ -569,14 +615,14 @@ sub input_from_known_client {
                 next;
                }
         my $host_key = $hit->{hostkey};
-        &daemon_log("DEBUG: input_from_known_client: host_name: $host_name", 7);
-        &daemon_log("DEBUG: input_from_known_client: host_key: $host_key", 7);
+        &daemon_log("$session_id DEBUG: input_from_known_client: host_name: $host_name", 7);
+        &daemon_log("$session_id DEBUG: input_from_known_client: host_key: $host_key", 7);
 
         # check if module can open msg envelope with module key
-        ($msg, $msg_hash) = &check_key_and_xml_validity($input, $host_key);
+        ($msg, $msg_hash) = &check_key_and_xml_validity($input, $host_key, $session_id);
 
         if( (!$msg) || (!$msg_hash) ) {
-            &daemon_log("DEGUG: input_from_known_client: deciphering raise error", 7);
+            &daemon_log("$session_id DEGUG: input_from_known_client: deciphering raise error", 7);
             &daemon_log("$@", 8);
             next;
         }
@@ -587,7 +633,7 @@ sub input_from_known_client {
     }
 
     if( (!$msg) || (!$msg_hash) || (!$module) ) {
-        &daemon_log("DEBUG: Incoming message is not from a known client", 7);
+        &daemon_log("$session_id DEBUG: Incoming message is not from a known client", 7);
     }
 
     return ($msg, $msg_hash, $module);
@@ -596,7 +642,7 @@ sub input_from_known_client {
 
 sub input_from_unknown_host {
     no strict "refs";
-    my ($input) = @_ ;
+    my ($input, $session_id) = @_ ;
     my ($msg, $msg_hash, $module);
     my $error_string;
     
@@ -610,13 +656,13 @@ sub input_from_unknown_host {
             if( $mod eq 'ArpHandler' ) {
                 next;
             }
-            daemon_log("ERROR: no key specified in config file for $mod", 1);
+            daemon_log("$session_id ERROR: no key specified in config file for $mod", 1);
             next;
         }
-        daemon_log("DEBUG: $mod: $module_key", 7);
+        daemon_log("$session_id DEBUG: $mod: $module_key", 7);
 
         # check if module can open msg envelope with module key
-        ($msg, $msg_hash) = &check_key_and_xml_validity($input, $module_key);
+        ($msg, $msg_hash) = &check_key_and_xml_validity($input, $module_key, $session_id);
         if( (not defined $msg) || (not defined $msg_hash) ) {
             next;
         }
@@ -627,7 +673,7 @@ sub input_from_unknown_host {
     }
 
     if( (!$msg) || (!$msg_hash) || (!$module)) {
-        daemon_log("DEBUG: Incoming message is not from an unknown host", 7);
+        daemon_log("$session_id DEBUG: Incoming message is not from an unknown host", 7);
     }
 
     return ($msg, $msg_hash, $module);
@@ -810,7 +856,7 @@ sub get_local_ip_for_remote_ip {
 
 
 sub send_msg_to_target {
-    my ($msg, $address, $encrypt_key, $msg_header) = @_ ;
+    my ($msg, $address, $encrypt_key, $msg_header, $session_id) = @_ ;
     my $error = 0;
     my $header;
     my $new_status;
@@ -835,7 +881,7 @@ sub send_msg_to_target {
     # opensocket
     my $socket = &open_socket($address);
     if( !$socket ) {
-        daemon_log("ERROR: cannot send ".$header."msg to $address , host not reachable", 1);
+        daemon_log("$session_id ERROR: cannot send ".$header."msg to $address , host not reachable", 1);
         $error++;
     }
     
@@ -843,8 +889,8 @@ sub send_msg_to_target {
         # send xml msg
         print $socket $crypted_msg."\n";
 
-        daemon_log("INFO: send ".$header."msg to $address", 5);
-        daemon_log("message:\n$msg", 8);
+        daemon_log("$session_id INFO: send ".$header."msg to $address", 5);
+        #daemon_log("DEBUG: message:\n$msg", 9);
         
     }
 
@@ -865,14 +911,14 @@ sub send_msg_to_target {
         if( $act_status eq "down" ) {
             $sql_statement = "DELETE FROM known_clients WHERE hostname='$address'";
             $res = $known_clients_db->del_dbentry($sql_statement);
-            daemon_log("WARNING: failed 2x to send msg to host '$address', delete host from known_clients", 3);
+            daemon_log("$session_id WARNING: failed 2x to send msg to host '$address', delete host from known_clients", 3);
         } else { 
             $sql_statement = "UPDATE known_clients SET status='$new_status' WHERE hostname='$address'";
             $res = $known_clients_db->update_dbentry($sql_statement);
             if($new_status eq "down"){
-                daemon_log("WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
+                daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
             } else {
-                daemon_log("INFO: set '$address' from status '$act_status' to '$new_status'", 5);
+                daemon_log("$session_id INFO: set '$address' from status '$act_status' to '$new_status'", 5);
             }
         }
     }
@@ -885,16 +931,16 @@ sub send_msg_to_target {
         if( $act_status eq "down" ) {
             $sql_statement = "DELETE FROM known_server WHERE hostname='$address'";
             $res = $known_server_db->del_dbentry($sql_statement);
-            daemon_log("WARNING: failed 2x to a send msg to host '$address', delete host from known_server", 3);
+            daemon_log("$session_id WARNING: failed 2x to a send msg to host '$address', delete host from known_server", 3);
         } 
         else { 
             $sql_statement = "UPDATE known_server SET status='$new_status' WHERE hostname='$address'";
             $res = $known_server_db->update_dbentry($sql_statement);
             if($new_status eq "down"){
-                daemon_log("WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
+                daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
             }
             else {
-                daemon_log("INFO: set '$address' from status '$act_status' to '$new_status'", 5);
+                daemon_log("$session_id INFO: set '$address' from status '$act_status' to '$new_status'", 5);
             }
         }
     }
@@ -906,76 +952,150 @@ sub update_jobdb_status_for_send_msgs {
     my ($answer, $error) = @_;
     if( $answer =~ /<jobdb_id>(\d+)<\/jobdb_id>/ ) {
         my $jobdb_id = $1;
+            
+        # sending msg faild
         if( $error ) {
             if (not $answer =~ /<header>trigger_action_reinstall<\/header>/) {
-                # sending msg faild
                 my $sql_statement = "UPDATE $job_queue_tn ".
                     "SET status='error', result='can not deliver msg, please consult log file' ".
-                    "WHERE id='$jobdb_id'";
+                    "WHERE id=$jobdb_id";
                 my $res = $job_db->update_dbentry($sql_statement);
             }
+
+        # sending msg was successful
         } else {
-            # sending msg was successful
             my $sql_statement = "UPDATE $job_queue_tn ".
                 "SET status='done' ".
-                "WHERE id='$jobdb_id' AND status='processed'";
+                "WHERE id=$jobdb_id AND status='processed'";
             my $res = $job_db->update_dbentry($sql_statement);
         }
     }
 }
 
-
 sub _start {
     my ($kernel) = $_[KERNEL];
     &trigger_db_loop($kernel);
-    $kernel->yield('create_fai_server_db', $fai_server_tn );
+    $global_kernel = $kernel;
+       $kernel->yield('create_fai_server_db', $fai_server_tn );
        $kernel->yield('create_fai_release_db', $fai_release_tn );
-    #$kernel->yield('create_packages_list_db', $sources_list );
+       $kernel->sig(USR1 => "sig_handler");
+       $kernel->sig(USR2 => "create_packages_list_db");
+}
+
+sub sig_handler {
+       my ($kernel, $signal) = @_[KERNEL, ARG0] ;
+       daemon_log("0 INFO got signal '$signal'", 1); 
+       $kernel->sig_handled();
+       return;
+}
+
+sub next_task {
+    my ($session, $heap) = @_[SESSION, HEAP];
+
+    while ( keys( %{ $heap->{task} } ) < $max_children ) {
+        my $next_task = shift @tasks;
+        last unless defined $next_task;
+
+        my $task = POE::Wheel::Run->new(
+                Program => sub { process_task($session, $heap, $next_task) },
+                StdioFilter => POE::Filter::Reference->new(),
+                StdoutEvent  => "task_result",
+                StderrEvent  => "task_debug",
+                CloseEvent   => "task_done",
+               );
+
+        $heap->{task}->{ $task->ID } = $task;
+    }
+}
+
+sub handle_task_result {
+    my ($kernel, $heap, $result) = @_[KERNEL, HEAP, ARG0];
+    my $client_answer = $result->{'answer'};
+    if( $client_answer =~ s/session_id=(\d+)$// ) {
+        my $session_id = $1;
+        if( defined $session_id ) {
+            my $session_reference = $kernel->ID_id_to_session($session_id);
+            if( defined $session_reference ) {
+                $heap = $session_reference->get_heap();
+            }
+        }
+
+        if(exists $heap->{'client'}) {
+            $heap->{'client'}->put($client_answer);
+        }
+    }
+    $kernel->sig(CHLD => "child_reap");
+}
+
+sub handle_task_debug {
+    my $result = $_[ARG0];
+    print STDERR "$result\n";
 }
 
+sub handle_task_done {
+    my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
+    delete $heap->{task}->{$task_id};
+    $kernel->yield("next_task");
+}
 
-sub client_input {
+sub process_task {
     no strict "refs";
-    my ($kernel, $session, $heap, $input, $wheel) = @_[KERNEL, SESSION, HEAP, ARG0, ARG1];
+    my ($session, $heap, $input) = @_;
     my $session_id = $session->ID;
     my ($msg, $msg_hash, $module);
     my $error = 0;
     my $answer_l;
     my ($answer_header, @answer_target_l, $answer_source);
-    my $client_answer;
+    my $client_answer = "";
 
     daemon_log("", 5); 
-    daemon_log("INFO: Incoming msg from '".$heap->{'remote_ip'}."'", 5);
-    daemon_log("DEBUG: Incoming msg:\n$input", 9);
+    daemon_log("$session_id INFO: Incoming msg with session ID $session_id from '".$heap->{'remote_ip'}."'", 5);
+    #daemon_log("$session_id DEBUG: Incoming msg:\n$input", 9);
 
     ####################
     # check incoming msg
     # msg is from a new client or gosa
-    ($msg, $msg_hash, $module) = &input_from_unknown_host($input);
+    ($msg, $msg_hash, $module) = &input_from_unknown_host($input, $session_id);
     # msg is from a gosa-si-server or gosa-si-bus
     if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
-        ($msg, $msg_hash, $module) = &input_from_known_server($input, $heap->{'remote_ip'});
+        ($msg, $msg_hash, $module) = &input_from_known_server($input, $heap->{'remote_ip'}, $session_id);
     }
     # msg is from a gosa-si-client
     if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
-        ($msg, $msg_hash, $module) = &input_from_known_client($input, $heap->{'remote_ip'});
+        ($msg, $msg_hash, $module) = &input_from_known_client($input, $heap->{'remote_ip'}, $session_id);
     }
     # an error occurred
     if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
+        # if an incoming msg could not be decrypted (maybe a wrong key), send client a ping. If the client
+        # could not understand a msg from its server the client cause a re-registering process
+        daemon_log("$session_id INFO cannot understand incoming msg, send 'ping'-msg to all host with ip '".$heap->{remote_ip}."' to cause a re-registering of the client if necessary", 5);
+        my $sql_statement = "SELECT * FROM $main::known_clients_tn WHERE (hostname LIKE '".$heap->{'remote_ip'}."%')";
+        my $query_res = $known_clients_db->select_dbentry( $sql_statement ); 
+        while( my ($hit_num, $hit) = each %{ $query_res } ) {    
+            my $host_name = $hit->{'hostname'};
+            my $host_key = $hit->{'hostkey'};
+            my $ping_msg = "<xml> <header>gosa_ping</header> <source>$server_address</source> <target>$host_name</target></xml>";
+            my $error = &send_msg_to_target($ping_msg, $host_name, $host_key, "gosa_ping", $session_id);
+            &update_jobdb_status_for_send_msgs($ping_msg, $error);
+        }
         $error++;
     }
 
     ######################
     # process incoming msg
     if( $error == 0) {
-        daemon_log("INFO: Incoming msg with header '".@{$msg_hash->{'header'}}[0]."'", 5); 
-        daemon_log("DEBUG: Processing module ".$module, 7);
+        daemon_log("$session_id INFO: Incoming msg with header '".@{$msg_hash->{'header'}}[0].
+                               "' from '".$heap->{'remote_ip'}."'", 5); 
+        daemon_log("$session_id DEBUG: Processing module ".$module, 7);
         $answer_l = &{ $module."::process_incoming_msg" }($msg, $msg_hash, $session_id);
 
-        if ( 0 > @{$answer_l} ) {
+        if ( 0 < @{$answer_l} ) {
             my $answer_str = join("\n", @{$answer_l});
-            daemon_log("DEGUB: $module: Got answer from module: \n".$answer_str,8);
+            daemon_log("$session_id DEBUG: $module: Got answer from module: \n".$answer_str,8);
+        } else {
+            daemon_log("$session_id DEBUG: $module: Got no answer from module!" ,8);
         }
+
     }
     if( !$answer_l ) { $error++ };
 
@@ -1007,7 +1127,7 @@ sub client_input {
                     while( my ($hit_num, $hit) = each %{ $query_res } ) {    
                         my $host_name = $hit->{hostname};
                         my $host_key = $hit->{hostkey};
-                        my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header);
+                        my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
                         &update_jobdb_status_for_send_msgs($answer, $error);
                     }
                 }
@@ -1021,16 +1141,15 @@ sub client_input {
                         my $host_name = $hit->{hostname};
                         my $host_key = $hit->{hostkey};
                         $answer =~ s/KNOWN_SERVER/$host_name/g;
-                        my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header);
+                        my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
                         &update_jobdb_status_for_send_msgs($answer, $error);
                     }
                 }
 
                 # target of msg is GOsa
-                elsif( $answer_target eq "GOSA" ) {
-                    $answer =~ /<session_id>(\d+)<\/session_id>/;
-                    my $session_id = $1;
-                    my $add_on = "";
+                               elsif( $answer_target eq "GOSA" ) {
+                                       my $session_id = ($1) if $answer =~ /<session_id>(\d+?)<\/session_id>/;
+                                       my $add_on = "";
                     if( defined $session_id ) {
                         $add_on = ".session_id=$session_id";
                     }
@@ -1044,13 +1163,13 @@ sub client_input {
                     $answer =~ /<header>(\S+)<\/header>/;   
                     my $header;
                     if( defined $1 ) { $header = $1; }
-                    my $error = &send_msg_to_target($answer, $server_address, $GosaPackages_key, $header);
+                    my $error = &send_msg_to_target($answer, $server_address, $GosaPackages_key, $header, $session_id);
                     &update_jobdb_status_for_send_msgs($answer, $error);
                 }
 
                 # target of msg is a mac address
                 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 ) {
-                    daemon_log("INFO: target is mac address '$answer_target', looking for host in known_clients", 5);
+                    daemon_log("$session_id INFO: target is mac address '$answer_target', looking for host in known_clients", 5);
                     my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$answer_target'";
                     my $query_res = $known_clients_db->select_dbentry( $sql_statement );
                     my $found_ip_flag = 0;
@@ -1058,21 +1177,21 @@ sub client_input {
                         my $host_name = $hit->{hostname};
                         my $host_key = $hit->{hostkey};
                         $answer =~ s/$answer_target/$host_name/g;
-                        daemon_log("INFO: found host '$host_name', associated to '$answer_target'", 5);
-                        my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header);
+                        daemon_log("$session_id INFO: found host '$host_name', associated to '$answer_target'", 5);
+                        my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
                         &update_jobdb_status_for_send_msgs($answer, $error);
                         $found_ip_flag++ ;
                     }   
                     if( $found_ip_flag == 0) {
-                        daemon_log("WARNING: no host found in known_clients with mac address '$answer_target'", 3);
+                        daemon_log("$session_id WARNING: no host found in known_clients with mac address '$answer_target'", 3);
                         if( $bus_activ eq "true" ) { 
-                            daemon_log("INFO: try to forward msg '$answer_header' to bus '$bus_address'", 5);
+                            daemon_log("$session_id INFO: try to forward msg '$answer_header' to bus '$bus_address'", 5);
                             my $sql_statement = "SELECT * FROM known_server WHERE hostname='$bus_address'";
                             my $query_res = $known_server_db->select_dbentry( $sql_statement );
                             while( my ($hit_num, $hit) = each %{ $query_res } ) {    
                                 my $bus_address = $hit->{hostname};
                                 my $bus_key = $hit->{hostkey};
-                                my $error = &send_msg_to_target($answer, $bus_address, $bus_key, $answer_header);
+                                my $error = &send_msg_to_target($answer, $bus_address, $bus_key, $answer_header, $session_id);
                                 &update_jobdb_status_for_send_msgs($answer, $error);
                                 last;
                             }
@@ -1086,57 +1205,55 @@ sub client_input {
                     my $encrypt_key = &get_encrypt_key($answer_target);
                     if( not defined $encrypt_key ) {
                         # unknown target, forward msg to bus
-                        daemon_log("WARNING: unknown target '$answer_target'", 3);
+                        daemon_log("$session_id WARNING: unknown target '$answer_target'", 3);
                         if( $bus_activ eq "true" ) { 
-                            daemon_log("INFO: try to forward msg '$answer_header' to bus '$bus_address'", 5);
+                            daemon_log("$session_id INFO: try to forward msg '$answer_header' to bus '$bus_address'", 5);
                             my $sql_statement = "SELECT * FROM known_server WHERE hostname='$bus_address'";
                             my $query_res = $known_server_db->select_dbentry( $sql_statement );
                             my $res_length = keys( %{$query_res} );
                             if( $res_length == 0 ){
-                                daemon_log("WARNING: send '$answer_header' to '$bus_address' failed, ".
+                                daemon_log("$session_id WARNING: send '$answer_header' to '$bus_address' failed, ".
                                         "no bus found in known_server", 3);
                             }
                             else {
                                 while( my ($hit_num, $hit) = each %{ $query_res } ) {    
                                     my $bus_key = $hit->{hostkey};
-                                    my $error = &send_msg_to_target($answer, $bus_address, $bus_key, $answer_header);
+                                    my $error = &send_msg_to_target($answer, $bus_address, $bus_key, $answer_header,$session_id );
                                     &update_jobdb_status_for_send_msgs($answer, $error);
                                 }
                             }
                         }
                         next;
                     }
-                    my $error = &send_msg_to_target($answer, $answer_target, $encrypt_key, $answer_header);
+                    my $error = &send_msg_to_target($answer, $answer_target, $encrypt_key, $answer_header,$session_id);
                     &update_jobdb_status_for_send_msgs($answer, $error);
                 }
             }
         }
     }
 
-    if( $client_answer ) {
-        if( $client_answer =~ s/session_id=(\d+)$// ) {
-            my $session_id = $1;
-            if( defined $session_id ) {
-                my $session_reference = $kernel->ID_id_to_session($session_id);
-                if( defined $session_reference ) {
-                    $heap = $session_reference->get_heap();
-                }
-            }     
-        }
-        $heap->{client}->put($client_answer);
-    }
+    my $filter = POE::Filter::Reference->new();
+    my %result = ( 
+            status => "seems ok to me",
+            answer => $client_answer,
+            );
 
-    return;
-}
+    my $output = $filter->put( [ \%result ] );
+    print @$output;
 
 
+}
+
 
 sub trigger_db_loop {
        my ($kernel) = @_ ;
        $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
-    $kernel->delay_set('watch_for_done_jobs', $job_queue_loop_delay); 
+       $kernel->delay_set('watch_for_done_jobs', $job_queue_loop_delay); 
+       $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
+       $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
 }
 
+
 sub watch_for_done_jobs {
     my ($kernel,$heap) = @_[KERNEL, HEAP];
 
@@ -1146,97 +1263,229 @@ sub watch_for_done_jobs {
 
     while( my ($id, $hit) = each %{$res} ) {
         my $jobdb_id = $hit->{id};
-        my $sql_statement = "DELETE FROM $job_queue_tn WHERE id='$jobdb_id'"; 
-        my $res = $job_db->del_dbentry($sql_statement);
+        my $sql_statement = "DELETE FROM $job_queue_tn WHERE id=$jobdb_id"; 
+        my $res = $job_db->del_dbentry($sql_statement);        
     }
 
     $kernel->delay_set('watch_for_done_jobs',$job_queue_loop_delay);
 }
 
+
 sub watch_for_new_jobs {
-       my ($kernel,$heap) = @_[KERNEL, HEAP];
+       if($watch_for_new_jobs_in_progress == 0) {
+               $watch_for_new_jobs_in_progress = 1;
+               my ($kernel,$heap) = @_[KERNEL, HEAP];
+
+               # check gosa job queue for jobs with executable timestamp
+               my $timestamp = &get_time();
+               my $sql_statement = "SELECT * FROM $job_queue_tn WHERE status='waiting' AND (CAST (timestamp AS INTEGER)) < $timestamp ORDER BY timestamp";
+               my $res = $job_db->exec_statement( $sql_statement );
+
+               # Merge all new jobs that would do the same actions
+               my @drops;
+               my $hits;
+               foreach my $hit (reverse @{$res} ) {
+                       my $macaddress= lc @{$hit}[8];
+                       my $headertag= @{$hit}[5];
+                       if(
+                               defined($hits->{$macaddress}) &&
+                               defined($hits->{$macaddress}->{$headertag}) &&
+                               defined($hits->{$macaddress}->{$headertag}[0])
+                       ) {
+                               push @drops, "DELETE FROM $job_queue_tn WHERE id = $hits->{$macaddress}->{$headertag}[0]";
+                       }
+                       $hits->{$macaddress}->{$headertag}= $hit;
+               }
 
-       # check gosa job queue for jobs with executable timestamp
-    my $timestamp = &get_time();
-    my $sql_statement = "SELECT * FROM ".$job_queue_tn.
-        " WHERE status='waiting' AND timestamp<'$timestamp'";
-       my $res = $job_db->select_dbentry( $sql_statement );
+               # Delete new jobs with a matching job in state 'processing'
+               foreach my $macaddress (keys %{$hits}) {
+                       foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
+                               my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
+                               if(defined($jobdb_id)) {
+                                       my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND headertag='$jobdb_headertag' AND status='processing'";
+                                       my $res = $job_db->exec_statement( $sql_statement );
+                                       foreach my $hit (@{$res}) {
+                                               push @drops, "DELETE FROM $job_queue_tn WHERE id=$jobdb_id";
+                                       }
+                               } else {
+                                       daemon_log("J ERROR: Job without id exists for macaddress $macaddress!", 1);
+                               }
+                       }
+               }
 
-       while( my ($id, $hit) = each %{$res} ) {         
-               my $jobdb_id = $hit->{id};
-               my $macaddress = $hit->{'macaddress'};
-        my $job_msg = $hit->{'xmlmessage'};
-        daemon_log("DEBUG: its time to execute $job_msg", 7); 
-        my $header = $hit->{'headertag'};
-        my $sql_statement = "SELECT * FROM known_clients WHERE macaddress='$macaddress'";
-               my $res_hash = $known_clients_db->select_dbentry( $sql_statement );
-               # expect macaddress is unique!!!!!!
-               my $target = $res_hash->{1}->{hostname};
-
-               if (not defined $target) {
-                       &daemon_log("ERROR: no host found for mac address: $macaddress", 1);
-                       &daemon_log("$hit->{xmlmessage}", 8);
-            my $sql_statement = "UPDATE $job_queue_tn ".
-                "SET status='error', result='no host found for mac address' ".
-                "WHERE id='$jobdb_id'";
-                       my $res = $job_db->update_dbentry($sql_statement);
-                       next;
+               # Commit deletion
+               $job_db->exec_statementlist(\@drops);
+
+               # Look for new jobs that could be executed
+               foreach my $macaddress (keys %{$hits}) {
+
+                       # Look if there is an executing job
+                       my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND status='processing'";
+                       my $res = $job_db->exec_statement( $sql_statement );
+
+                       # Skip new jobs for host if there is a processing job
+                       if(defined($res) and defined @{$res}[0]) {
+                               next;
+                       }
+
+                       foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
+                               my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
+                               if(defined($jobdb_id)) {
+                                       my $job_msg = @{$hits->{$macaddress}->{$jobdb_headertag}}[7];
+
+                                       daemon_log("J DEBUG: its time to execute $job_msg", 7);
+                                       my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$macaddress'";
+                                       my $res_hash = $known_clients_db->select_dbentry( $sql_statement );
+
+                                       # expect macaddress is unique!!!!!!
+                                       my $target = $res_hash->{1}->{hostname};
+
+                                       # change header
+                                       $job_msg =~ s/<header>job_/<header>gosa_/;
+
+                                       # add sqlite_id
+                                       $job_msg =~ s/<\/xml>$/<jobdb_id>$jobdb_id<\/jobdb_id><\/xml>/;
+
+                                       $job_msg =~ /<header>(\S+)<\/header>/;
+                                       my $header = $1 ;
+                                       my $func_error = &send_msg_to_target($job_msg, $server_address, $GosaPackages_key, $header, "J");
+
+                                       # update status in job queue to 'processing'
+                                       $sql_statement = "UPDATE $job_queue_tn SET status='processing' WHERE id=$jobdb_id";
+                                       my $res = $job_db->update_dbentry($sql_statement);
+# TODO: abfangen ob alles in ordnung ist oder nicht, wenn nicht error schmeißen                                       
+
+                                       # We don't want parallel processing
+                                       last;
+                               }
+                       }
                }
 
-               # change header
-        $job_msg =~ s/<header>job_/<header>gosa_/;
+               $watch_for_new_jobs_in_progress = 0;
+               $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
+       }
+}
+
+
+sub watch_for_new_messages {
+    my ($kernel,$heap) = @_[KERNEL, HEAP];
+    my @coll_user_msg;   # collection list of outgoing messages
+    
+    # check messaging_db for new incoming messages with executable timestamp
+    my $timestamp = &get_time();
+    my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( (CAST(timestamp AS INTEGER))<$timestamp AND flag='n' AND direction='in' )";
+    my $res = $messaging_db->exec_statement( $sql_statement );
+       foreach my $hit (@{$res}) {
+
+        # create outgoing messages
+        my $message_to = @{$hit}[3];
+
+        # translate message_to to plain login name
+# TODO implement reciever translation
+        my @reciever_l = ($message_to);  
+        my $message_id = @{$hit}[0];
+
+        #add each outgoing msg to messaging_db
+        my $reciever;
+        foreach $reciever (@reciever_l) {
+            my $sql_statement = "INSERT INTO $messaging_tn (id, subject, message_from, message_to, flag, direction, delivery_time, message, timestamp) ".
+                "VALUES ('".
+                $message_id."', '".    # id
+                @{$hit}[1]."', '".     # subject
+                @{$hit}[2]."', '".     # message_from
+                $reciever."', '".      # message_to
+                "none"."', '".         # flag
+                "out"."', '".          # direction
+                @{$hit}[6]."', '".     # delivery_time
+                @{$hit}[7]."', '".     # message
+                $timestamp."'".     # timestamp
+                ")";
+            &daemon_log("M DEBUG: $sql_statement", 1);
+            my $res = $messaging_db->exec_statement($sql_statement);
+            &daemon_log("M INFO: message '".@{$hit}[0]."' is prepared for delivery to reciever '$reciever'", 5);
+        }
 
-               # add sqlite_id 
-        $job_msg =~ s/<\/xml>$/<jobdb_id>$jobdb_id<\/jobdb_id><\/xml>/;
+        # send outgoing messages
+        my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( flag='p' AND direction='out' )";
+        my $res = $messaging_db->exec_statement( $sql_statement );
+        foreach my $hit (@{$res}) {
+            # add subject, from, to and message to list coll_user_msg
+            my @user_msg = [@{$hit}[1], @{$hit}[2], $reciever, @{$hit}[7]];
+            push( @coll_user_msg, \@user_msg);
+        }
 
-               my $func_error = &send_msg_to_target($job_msg, $server_address, $GosaPackages_key, $header);
+        # send outgoing list to myself (gosa-si-server) to deliver each message to user
+        # reason for this workaround: if to much messages have to be delivered, it can come to 
+        # denial of service problems of the server. so, the incoming message list can be processed
+        # by a forked child and gosa-si-server is always ready to work. 
+        my $collection_out_msg = &create_xml_hash("collection_user_messages", $server_address, $server_address);
+        # add to hash 'msg1' => [subject, from, to, message]
+        # hash to string
+        # send msg to myself
+# TODO
+
+        # set incoming message to flag d=deliverd
+        $sql_statement = "UPDATE $messaging_tn SET flag='p' WHERE id='$message_id'"; 
+        &daemon_log("M DEBUG: $sql_statement", 7);
+        $res = $messaging_db->update_dbentry($sql_statement);
+        &daemon_log("M INFO: message '$message_id' is set to flag 'p' (processed)", 5);
 
-        # update status in job queue to 'processing'
-        $sql_statement = "UPDATE $job_queue_tn SET status='processing' WHERE id='$jobdb_id'";
-        my $res = $job_db->update_dbentry($sql_statement);
     }
+    
+    $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay); 
 
-       $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
+
+    return;
+}
+
+
+sub watch_for_done_messages {
+    my ($kernel,$heap) = @_[KERNEL, HEAP];
+
+    $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay); 
+    return;
 }
 
 
-sub refresh_ldap_handle {
-  my $mesg;
+sub get_ldap_handle {
+       my ($session_id) = @_;
+       my $heap;
+       my $ldap_handle;
 
-  # Get an ldap handle, if we don't have one
-  if( ! defined $ldap_handle ){
-         $ldap_handle = Net::LDAP->new( $ldap_uri );
-  }
-  # Still not defined?
-  if( ! defined $ldap_handle ) {
-         daemon_log( "ch $$: Net::LDAP constructor failed: $!\n" );
-         return 0;
-  }
+       if (not defined $session_id ) { $session_id = 0 };
+       if ($session_id =~ /[^0-9]*/) { $session_id = 0 };
 
-  # Bind to ldap server - eventually authenticate
-  if( defined $ldap_admin_dn ) {
-    if( defined $ldap_admin_password ) {
-      $mesg = $ldap_handle->bind( $ldap_admin_dn, password => $ldap_admin_password );
-    } else {
-      $mesg = $ldap_handle->bind( $ldap_admin_dn );
-    }
-  } else {
-    $mesg = $ldap_handle->bind();
-  }
+       if ($session_id == 0) {
+               daemon_log("$session_id DEBUG: get_ldap_handle invoked without a session_id, create a new ldap_handle", 7); 
+               $ldap_handle = Net::LDAP->new( $ldap_uri );
+               $ldap_handle->bind($ldap_admin_dn, password => $ldap_admin_password); 
 
-  if( 0 != $mesg->code ) {
-    undef( $ldap_handle ) if( 81 == $mesg->code );
-    daemon_log( "ch $$: LDAP bind: error (". $mesg->code . ') - ' . $mesg->error . "\n", 1);
-    return 0;
-  }
+       } else {
+               my $session_reference = $global_kernel->ID_id_to_session($session_id);
+               if( defined $session_reference ) {
+                       $heap = $session_reference->get_heap();
+               }
+
+               if (not defined $heap) {
+                       daemon_log("$session_id DEBUG: cannot get heap for session_id '$session_id'", 7); 
+                       return;
+               }
 
-  return 1;
+               # TODO: This "if" is nonsense, because it doesn't prove that the
+                #       used handle is still valid - or if we've to reconnect...
+               #if (not exists $heap->{ldap_handle}) {
+                       $ldap_handle = Net::LDAP->new( $ldap_uri );
+                       $ldap_handle->bind($ldap_admin_dn, password => $ldap_admin_password); 
+                       $heap->{ldap_handle} = $ldap_handle;
+               #}
+       }
+       return $ldap_handle;
 }
 
 
 sub change_fai_state {
-    my ($st, $targets) = @_;
-
+    my ($st, $targets, $session_id) = @_;
+    $session_id = 0 if not defined $session_id;
     # Set FAI state to localboot
     my %mapActions= (
         reboot    => '',
@@ -1247,29 +1496,32 @@ sub change_fai_state {
         wake      => '',
         memcheck  => 'memcheck',
         sysinfo   => 'sysinfo',
+        install   => 'install',
     );
 
     # Return if this is unknown
     if (!exists $mapActions{ $st }){
+        daemon_log("$session_id ERROR: unknown action '$st', can not translate ot FAIstate", 1); 
       return;
     }
 
     my $state= $mapActions{ $st };
 
-    &refresh_ldap_handle();
+    my $ldap_handle = &get_ldap_handle($session_id);
     if( defined($ldap_handle) ) {
 
       # Build search filter for hosts
-      my $search= "(&(objectClass=GOhard)";
-      foreach (@{$targets}){
-        $search.= "(macAddress=$_)";
-      }
-      $search.= ")";
+        my $search= "(&(objectClass=GOhard)";
+        foreach (@{$targets}){
+            $search.= "(macAddress=$_)";
+        }
+        $search.= ")";
 
       # If there's any host inside of the search string, procress them
-      if (!($search =~ /macAddress/)){
-        return;
-      }
+        if (!($search =~ /macAddress/)){
+            daemon_log("$session_id ERROR: no macAddress found in filter statement for LDAP search: '$search'", 1);    
+            return;
+        }
 
       # Perform search for Unit Tag
       my $mesg = $ldap_handle->search(
@@ -1279,49 +1531,53 @@ sub change_fai_state {
           filter => "$search"
           );
 
-      if ($mesg->count) {
-        my @entries = $mesg->entries;
-        foreach my $entry (@entries) {
-
-          # Only modify entry if it is not set to '$state'
-          if ($entry->get_value("FAIstate") ne "$state"){
-
-            daemon_log("INFO: Setting FAIstate to '$state' for ".$entry->dn, 5);
-            my $result;
-            my %tmp = map { $_ => 1 } $entry->get_value("objectClass");
-            if (exists $tmp{'FAIobject'}){
-              if ($state eq ''){
-                $result= $ldap_handle->modify($entry->dn, changes => [
-                            delete => [ FAIstate => [] ] ]);
-              } else {
-                $result= $ldap_handle->modify($entry->dn, changes => [
-                            replace => [ FAIstate => $state ] ]);
-              }
-            } elsif ($state ne ''){
-              $result= $ldap_handle->modify($entry->dn, changes => [
-                          add     => [ objectClass => 'FAIobject' ],
-                          add     => [ FAIstate => $state ] ]);
-            }
-
-            # Errors?
-            if ($result->code){
-              daemon_log("Error: Setting FAIstate to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
-            }
-
-          }
-        }
-      }
+         if ($mesg->count) {
+                 my @entries = $mesg->entries;
+                 foreach my $entry (@entries) {
+                         # Only modify entry if it is not set to '$state'
+                         if ($entry->get_value("FAIstate") ne "$state"){
+                                 daemon_log("$session_id INFO: Setting FAIstate to '$state' for ".$entry->dn, 5);
+                                 my $result;
+                                 my %tmp = map { $_ => 1 } $entry->get_value("objectClass");
+                                 if (exists $tmp{'FAIobject'}){
+                                         if ($state eq ''){
+                                                 $result= $ldap_handle->modify($entry->dn, changes => [
+                                                         delete => [ FAIstate => [] ] ]);
+                                         } else {
+                                                 $result= $ldap_handle->modify($entry->dn, changes => [
+                                                         replace => [ FAIstate => $state ] ]);
+                                         }
+                                 } elsif ($state ne ''){
+                                         $result= $ldap_handle->modify($entry->dn, changes => [
+                                                 add     => [ objectClass => 'FAIobject' ],
+                                                 add     => [ FAIstate => $state ] ]);
+                                 }
+
+                                 # Errors?
+                                 if ($result->code){
+                                         daemon_log("$session_id Error: Setting FAIstate to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
+                                 }
+                         } else {
+                                 daemon_log("$session_id DEBUG FAIstate at host '".$entry->dn."' already at state '$st'", 7); 
+                         }  
+                 }
+         }
+    # if no ldap handle defined
+    } else {
+        daemon_log("$session_id ERROR: no LDAP handle defined for update FAIstate", 1); 
     }
+
 }
 
 
 sub change_goto_state {
-    my ($st, $targets) = @_;
+    my ($st, $targets, $session_id) = @_;
+    $session_id = 0  if not defined $session_id;
 
     # Switch on or off?
     my $state= $st eq 'active' ? 'active': 'locked';
 
-    &refresh_ldap_handle();
+    my $ldap_handle = &get_ldap_handle($session_id);
     if( defined($ldap_handle) ) {
 
       # Build search filter for hosts
@@ -1351,14 +1607,14 @@ sub change_goto_state {
           # Only modify entry if it is not set to '$state'
           if ($entry->get_value("gotoMode") ne $state){
 
-            daemon_log("INFO: Setting gotoMode to '$state' for ".$entry->dn, 5);
+            daemon_log("$session_id INFO: Setting gotoMode to '$state' for ".$entry->dn, 5);
             my $result;
             $result= $ldap_handle->modify($entry->dn, changes => [
                                                 replace => [ gotoMode => $state ] ]);
 
             # Errors?
             if ($result->code){
-              &daemon_log("Error: Setting gotoMode to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
+              &daemon_log("$session_id Error: Setting gotoMode to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
             }
 
           }
@@ -1369,12 +1625,29 @@ sub change_goto_state {
 }
 
 
+sub run_create_fai_server_db {
+    my ($kernel, $session, $heap, $table_name) = @_[KERNEL, SESSION, HEAP, ARG0];
+    my $session_id = $session->ID;
+    my $task = POE::Wheel::Run->new(
+            Program => sub { &create_fai_server_db($table_name,$kernel, undef, $session_id) },
+            StdoutEvent  => "session_run_result",
+            StderrEvent  => "session_run_debug",
+            CloseEvent   => "session_run_done",
+            );
+
+    $heap->{task}->{ $task->ID } = $task;
+    return;
+}
+
+
 sub create_fai_server_db {
-    my ($table_name) = $_[ARG0];
+    my ($table_name, $kernel, $dont_create_packages_list, $session_id) = @_;
        my $result;
 
+       if (not defined $session_id) { $session_id = 0; }
+    my $ldap_handle = &get_ldap_handle();
        if(defined($ldap_handle)) {
-               daemon_log("Creating fai_server_db",4);
+               daemon_log("$session_id INFO: create_fai_server_db: start", 5);
                my $mesg= $ldap_handle->search(
                        base   => $ldap_base,
                        scope  => 'sub',
@@ -1394,25 +1667,51 @@ sub create_fai_server_db {
                                                                   primkey => ['server', 'release', 'tag'],
                                                                   server => $tmp_url,
                                                                   release => $tmp_release,
+                                                                  sections => $tmp_sections,
                                                                   tag => (length($tmp_tag)>0)?$tmp_tag:"",
                                                           } );
                                           }
                                   }
                           }
                   }
-               daemon_log("Done with creating fai_server_db",4);
+               daemon_log("$session_id INFO: create_fai_server_db: finished", 5);
+
+               # TODO: Find a way to post the 'create_packages_list_db' event
+               if(not defined($dont_create_packages_list)) {
+                       &create_packages_list_db(undef, undef, $session_id);
+               }
        }       
-   
+    
+    $ldap_handle->disconnect;
        return $result;
 }
 
 
+sub run_create_fai_release_db {
+    my ($session, $heap, $table_name) = @_[SESSION, HEAP, ARG0];
+       my $session_id = $session->ID;
+    my $task = POE::Wheel::Run->new(
+            Program => sub { &create_fai_release_db($table_name, $session_id) },
+            StdoutEvent  => "session_run_result",
+            StderrEvent  => "session_run_debug",
+            CloseEvent   => "session_run_done",
+            );
+
+    $heap->{task}->{ $task->ID } = $task;
+    return;
+}
+
+
 sub create_fai_release_db {
-       my ($table_name) = $_[ARG0];
+       my ($table_name, $session_id) = @_;
        my $result;
 
+    # used for logging
+    if (not defined $session_id) { $session_id = 0; }
+
+    my $ldap_handle = &get_ldap_handle();
        if(defined($ldap_handle)) {
-               daemon_log("Creating fai_release_db",4);
+               daemon_log("$session_id INFO: create_fai_release_db: start",5);
                my $mesg= $ldap_handle->search(
                        base   => $ldap_base,
                        scope  => 'sub',
@@ -1425,7 +1724,7 @@ sub create_fai_release_db {
                        my @sql_list;
                        my $timestamp= &get_time();
                        foreach my $ou (@{$mesg->{entries}}) {
-                               my $tmp_classes= resolve_fai_classes($ou->dn);
+                               my $tmp_classes= resolve_fai_classes($ou->dn, $ldap_handle, $session_id);
                                if(defined($tmp_classes) && ref($tmp_classes) eq 'HASH') {
                                        my @tmp_array=get_fai_release_entries($tmp_classes);
                                        if(@tmp_array) {
@@ -1445,31 +1744,69 @@ sub create_fai_release_db {
                                        }
                                }
                        }
-                       daemon_log("Inserting entries to DB",6);
-                       $fai_server_db->exec_statementlist(\@sql_list);
-                       daemon_log("Done with inserting",6);
+
+                       daemon_log("$session_id DEBUG: Inserting ".scalar @sql_list." entries to DB",8);
+                       if(@sql_list) {
+                               unshift @sql_list, "DELETE FROM $table_name";   # at first, clear db
+                               $fai_release_db->exec_statementlist(\@sql_list);
+                       }
+                       daemon_log("$session_id DEBUG: Done with inserting",7);
+               }
+               daemon_log("$session_id INFO: create_fai_release_db: finished",5);
+       }
+    $ldap_handle->disconnect;
+       return $result;
+}
+
+sub get_fai_types {
+       my $tmp_classes = shift || return undef;
+       my @result;
+
+       foreach my $type(keys %{$tmp_classes}) {
+               if(defined($tmp_classes->{$type}[0]) && (!($tmp_classes->{$type}[0] =~ /^.*?removed.*?$/))) {
+                       my $entry = {
+                               type => $type,
+                               state => $tmp_classes->{$type}[0],
+                       };
+                       push @result, $entry;
+               }
+       }
+
+       return @result;
+}
+
+sub get_fai_state {
+       my $result = "";
+       my $tmp_classes = shift || return $result;
+
+       foreach my $type(keys %{$tmp_classes}) {
+               if(defined($tmp_classes->{$type}[0])) {
+                       $result = $tmp_classes->{$type}[0];
+                       
+               # State is equal for all types in class
+                       last;
                }
-               daemon_log("Done with creating fai_release_db",4);
        }
 
        return $result;
 }
 
 sub resolve_fai_classes {
+       my ($fai_base, $ldap_handle, $session_id) = @_;
+       if (not defined $session_id) { $session_id = 0; }
        my $result;
-       my $fai_base= shift;
        my @possible_fai_classes= ("FAIscript", "FAIhook", "FAIpartitionTable", "FAItemplate", "FAIvariable", "FAIprofile", "FAIpackageList");
        my $fai_filter= "(|(&(objectClass=FAIclass)(|(objectClass=".join(")(objectClass=", @possible_fai_classes).")))(objectClass=FAIbranch))";
        my $fai_classes;
 
-       daemon_log("Searching for FAI entries in base $fai_base",6);
+       daemon_log("$session_id DEBUG: Searching for FAI entries in base $fai_base",7);
        my $mesg= $ldap_handle->search(
                base   => $fai_base,
                scope  => 'sub',
                attrs  => ['cn','objectClass','FAIstate'],
                filter => $fai_filter,
        );
-       daemon_log("Found ".$mesg->count()." FAI entries",6);
+       daemon_log("$session_id DEBUG: Found ".$mesg->count()." FAI entries",7);
 
        if($mesg->{'resultCode'} == 0 &&
                $mesg->count != 0) {
@@ -1551,6 +1888,53 @@ sub resolve_fai_classes {
        return $result;
 }
 
+sub apply_fai_inheritance {
+       my $fai_classes = shift || return {};
+       my $tmp_classes;
+
+       # Get the classes from the branch
+       foreach my $class (keys %{$fai_classes}) {
+               # Skip subreleases
+               if($class =~ /^ou=.*$/) {
+                       next;
+               } else {
+                       $tmp_classes->{$class}= deep_copy($fai_classes->{$class});
+               }
+       }
+
+       # Apply to each subrelease
+       foreach my $subrelease (keys %{$fai_classes}) {
+               if($subrelease =~ /ou=/) {
+                       foreach my $tmp_class (keys %{$tmp_classes}) {
+                               if(!exists($fai_classes->{$subrelease}->{$tmp_class})) {
+                                       $fai_classes->{$subrelease}->{$tmp_class} =
+                                       deep_copy($tmp_classes->{$tmp_class});
+                               } else {
+                                       foreach my $type (keys %{$tmp_classes->{$tmp_class}}) {
+                                               if(!exists($fai_classes->{$subrelease}->{$tmp_class}->{$type})) {
+                                                       $fai_classes->{$subrelease}->{$tmp_class}->{$type}=
+                                                       deep_copy($tmp_classes->{$tmp_class}->{$type});
+                                               }
+                                       }
+                               }
+                       }
+               }
+       }
+
+       # Find subreleases in deeper levels
+       foreach my $subrelease (keys %{$fai_classes}) {
+               if($subrelease =~ /ou=/) {
+                       foreach my $subsubrelease (keys %{$fai_classes->{$subrelease}}) {
+                               if($subsubrelease =~ /ou=/) {
+                                       apply_fai_inheritance($fai_classes->{$subrelease});
+                               }
+                       }
+               }
+       }
+
+       return $fai_classes;
+}
+
 sub get_fai_release_entries {
        my $tmp_classes = shift || return;
        my $parent = shift || "";
@@ -1586,166 +1970,236 @@ sub get_fai_release_entries {
        return @result;
 }
 
-sub get_fai_types {
-       my $tmp_classes = shift || return undef;
-       my @result;
+sub deep_copy {
+       my $this = shift;
+       if (not ref $this) {
+               $this;
+       } elsif (ref $this eq "ARRAY") {
+               [map deep_copy($_), @$this];
+       } elsif (ref $this eq "HASH") {
+               +{map { $_ => deep_copy($this->{$_}) } keys %$this};
+       } else { die "what type is $_?" }
+}
 
-       foreach my $type(keys %{$tmp_classes}) {
-               if(defined($tmp_classes->{$type}[0]) && (!($tmp_classes->{$type}[0] =~ /^.*?removed.*?$/))) {
-                       my $entry = {
-                               type => $type,
-                               state => $tmp_classes->{$type}[0],
-                       };
-                       push @result, $entry;
-               }
-       }
 
-       return @result;
+sub session_run_result {
+    my ($kernel, $heap, $client_answer) = @_[KERNEL, HEAP, ARG0];    
+    $kernel->sig(CHLD => "child_reap");
 }
 
-sub apply_fai_inheritance {
-       my $fai_classes = shift || return {};
-       my $tmp_classes;
+sub session_run_debug {
+    my $result = $_[ARG0];
+    print STDERR "$result\n";
+}
 
-       # Get the classes from the branch
-       foreach my $class (keys %{$fai_classes}) {
-               # Skip subreleases
-               if($class =~ /^ou=.*$/) {
-                       next;
-               } else {
-                       $tmp_classes->{$class}= deep_copy($fai_classes->{$class});
-               }
-       }
+sub session_run_done {
+    my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
+    delete $heap->{task}->{$task_id};
+}
 
-       # Apply to each subrelease
-       foreach my $subrelease (keys %{$fai_classes}) {
-               if($subrelease =~ /ou=/) {
-                       foreach my $tmp_class (keys %{$tmp_classes}) {
-                               if(!exists($fai_classes->{$subrelease}->{$tmp_class})) {
-                                       $fai_classes->{$subrelease}->{$tmp_class} = 
-                                       deep_copy($tmp_classes->{$tmp_class});
-                               } else {
-                                       foreach my $type (keys %{$tmp_classes->{$tmp_class}}) {
-                                               if(!exists($fai_classes->{$subrelease}->{$tmp_class}->{$type})) {
-                                                       $fai_classes->{$subrelease}->{$tmp_class}->{$type}=
-                                                       deep_copy($tmp_classes->{$tmp_class}->{$type});
-                                               }
-                                       }
-                               }
-                       }
-               }
+
+sub create_sources_list {
+       my $session_id = shift;
+       my $ldap_handle = &main::get_ldap_handle;
+       my $result="/tmp/gosa_si_tmp_sources_list";
+
+       # Remove old file
+       if(stat($result)) {
+               unlink($result);
+               &main::daemon_log("$session_id DEBUG: remove an old version of '$result'", 7); 
        }
 
-       # Find subreleases in deeper levels
-       foreach my $subrelease (keys %{$fai_classes}) {
-               if($subrelease =~ /ou=/) {
-                       foreach my $subsubrelease (keys %{$fai_classes->{$subrelease}}) {
-                               if($subsubrelease =~ /ou=/) {
-                                       apply_fai_inheritance($fai_classes->{$subrelease});
+       my $fh;
+       open($fh, ">$result");
+       if (not defined $fh) {
+               &main::daemon_log("$session_id DEBUG: cannot open '$result' for writing", 7); 
+               return undef;
+       }
+       if(defined($main::ldap_server_dn) and length($main::ldap_server_dn) > 0) {
+               my $mesg=$ldap_handle->search(
+                       base    => $main::ldap_server_dn,
+                       scope   => 'base',
+                       attrs   => 'FAIrepository',
+                       filter  => 'objectClass=FAIrepositoryServer'
+               );
+               if($mesg->count) {
+                       foreach my $entry(@{$mesg->{'entries'}}) {
+                               foreach my $value(@{$entry->get_value('FAIrepository', asref => 1)}) {
+                                       my ($server, $tag, $release, $sections)= split /\|/, $value;
+                                       my $line = "deb $server $release";
+                                       $sections =~ s/,/ /g;
+                                       $line.= " $sections";
+                                       print $fh $line."\n";
                                }
                        }
                }
+       } else {
+               &main::daemon_log("$session_id ERROR: something wrong with ldap_server_dn '$main::ldap_server_dn', abort create_sources_list", 1); 
        }
-       
-       return $fai_classes;
+       close($fh);
+
+       return $result;
 }
 
-sub deep_copy {
-       my $this = shift;
-       if (not ref $this) {
-               $this;
-       } elsif (ref $this eq "ARRAY") {
-               [map deep_copy($_), @$this];
-       } elsif (ref $this eq "HASH") {
-               +{map { $_ => deep_copy($this->{$_}) } keys %$this};
-       } else { die "what type is $_?" }
+
+sub run_create_packages_list_db {
+    my ($session, $heap) = @_[SESSION, HEAP];
+       my $session_id = $session->ID;
+
+       my $task = POE::Wheel::Run->new(
+                                       Program => sub {&create_packages_list_db(undef, undef, $session_id)},
+                                       StdoutEvent  => "session_run_result",
+                                       StderrEvent  => "session_run_debug",
+                                       CloseEvent   => "session_run_done",
+                                       );
+       $heap->{task}->{ $task->ID } = $task;
 }
 
+
 sub create_packages_list_db {
-    my ($sources_file) = $_[ARG0] ;
-    my $line;
+       my ($ldap_handle, $sources_file, $session_id) = @_;
+       
+       # it should not be possible to trigger a recreation of packages_list_db
+       # while packages_list_db is under construction, so set flag packages_list_under_construction
+       # which is tested befor recreation can be started
+       if (-r $packages_list_under_construction) {
+               daemon_log("$session_id WARNING: packages_list_db is right now under construction, please wait until this process is finished", 3);
+               return;
+       } else {
+               daemon_log("$session_id INFO: create_packages_list_db: start", 5); 
+               # set packages_list_under_construction to true
+               system("touch $packages_list_under_construction");
+               @packages_list_statements=undef;
+       }
 
-    open(CONFIG, "<$sources_file") or do {
-        daemon_log( "ERROR: Failed to open '$sources_file', creating packages.db stopped", 1);
-        return;
-    };
-    
-    # Read lines
-    while ($line = <CONFIG>){
-        # Unify
-        chop($line);
-        $line =~ s/^\s+//;
-        $line =~ s/^\s+/ /;
+       if (not defined $session_id) { $session_id = 0; }
+       if (not defined $ldap_handle) { 
+               $ldap_handle= &get_ldap_handle();
 
-        # Strip comments
-        $line =~ s/#.*$//g;
+               if (not defined $ldap_handle) {
+                       daemon_log("$session_id ERROR: no ldap_handle available to create_packages_list_db", 1);
+                       unlink($packages_list_under_construction);
+                       return;
+               }
+       }
+       if (not defined $sources_file) { 
+               &main::daemon_log("$session_id INFO: no sources_file given for creating packages list so trigger creation of it", 5); 
+               $sources_file = &create_sources_list($session_id);
+       }
 
-        # Skip empty lines
-        if ($line =~ /^\s*$/){
-            next;
-        }
+       if (not defined $sources_file) {
+               &main::daemon_log("$session_id ERROR: no sources_file given under '$sources_file', skip create_packages_list_db", 1); 
+               unlink($packages_list_under_construction);
+               return;
+       }
 
-        # Interpret deb line
-        if ($line =~ /^deb [^\s]+\s[^\s]+\s[^\s]+/){
-            my( $baseurl, $dist, $sections ) = ($line =~ /^deb\s([^\s]+)\s+([^\s]+)\s+(.*)$/);
-            my $section;
-            foreach $section (split(' ', $sections)){
-                &parse_package_info( $baseurl, $dist, $section );
-            }
-        }
-    }
+       my $line;
 
-    close (CONFIG);
+       open(CONFIG, "<$sources_file") or do {
+               daemon_log( "$session_id ERROR: create_packages_list_db: Failed to open '$sources_file'", 1);
+               unlink($packages_list_under_construction);
+               return;
+       };
 
+       # Read lines
+       while ($line = <CONFIG>){
+               # Unify
+               chop($line);
+               $line =~ s/^\s+//;
+               $line =~ s/^\s+/ /;
 
-    return;
+               # Strip comments
+               $line =~ s/#.*$//g;
+
+               # Skip empty lines
+               if ($line =~ /^\s*$/){
+                       next;
+               }
+
+               # Interpret deb line
+               if ($line =~ /^deb [^\s]+\s[^\s]+\s[^\s]+/){
+                       my( $baseurl, $dist, $sections ) = ($line =~ /^deb\s([^\s]+)\s+([^\s]+)\s+(.*)$/);
+                       my $section;
+                       foreach $section (split(' ', $sections)){
+                               &parse_package_info( $baseurl, $dist, $section, $session_id );
+                       }
+               }
+       }
+
+       close (CONFIG);
+
+       find(\&cleanup_and_extract, keys( %repo_dirs ));
+       $packages_list_db->exec_statementlist(\@packages_list_statements);
+       unlink($packages_list_under_construction);
+       daemon_log("$session_id INFO: create_packages_list_db: finished", 5); 
+       return;
 }
+
+
 sub parse_package_info {
-  my ($baseurl, $dist, $section)= @_;
-  my ($package);
-
-  my ($path) = ($baseurl =~ m%://[^/]*(.*)$%);
-
-  foreach $package ("Packages.gz"){
-    print "getting $baseurl , $dist , $section... \n";
-    get_package( "$baseurl/dists/$dist/$section/binary-$arch/$package", "$outdir/$dist/$section" );
-    print "done\n";
-    print "parsing packages... \n"; 
-    parse_package( "$outdir/$dist/$section", $dist, $path );
-    print "done\n";
-    last;
-  }
+    my ($baseurl, $dist, $section, $session_id)= @_;
+    my ($package);
+    if (not defined $session_id) { $session_id = 0; }
+    my ($path) = ($baseurl =~ m%://[^/]*(.*)$%);
+    $repo_dirs{ "${repo_path}/pool" } = 1;
+
+    foreach $package ("Packages.gz"){
+        daemon_log("$session_id DEBUG: create_packages_list: fetch $baseurl, $dist, $section", 7);
+        get_package( "$baseurl/dists/$dist/$section/binary-$arch/$package", "$outdir/$dist/$section", $session_id );
+        parse_package( "$outdir/$dist/$section", $dist, $path, $session_id );
+    }
+    
 }
-sub get_package {
-  my ($url, $dest)= @_;
-
-  my $tpath = dirname($dest);
-  -d "$tpath" || mkpath "$tpath";
 
-  # This is ugly, but I've no time to take a look at "how it works in perl"
-  if( system("wget '$url' -O '$dest' 2>/dev/null") ) {
-    system("gzip -cd '$dest' > '$dest.in'");
-    system("rm -f '$dest'");
-  }
 
-  return 0;
+sub get_package {
+    my ($url, $dest, $session_id)= @_;
+    if (not defined $session_id) { $session_id = 0; }
+
+    my $tpath = dirname($dest);
+    -d "$tpath" || mkpath "$tpath";
+
+    # This is ugly, but I've no time to take a look at "how it works in perl"
+    if(0 == system("wget '$url' -O '$dest' 2>/dev/null") ) {
+        system("gunzip -cd '$dest' > '$dest.in'");
+        daemon_log("$session_id DEBUG: run command: gunzip -cd '$dest' > '$dest.in'", 5);
+        unlink($dest);
+        daemon_log("$session_id DEBUG: delete file '$dest'", 5); 
+    } else {
+        daemon_log("$session_id ERROR: create_packages_list_db: get_packages: fetching '$url' failed!", 1);
+    }
+    return 0;
 }
+
+
 sub parse_package {
-    my ($path, $dist, $srv_path )= @_;
+    my ($path, $dist, $srv_path, $session_id)= @_;
+    if (not defined $session_id) { $session_id = 0;}
     my ($package, $version, $section, $description);
-    my @sql_list;
+    my $PACKAGES;
+    my $timestamp = &get_time();
 
-    open(PACKAGES, "<$path.in") or return;
+    if(not stat("$path.in")) {
+        daemon_log("$session_id ERROR: create_packages_list: parse_package: file '$path.in' is not readable",1);
+        return;
+    }
+
+    open($PACKAGES, "<$path.in");
+    if(not defined($PACKAGES)) {
+        daemon_log("$session_id ERROR: create_packages_list_db: parse_package: cannot open '$path.in'",1); 
+        return;
+    }
 
     # Read lines
-    while (my $line = <PACKAGES>){
+    while (<$PACKAGES>){
+        my $line = $_;
         # Unify
         chop($line);
 
         # Use empty lines as a trigger
         if ($line =~ /^\s*$/){
-            my $sql = "INSERT INTO packages_list VALUES ('$dist', '$package', '$version', '$section', 'xxx', 'none', '0')";
-            push(@sql_list, $sql);
+            my $sql = "INSERT INTO packages_list VALUES ('$dist', '$package', '$version', '$section', '', 'none', '$timestamp')";
+            push(@packages_list_statements, $sql);
             $package = "none";
             $version = "none";
             $section = "none";
@@ -1777,41 +2231,72 @@ sub parse_package {
             next;
         }
 
+        # Trigger for filename
+        if ($line =~ /^Filename:\s/){
+            my ($filename) = ($line =~ /^Filename: (.*)$/);
+            store_fileinfo( $package, $filename, $dist, $srv_path, $version, $repo_path );
+            next;
+        }
     }
 
-    close( PACKAGES );
+    close( $PACKAGES );
     unlink( "$path.in" );
-    
-    $packages_list_db->exec_statementlist(\@sql_list);
+    &main::daemon_log("$session_id DEBUG: unlink '$path.in'", 1); 
 }
 
-#
-#sub store_fileinfo {
-#  my( $package, $file, $dist, $path, $vers ) = @_;
-#
-#  my %fileinfo = (
-#    'package' => $package,
-#    'dist' => $dist,
-#    'version' => $vers
-#  );
-#
-#  $repo_files{ "${srvdir}${path}/$file" } = \%fileinfo;
-#}
 
-sub next_task {
-    my ($heap) = $_[HEAP];
+sub store_fileinfo {
+    my( $package, $file, $dist, $path, $vers, $srvdir) = @_;
 
-    if( keys(%{$heap->{task}}) < $max_clients ) {
-        
-    }
-    
-    #$heap->{task}->{$task->ID} = $task;
+    my %fileinfo = (
+        'package' => $package,
+        'dist' => $dist,
+        'version' => $vers,
+    );
+
+    $repo_files{ "${srvdir}/$file" } = \%fileinfo;
 }
 
-sub task_result {
 
+sub cleanup_and_extract {
+    my $fileinfo = $repo_files{ $File::Find::name };
+
+    if( defined $fileinfo ) {
+
+        my $dir = "$outdir/$fileinfo->{ 'dist' }/debconf.d";
+        my $sql;
+        my $package = $fileinfo->{ 'package' };
+        my $newver = $fileinfo->{ 'version' };
+
+        mkpath($dir);
+        system( "dpkg -e '$File::Find::name' '$dir/DEBIAN'" );
+
+        if( -f "$dir/DEBIAN/templates" ) {
+
+            daemon_log("DEBUG: Found debconf templates in '$package' - $newver", 5);
+
+            my $tmpl= "";
+            {
+                local $/=undef;
+                open FILE, "$dir/DEBIAN/templates";
+                $tmpl = &encode_base64(<FILE>);
+                close FILE;
+            }
+            rmtree("$dir/DEBIAN/templates");
+
+            $sql= "update $main::packages_list_tn set template = '$tmpl' where package = '$package' and version = '$newver';";
+
+        } else {
+            $sql= "update $main::packages_list_tn set template = '' where package = '$package' and version = '$newver';";
+        }
+
+        push @packages_list_statements, $sql;
+    }
+
+    return;
 }
 
+
 #==== MAIN = main ==============================================================
 #  parse commandline options
 Getopt::Long::Configure( "bundling" );
@@ -1864,11 +2349,6 @@ if ($no_bus > 0) {
     $bus_activ = "false"
 }
 
-
-
-# delete old DBsqlite lock files
-#unlink('/tmp/gosa_si_lock*');
-
 # connect to gosa-si job queue
 $job_db = GOSA::DBsqlite->new($job_queue_file_name);
 $job_db->create_table($job_queue_tn, \@job_queue_col_names);
@@ -1886,12 +2366,17 @@ $login_users_db = GOSA::DBsqlite->new($login_users_file_name);
 $login_users_db->create_table($login_users_tn, \@login_users_col_names);
 
 # connect to fai_server_db and fai_release_db
+unlink($fai_server_file_name);
 $fai_server_db = GOSA::DBsqlite->new($fai_server_file_name);
 $fai_server_db->create_table($fai_server_tn, \@fai_server_col_names);
-$fai_server_db->create_table($fai_release_tn, \@fai_release_col_names);
+
+unlink($fai_release_file_name);
+$fai_release_db = GOSA::DBsqlite->new($fai_release_file_name);
+$fai_release_db->create_table($fai_release_tn, \@fai_release_col_names);
 
 # connect to packages_list_db
 unlink($packages_list_file_name);
+unlink($packages_list_under_construction);
 $packages_list_db = GOSA::DBsqlite->new($packages_list_file_name);
 $packages_list_db->create_table($packages_list_tn, \@packages_list_col_names);
 
@@ -1904,23 +2389,41 @@ $messaging_db->create_table($messaging_tn, \@messaging_col_names);
 $xml = new XML::Simple();
 
 # create socket for incoming xml messages
+
 POE::Component::Server::TCP->new(
        Port => $server_port,
-       ClientInput => \&client_input,
+       ClientInput => sub {
+        my ($kernel, $input) = @_[KERNEL, ARG0];
+        push(@tasks, $input);
+        $kernel->yield("next_task");
+        },
+    InlineStates => {
+        next_task => \&next_task,
+        task_result => \&handle_task_result,
+        task_done   => \&handle_task_done,
+        task_debug  => \&handle_task_debug,
+        child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!"  },
+    }
 );
+
 daemon_log("start socket for incoming xml messages at port '$server_port' ", 1);
 
 # create session for repeatedly checking the job queue for jobs
 POE::Session->create(
        inline_states => {
                _start => \&_start,
-        next_task => \&next_task,
-        task_result => \&task_result,
+               sig_handler => \&sig_handler,
+        watch_for_new_messages => \&watch_for_new_messages,
+        watch_for_done_messages => \&watch_for_done_messages,
                watch_for_new_jobs => \&watch_for_new_jobs,
         watch_for_done_jobs => \&watch_for_done_jobs,
-        create_packages_list_db => \&create_packages_list_db,
-        create_fai_server_db => \&create_fai_server_db,
-        create_fai_release_db => \&create_fai_release_db,
+        create_packages_list_db => \&run_create_packages_list_db,
+        create_fai_server_db => \&run_create_fai_server_db,
+        create_fai_release_db => \&run_create_fai_release_db,
+        session_run_result => \&session_run_result,
+        session_run_debug => \&session_run_debug,
+        session_run_done => \&session_run_done,
+        child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!"  },
        }
 );