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