192e8d65f323cf0af3744221f952ea1ad6e731a2
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:\d*$/) {
699 next;
700 }
701 my $host_key = $hit->{hostkey};
702 &daemon_log("$session_id DEBUG: input_from_known_client: host_name: $host_name", 7);
703 &daemon_log("$session_id DEBUG: input_from_known_client: host_key: $host_key", 7);
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 # Patch the source ip
887 if($msg =~ /<source>0\.0\.0\.0:\d*?<\/source>/) {
888 my $remote_ip = &get_local_ip_for_remote_ip(sprintf("%s", $address =~ /^([0-9\.]*?):.*$/));
889 $msg =~ s/<source>(0\.0\.0\.0):(\d*?)<\/source>/<source>$remote_ip:$2<\/source>/s;
890 }
892 # Memorize own source address
893 $msg =~ /<source>(\S+)<\/source>/;
894 my $own_source_address = $1;
896 # encrypt xml msg
897 my $crypted_msg = &encrypt_msg($msg, $encrypt_key);
899 # opensocket
900 my $socket = &open_socket($address);
901 if( !$socket ) {
902 daemon_log("$session_id WARNING: cannot send ".$header."msg to '$address' , host not reachable! Message: '$msg'", 3);
903 $error++;
904 }
906 if( $error == 0 ) {
907 # send xml msg
908 print $socket $crypted_msg.";$own_source_address\n";
910 daemon_log("$session_id INFO: send ".$header."msg to $address", 5);
911 daemon_log("$session_id DEBUG: message:\n$msg", 9);
913 }
915 # close socket in any case
916 if( $socket ) {
917 close $socket;
918 }
920 if( $error > 0 ) { $new_status = "down"; }
921 else { $new_status = $msg_header; }
924 # known_clients
925 $sql_statement = "SELECT * FROM $known_clients_tn WHERE hostname='$address'";
926 $res = $known_clients_db->select_dbentry($sql_statement);
927 if( keys(%$res) == 1) {
928 $act_status = exists $res->{1}->{'status'} ? $res->{1}->{'status'} : "";
929 if ($act_status eq "down" && $new_status eq "down") {
930 $sql_statement = "DELETE FROM known_clients WHERE hostname='$address'";
931 $res = $known_clients_db->del_dbentry($sql_statement);
932 daemon_log("$session_id WARNING: failed 2x to send msg to host '$address', delete host from known_clients", 3);
933 } else {
934 $sql_statement = "UPDATE known_clients SET status='$new_status', timestamp='$timestamp' WHERE hostname='$address'";
935 $res = $known_clients_db->update_dbentry($sql_statement);
936 if($new_status eq "down"){
937 daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
938 } else {
939 daemon_log("$session_id INFO: set '$address' from status '$act_status' to '$new_status'", 5);
940 }
941 }
942 }
944 # known_server
945 $sql_statement = "SELECT * FROM $known_server_tn WHERE hostname='$address'";
946 $res = $known_server_db->select_dbentry($sql_statement);
947 if( keys(%$res) == 1) {
948 $act_status = exists $res->{1}->{'status'} ? $res->{1}->{'status'} : "";
949 if ($act_status eq "down" && $new_status eq "down") {
950 $sql_statement = "DELETE FROM known_server WHERE hostname='$address'";
951 $res = $known_server_db->del_dbentry($sql_statement);
952 daemon_log("$session_id WARNING: failed 2x to send a message to host '$address', delete host from known_server", 3);
953 }
954 else {
955 $sql_statement = "UPDATE known_server SET status='$new_status', timestamp='$timestamp' WHERE hostname='$address'";
956 $res = $known_server_db->update_dbentry($sql_statement);
957 if($new_status eq "down"){
958 daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
959 } else {
960 daemon_log("$session_id INFO: set '$address' from status '$act_status' to '$new_status'", 5);
961 }
962 }
963 }
964 return $error;
965 }
968 sub update_jobdb_status_for_send_msgs {
969 my ($session_id, $answer, $error) = @_;
970 &daemon_log("$session_id DEBUG: try to update job status", 7);
971 if( $answer =~ /<jobdb_id>(\d+)<\/jobdb_id>/ ) {
972 my $jobdb_id = $1;
974 $answer =~ /<header>(.*)<\/header>/;
975 my $job_header = $1;
977 $answer =~ /<target>(.*)<\/target>/;
978 my $job_target = $1;
980 # Sending msg failed
981 if( $error ) {
983 # Set jobs to done, jobs do not need to deliver their message in any case
984 if (($job_header eq "trigger_action_localboot")
985 ||($job_header eq "trigger_action_lock")
986 ||($job_header eq "trigger_action_halt")
987 ) {
988 my $sql_statement = "UPDATE $job_queue_tn SET status='done' WHERE id=$jobdb_id";
989 &daemon_log("$session_id DEBUG: $sql_statement", 7);
990 my $res = $job_db->update_dbentry($sql_statement);
992 # Reactivate jobs, jobs need to deliver their message
993 } elsif (($job_header eq "trigger_action_activate")
994 ||($job_header eq "trigger_action_update")
995 ||($job_header eq "trigger_action_reinstall")
996 ||($job_header eq "trigger_activate_new")
997 ) {
998 &reactivate_job_with_delay($session_id, $job_target, $job_header, 30 );
1000 # For all other messages
1001 } else {
1002 my $sql_statement = "UPDATE $job_queue_tn ".
1003 "SET status='error', result='can not deliver msg, please consult log file' ".
1004 "WHERE id=$jobdb_id";
1005 &daemon_log("$session_id DEBUG: $sql_statement", 7);
1006 my $res = $job_db->update_dbentry($sql_statement);
1007 }
1009 # Sending msg was successful
1010 } else {
1011 # Set jobs localboot, lock, activate, halt, reboot and wake to done
1012 # jobs reinstall, update, inst_update do themself setting to done
1013 if (($job_header eq "trigger_action_localboot")
1014 ||($job_header eq "trigger_action_lock")
1015 ||($job_header eq "trigger_action_activate")
1016 ||($job_header eq "trigger_action_halt")
1017 ||($job_header eq "trigger_action_reboot")
1018 ||($job_header eq "trigger_action_wake")
1019 ||($job_header eq "trigger_wake")
1020 ) {
1022 my $sql_statement = "UPDATE $job_queue_tn ".
1023 "SET status='done' ".
1024 "WHERE id=$jobdb_id AND status='processed'";
1025 &daemon_log("$session_id DEBUG: $sql_statement", 7);
1026 my $res = $job_db->update_dbentry($sql_statement);
1027 } else {
1028 &daemon_log("$session_id DEBUG: sending message succeed but cannot update job status.", 7);
1029 }
1030 }
1031 } else {
1032 &daemon_log("$session_id DEBUG: cannot update job status, msg has no jobdb_id-tag: $answer", 7);
1033 }
1034 }
1036 sub reactivate_job_with_delay {
1037 my ($session_id, $target, $header, $delay) = @_ ;
1038 # Sometimes the client is still booting or does not wake up, in this case reactivate the job (if it exists) with a delay of n sec
1040 if (not defined $delay) { $delay = 30 } ;
1041 my $delay_timestamp = &calc_timestamp(&get_time(), "plus", $delay);
1043 my $sql = "UPDATE $job_queue_tn Set timestamp='$delay_timestamp', status='waiting' WHERE (macaddress LIKE 'target' AND headertag='$header')";
1044 my $res = $job_db->update_dbentry($sql);
1045 daemon_log("$session_id INFO: '$header'-job will be reactivated at '$delay_timestamp' ".
1046 "cause client '$target' is currently not available", 5);
1047 daemon_log("$session_id $sql", 7);
1048 return;
1049 }
1052 sub sig_handler {
1053 my ($kernel, $signal) = @_[KERNEL, ARG0] ;
1054 daemon_log("0 INFO got signal '$signal'", 1);
1055 $kernel->sig_handled();
1056 return;
1057 }
1060 sub msg_to_decrypt {
1061 my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];
1062 my $session_id = $session->ID;
1063 my ($msg, $msg_hash, $module);
1064 my $error = 0;
1066 # fetch new msg out of @msgs_to_decrypt
1067 my $tmp_next_msg = shift @msgs_to_decrypt;
1068 my ($next_msg, $msg_source) = split(/;/, $tmp_next_msg);
1070 # msg is from a new client or gosa
1071 ($msg, $msg_hash, $module) = &input_from_unknown_host($next_msg, $session_id);
1073 # msg is from a gosa-si-server
1074 if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1075 #($msg, $msg_hash, $module) = &input_from_known_server($next_msg, $heap->{'remote_ip'}, $session_id);
1076 ($msg, $msg_hash, $module) = &input_from_known_server($next_msg, $msg_source, $session_id);
1077 }
1078 # msg is from a gosa-si-client
1079 if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1080 ($msg, $msg_hash, $module) = &input_from_known_client($next_msg, $msg_source, $session_id);
1081 }
1082 # an error occurred
1083 if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1084 # If an incoming msg could not be decrypted (maybe a wrong key), decide if msg comes from a client
1085 # or a server. In case of a client, send a ping. If the client could not understand a msg from its
1086 # server the client cause a re-registering process. In case of a server, decrease update_time in kown_server_db
1087 # and trigger a re-registering process for servers
1088 if (defined $msg_source && $msg_source =~ /:$server_port$/)
1089 {
1090 daemon_log("$session_id WARNING: Cannot understand incoming msg from server '$msg_source'. Cause re-registration process for servers.", 3);
1091 my $update_statement = "UPDATE $known_server_tn SET update_time='19700101000000' WHERE hostname='$msg_source'";
1092 daemon_log("$session_id DEBUG: $update_statement", 7);
1093 my $upadte_res = $known_server_db->exec_statement($update_statement);
1094 $kernel->yield("register_at_foreign_servers");
1095 }
1096 elsif (defined $msg_source)
1097 {
1098 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);
1099 #my $remote_ip = $heap->{'remote_ip'};
1100 #my $remote_port = $heap->{'remote_port'};
1101 my $ping_msg = "<xml> <header>gosa_ping</header> <source>$server_address</source><target>$msg_source</target></xml>";
1102 my ($test_error, $test_error_string) = &send_msg_to_target($ping_msg, "$msg_source", "dummy-key", "gosa_ping", $session_id);
1103 daemon_log("$session_id WARNING: sending msg to cause re-registering: $ping_msg", 3);
1104 }
1105 else
1106 {
1107 daemon_log("$session_id ERROR: incoming message contains no msg source. Processing aborted: $tmp_next_msg", 1);
1108 }
1110 $error++;
1111 }
1114 my $header;
1115 my $target;
1116 my $source;
1117 my $done = 0;
1118 my $sql;
1119 my $res;
1121 # check whether this message should be processed here
1122 if ($error == 0) {
1123 $header = @{$msg_hash->{'header'}}[0];
1124 $target = @{$msg_hash->{'target'}}[0];
1125 $source = @{$msg_hash->{'source'}}[0];
1126 my $not_found_in_known_clients_db = 0;
1127 my $not_found_in_known_server_db = 0;
1128 my $not_found_in_foreign_clients_db = 0;
1129 my $local_address;
1130 my $local_mac;
1131 my ($target_ip, $target_port) = split(':', $target);
1133 # Determine the local ip address if target is an ip address
1134 if ($target =~ /^\d+\.\d+\.\d+\.\d+:\d+$/) {
1135 $local_address = &get_local_ip_for_remote_ip($target_ip).":$server_port";
1136 } else {
1137 $local_address = $server_address;
1138 }
1140 # Determine the local mac address if target is a mac address
1141 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) {
1142 my $loc_ip = &get_local_ip_for_remote_ip($heap->{'remote_ip'});
1143 my $network_interface= &get_interface_for_ip($loc_ip);
1144 $local_mac = &get_mac_for_interface($network_interface);
1145 } else {
1146 $local_mac = $server_mac_address;
1147 }
1149 # target and source is equal to GOSA -> process here
1150 if (not $done) {
1151 if ($target eq "GOSA" && $source eq "GOSA") {
1152 $done = 1;
1153 &daemon_log("$session_id DEBUG: target and source is 'GOSA' -> process here", 7);
1154 }
1155 }
1157 # target is own address without forward_to_gosa-tag -> process here
1158 if (not $done) {
1159 #if ((($target eq $local_address) || ($target eq $local_mac) ) && (not exists $msg_hash->{'forward_to_gosa'})) {
1160 if (($target eq $local_address) && (not exists $msg_hash->{'forward_to_gosa'})) {
1161 $done = 1;
1162 if ($source eq "GOSA") {
1163 $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1164 }
1165 &daemon_log("$session_id DEBUG: target is own address without forward_to_gosa-tag -> process here", 7);
1166 }
1167 }
1169 # target is a client address in known_clients -> process here
1170 if (not $done) {
1171 $sql = "SELECT * FROM $known_clients_tn WHERE (hostname='$target' OR macaddress LIKE '$target')";
1172 $res = $known_clients_db->select_dbentry($sql);
1173 if (keys(%$res) > 0) {
1174 $done = 1;
1175 my $hostname = $res->{1}->{'hostname'};
1176 $msg =~ s/<target>$target<\/target>/<target>$hostname<\/target>/;
1177 my $local_address = &get_local_ip_for_remote_ip($target_ip).":$server_port";
1178 if ($source eq "GOSA") {
1179 $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1180 }
1181 &daemon_log("$session_id DEBUG: target is a client address in known_clients -> process here", 7);
1183 } else {
1184 $not_found_in_known_clients_db = 1;
1185 }
1186 }
1188 # target ist own address with forward_to_gosa-tag not pointing to myself -> process here
1189 if (not $done) {
1190 my $forward_to_gosa = @{$msg_hash->{'forward_to_gosa'}}[0];
1191 my $gosa_at;
1192 my $gosa_session_id;
1193 if (($target eq $local_address) && (defined $forward_to_gosa)){
1194 my ($gosa_at, $gosa_session_id) = split(/,/, $forward_to_gosa);
1195 if ($gosa_at ne $local_address) {
1196 $done = 1;
1197 &daemon_log("$session_id DEBUG: target is own address with forward_to_gosa-tag not pointing to myself -> process here", 7);
1198 }
1199 }
1200 }
1202 # if message should be processed here -> add message to incoming_db
1203 if ($done) {
1204 # if a job or a gosa message comes from a foreign server, fake module to GosaPackages
1205 # so gosa-si-server knows how to process this kind of messages
1206 if ($header =~ /^gosa_/ || $header =~ /^job_/) {
1207 $module = "GosaPackages";
1208 }
1210 my $res = $incoming_db->add_dbentry( {table=>$incoming_tn,
1211 primkey=>[],
1212 headertag=>$header,
1213 targettag=>$target,
1214 xmlmessage=>&encode_base64($msg),
1215 timestamp=>&get_time,
1216 module=>$module,
1217 sessionid=>$session_id,
1218 } );
1220 }
1222 # target is own address with forward_to_gosa-tag pointing at myself -> forward to gosa
1223 if (not $done) {
1224 my $forward_to_gosa = @{$msg_hash->{'forward_to_gosa'}}[0];
1225 my $gosa_at;
1226 my $gosa_session_id;
1227 if (($target eq $local_address) && (defined $forward_to_gosa)){
1228 my ($gosa_at, $gosa_session_id) = split(/,/, $forward_to_gosa);
1229 if ($gosa_at eq $local_address) {
1230 my $session_reference = $kernel->ID_id_to_session($gosa_session_id);
1231 if( defined $session_reference ) {
1232 $heap = $session_reference->get_heap();
1233 }
1234 if(exists $heap->{'client'}) {
1235 $msg = &encrypt_msg($msg, $GosaPackages_key);
1236 $heap->{'client'}->put($msg);
1237 &daemon_log("$session_id INFO: incoming '$header' message forwarded to GOsa", 5);
1238 }
1239 $done = 1;
1240 &daemon_log("$session_id DEBUG: target is own address with forward_to_gosa-tag pointing at myself -> forward to gosa", 7);
1241 }
1242 }
1244 }
1246 # target is a client address in foreign_clients -> forward to registration server
1247 if (not $done) {
1248 $sql = "SELECT * FROM $foreign_clients_tn WHERE (hostname='$target' OR macaddress LIKE '$target')";
1249 $res = $foreign_clients_db->select_dbentry($sql);
1250 if (keys(%$res) > 0) {
1251 my $hostname = $res->{1}->{'hostname'};
1252 my ($host_ip, $host_port) = split(/:/, $hostname);
1253 my $local_address = &get_local_ip_for_remote_ip($host_ip).":$server_port";
1254 my $regserver = $res->{1}->{'regserver'};
1255 my $sql = "SELECT * FROM $known_server_tn WHERE hostname='$regserver'";
1256 my $res = $known_server_db->select_dbentry($sql);
1257 if (keys(%$res) > 0) {
1258 my $regserver_key = $res->{1}->{'hostkey'};
1259 $msg =~ s/<source>GOSA<\/source>/<source>$local_address<\/source>/;
1260 $msg =~ s/<target>$target<\/target>/<target>$hostname<\/target>/;
1261 if ($source eq "GOSA") {
1262 $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1263 }
1264 my $error= &send_msg_to_target($msg, $regserver, $regserver_key, $header, $session_id);
1265 if ($error) {
1266 &daemon_log("$session_id ERROR: some problems (error=$error) occurred while trying to send msg to registration server: $msg", 1);
1267 }
1268 }
1269 $done = 1;
1270 &daemon_log("$session_id DEBUG: target is a client address in foreign_clients -> forward to registration server", 7);
1271 } else {
1272 $not_found_in_foreign_clients_db = 1;
1273 }
1274 }
1276 # target is a server address -> forward to server
1277 if (not $done) {
1278 $sql = "SELECT * FROM $known_server_tn WHERE (hostname='$target' OR macaddress LIKE '$target')";
1279 $res = $known_server_db->select_dbentry($sql);
1280 if (keys(%$res) > 0) {
1281 my $hostkey = $res->{1}->{'hostkey'};
1283 if ($source eq "GOSA") {
1284 $msg =~ s/<source>GOSA<\/source>/<source>$local_address<\/source>/;
1285 $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1287 }
1289 &send_msg_to_target($msg, $target, $hostkey, $header, $session_id);
1290 $done = 1;
1291 &daemon_log("$session_id DEBUG: target is a server address -> forward to server", 7);
1292 } else {
1293 $not_found_in_known_server_db = 1;
1294 }
1295 }
1298 # target is not in foreign_clients_db, known_server_db or known_clients_db, maybe it is a complete new one -> process here
1299 if ( $not_found_in_foreign_clients_db
1300 && $not_found_in_known_server_db
1301 && $not_found_in_known_clients_db) {
1302 &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);
1303 if ($header =~ /^gosa_/ || $header =~ /^job_/) {
1304 $module = "GosaPackages";
1305 }
1306 my $res = $incoming_db->add_dbentry( {table=>$incoming_tn,
1307 primkey=>[],
1308 headertag=>$header,
1309 targettag=>$target,
1310 xmlmessage=>&encode_base64($msg),
1311 timestamp=>&get_time,
1312 module=>$module,
1313 sessionid=>$session_id,
1314 } );
1315 $done = 1;
1316 }
1319 if (not $done) {
1320 daemon_log("$session_id ERROR: do not know what to do with this message: $msg", 1);
1321 if ($source eq "GOSA") {
1322 my %data = ('error_msg' => &encode_base64($msg), 'error_string' => "Do not know what to do with this message!");
1323 my $error_msg = &build_msg("error", $local_address, "GOSA", \%data );
1325 my $session_reference = $kernel->ID_id_to_session($session_id);
1326 if( defined $session_reference ) {
1327 $heap = $session_reference->get_heap();
1328 }
1329 if(exists $heap->{'client'}) {
1330 $error_msg = &encrypt_msg($error_msg, $GosaPackages_key);
1331 $heap->{'client'}->put($error_msg);
1332 }
1333 }
1334 }
1336 }
1338 return;
1339 }
1342 sub next_task {
1343 my ($session, $heap, $task) = @_[SESSION, HEAP, ARG0, ARG1];
1344 my $running_task = POE::Wheel::Run->new(
1345 Program => sub { process_task($session, $heap, $task) },
1346 StdioFilter => POE::Filter::Reference->new(),
1347 StdoutEvent => "task_result",
1348 StderrEvent => "task_debug",
1349 CloseEvent => "task_done",
1350 );
1351 $heap->{task}->{ $running_task->ID } = $running_task;
1352 }
1354 sub handle_task_result {
1355 my ($kernel, $heap, $result) = @_[KERNEL, HEAP, ARG0];
1356 my $client_answer = $result->{'answer'};
1357 if( $client_answer =~ s/session_id=(\d+)$// ) {
1358 my $session_id = $1;
1359 if( defined $session_id ) {
1360 my $session_reference = $kernel->ID_id_to_session($session_id);
1361 if( defined $session_reference ) {
1362 $heap = $session_reference->get_heap();
1363 }
1364 }
1366 if(exists $heap->{'client'}) {
1367 $heap->{'client'}->put($client_answer);
1368 }
1369 }
1370 $kernel->sig(CHLD => "child_reap");
1371 }
1373 sub handle_task_debug {
1374 my $result = $_[ARG0];
1375 print STDERR "$result\n";
1376 }
1378 sub handle_task_done {
1379 my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
1380 delete $heap->{task}->{$task_id};
1381 if (exists $heap->{ldap_handle}->{$task_id}) {
1382 &release_ldap_handle($heap->{ldap_handle}->{$task_id});
1383 }
1384 }
1386 sub process_task {
1387 no strict "refs";
1388 #CHECK: Not @_[...]?
1389 my ($session, $heap, $task) = @_;
1390 my $error = 0;
1391 my $answer_l;
1392 my ($answer_header, @answer_target_l, $answer_source);
1393 my $client_answer = "";
1395 # prepare all variables needed to process message
1396 #my $msg = $task->{'xmlmessage'};
1397 my $msg = &decode_base64($task->{'xmlmessage'});
1398 my $incoming_id = $task->{'id'};
1399 my $module = $task->{'module'};
1400 my $header = $task->{'headertag'};
1401 my $session_id = $task->{'sessionid'};
1402 my $msg_hash;
1403 eval {
1404 $msg_hash = $xml->XMLin($msg, ForceArray=>1);
1405 };
1406 daemon_log("ERROR: XML failure '$@'") if ($@);
1407 my $source = @{$msg_hash->{'source'}}[0];
1409 # set timestamp of incoming client uptodate, so client will not
1410 # be deleted from known_clients because of expiration
1411 my $cur_time = &get_time();
1412 my $sql = "UPDATE $known_clients_tn SET timestamp='$cur_time' WHERE hostname='$source'";
1413 my $res = $known_clients_db->exec_statement($sql);
1415 ######################
1416 # process incoming msg
1417 if( $error == 0) {
1418 daemon_log("$session_id INFO: Incoming msg (session_id=$session_id) with header '".@{$msg_hash->{'header'}}[0]."'", 5);
1419 daemon_log("$session_id DEBUG: Processing module ".$module, 7);
1420 $answer_l = &{ $module."::process_incoming_msg" }($msg, $msg_hash, $session_id);
1422 if ( 0 < @{$answer_l} ) {
1423 my $answer_str = join("\n", @{$answer_l});
1424 while ($answer_str =~ /<header>(\w+)<\/header>/g) {
1425 daemon_log("$session_id INFO: got answer message with header '$1'", 5);
1426 }
1427 daemon_log("$session_id DEBUG: $module: got answer from module: \n".$answer_str,9);
1428 } else {
1429 daemon_log("$session_id DEBUG: $module: got no answer from module!" ,7);
1430 }
1432 }
1433 if( !$answer_l ) { $error++ };
1435 ########
1436 # answer
1437 if( $error == 0 ) {
1439 foreach my $answer ( @{$answer_l} ) {
1440 # check outgoing msg to xml validity
1441 my $answer_hash = &check_outgoing_xml_validity($answer, $session_id);
1442 if( not defined $answer_hash ) { next; }
1444 $answer_header = @{$answer_hash->{'header'}}[0];
1445 @answer_target_l = @{$answer_hash->{'target'}};
1446 $answer_source = @{$answer_hash->{'source'}}[0];
1448 # deliver msg to all targets
1449 foreach my $answer_target ( @answer_target_l ) {
1451 # targets of msg are all gosa-si-clients in known_clients_db
1452 if( $answer_target eq "*" ) {
1453 # answer is for all clients
1454 my $sql_statement= "SELECT * FROM known_clients";
1455 my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1456 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1457 my $host_name = $hit->{hostname};
1458 my $host_key = $hit->{hostkey};
1459 my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1460 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1461 }
1462 }
1464 # targets of msg are all gosa-si-server in known_server_db
1465 elsif( $answer_target eq "KNOWN_SERVER" ) {
1466 # answer is for all server in known_server
1467 my $sql_statement= "SELECT * FROM $known_server_tn";
1468 my $query_res = $known_server_db->select_dbentry( $sql_statement );
1469 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1470 my $host_name = $hit->{hostname};
1471 my $host_key = $hit->{hostkey};
1472 $answer =~ s/<target>\S+<\/target>/<target>$host_name<\/target>/g;
1473 my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1474 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1475 }
1476 }
1478 # target of msg is GOsa
1479 elsif( $answer_target eq "GOSA" ) {
1480 my $session_id = ($1) if $answer =~ /<session_id>(\d+?)<\/session_id>/;
1481 my $add_on = "";
1482 if( defined $session_id ) {
1483 $add_on = ".session_id=$session_id";
1484 }
1485 # answer is for GOSA and has to returned to connected client
1486 my $gosa_answer = &encrypt_msg($answer, $GosaPackages_key);
1487 $client_answer = $gosa_answer.$add_on;
1488 }
1490 # target of msg is job queue at this host
1491 elsif( $answer_target eq "JOBDB") {
1492 $answer =~ /<header>(\S+)<\/header>/;
1493 my $header;
1494 if( defined $1 ) { $header = $1; }
1495 my $error = &send_msg_to_target($answer, $server_address, $GosaPackages_key, $header, $session_id);
1496 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1497 }
1499 # Target of msg is a mac address
1500 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 ) {
1501 daemon_log("$session_id INFO: target is mac address '$answer_target', looking for host in known_clients and foreign_clients", 5);
1503 # Looking for macaddress in known_clients
1504 my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$answer_target'";
1505 my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1506 my $found_ip_flag = 0;
1507 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1508 my $host_name = $hit->{hostname};
1509 my $host_key = $hit->{hostkey};
1510 $answer =~ s/$answer_target/$host_name/g;
1511 daemon_log("$session_id INFO: found host '$host_name', associated to '$answer_target'", 5);
1512 my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1513 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1514 $found_ip_flag++ ;
1515 }
1517 # Looking for macaddress in foreign_clients
1518 if ($found_ip_flag == 0) {
1519 my $sql = "SELECT * FROM $foreign_clients_tn WHERE macaddress LIKE '$answer_target'";
1520 my $res = $foreign_clients_db->select_dbentry($sql);
1521 while( my ($hit_num, $hit) = each %{ $res } ) {
1522 my $host_name = $hit->{hostname};
1523 my $reg_server = $hit->{regserver};
1524 daemon_log("$session_id INFO: found host '$host_name' with mac '$answer_target', registered at '$reg_server'", 5);
1526 # Fetch key for reg_server
1527 my $reg_server_key;
1528 my $sql = "SELECT * FROM $known_server_tn WHERE hostname='$reg_server'";
1529 my $res = $known_server_db->select_dbentry($sql);
1530 if (exists $res->{1}) {
1531 $reg_server_key = $res->{1}->{'hostkey'};
1532 } else {
1533 daemon_log("$session_id ERROR: cannot find hostkey for '$host_name' in '$known_server_tn'", 1);
1534 daemon_log("$session_id ERROR: unable to forward answer to correct registration server, processing is aborted!", 1);
1535 $reg_server_key = undef;
1536 }
1538 # Send answer to server where client is registered
1539 if (defined $reg_server_key) {
1540 $answer =~ s/$answer_target/$host_name/g;
1541 my $error = &send_msg_to_target($answer, $reg_server, $reg_server_key, $answer_header, $session_id);
1542 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1543 $found_ip_flag++ ;
1544 }
1545 }
1546 }
1548 # No mac to ip matching found
1549 if( $found_ip_flag == 0) {
1550 daemon_log("$session_id WARNING: no host found in known_clients or foreign_clients with mac address '$answer_target'", 3);
1551 &reactivate_job_with_delay($session_id, $answer_target, $answer_header, 30);
1552 }
1554 # Answer is for one specific host
1555 } else {
1556 # get encrypt_key
1557 my $encrypt_key = &get_encrypt_key($answer_target);
1558 if( not defined $encrypt_key ) {
1559 # unknown target
1560 daemon_log("$session_id WARNING: unknown target '$answer_target'", 3);
1561 next;
1562 }
1563 my $error = &send_msg_to_target($answer, $answer_target, $encrypt_key, $answer_header,$session_id);
1564 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1565 }
1566 }
1567 }
1568 }
1570 my $filter = POE::Filter::Reference->new();
1571 my %result = (
1572 status => "seems ok to me",
1573 answer => $client_answer,
1574 );
1576 my $output = $filter->put( [ \%result ] );
1577 print @$output;
1580 }
1582 sub session_start {
1583 my ($kernel) = $_[KERNEL];
1584 $global_kernel = $kernel;
1585 $kernel->yield('register_at_foreign_servers');
1586 $kernel->yield('create_fai_server_db', $fai_server_tn );
1587 $kernel->yield('create_fai_release_db', $fai_release_tn );
1588 $kernel->yield('watch_for_next_tasks');
1589 $kernel->sig(USR1 => "sig_handler");
1590 $kernel->sig(USR2 => "recreate_packages_db");
1591 $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
1592 $kernel->delay_set('watch_for_done_jobs', $job_queue_loop_delay);
1593 $kernel->delay_set('watch_for_modified_jobs', $modified_jobs_loop_delay);
1594 $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
1595 $kernel->delay_set('watch_for_delivery_messages', $messaging_db_loop_delay);
1596 $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
1597 $kernel->delay_set('watch_for_old_known_clients', $job_queue_loop_delay);
1599 # Start opsi check
1600 if ($opsi_enabled eq "true") {
1601 $kernel->delay_set('watch_for_opsi_jobs', $job_queue_opsi_delay);
1602 }
1604 }
1607 sub watch_for_done_jobs {
1608 #CHECK: $heap for what?
1609 my ($kernel,$heap) = @_[KERNEL, HEAP];
1611 my $sql_statement = "SELECT * FROM ".$job_queue_tn." WHERE ((status='done') AND (modified='0'))";
1612 my $res = $job_db->select_dbentry( $sql_statement );
1614 while( my ($id, $hit) = each %{$res} ) {
1615 my $jobdb_id = $hit->{id};
1616 my $sql_statement = "DELETE FROM $job_queue_tn WHERE id=$jobdb_id";
1617 my $res = $job_db->del_dbentry($sql_statement);
1618 }
1620 $kernel->delay_set('watch_for_done_jobs',$job_queue_loop_delay);
1621 }
1624 sub watch_for_opsi_jobs {
1625 my ($kernel) = $_[KERNEL];
1627 # 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
1628 # opsi install job is to parse the xml message. There is still the correct header.
1629 my $sql_statement = "SELECT * FROM ".$job_queue_tn." WHERE ((xmlmessage LIKE '%opsi_install_client</header>%') AND (status='processing') AND (siserver='localhost'))";
1630 my $res = $job_db->select_dbentry( $sql_statement );
1632 # Ask OPSI for an update of the running jobs
1633 while (my ($id, $hit) = each %$res ) {
1634 # Determine current parameters of the job
1635 my $hostId = $hit->{'plainname'};
1636 my $macaddress = $hit->{'macaddress'};
1637 my $progress = $hit->{'progress'};
1639 my $result= {};
1641 # For hosts, only return the products that are or get installed
1642 my $callobj;
1643 $callobj = {
1644 method => 'getProductStates_hash',
1645 params => [ $hostId ],
1646 id => 1,
1647 };
1649 my $hres = $opsi_client->call($opsi_url, $callobj);
1650 #my ($hres_err, $hres_err_string) = &check_opsi_res($hres);
1651 if (not &check_opsi_res($hres)) {
1652 my $htmp= $hres->result->{$hostId};
1654 # Check state != not_installed or action == setup -> load and add
1655 my $products= 0;
1656 my $installed= 0;
1657 my $installing = 0;
1658 my $error= 0;
1659 my @installed_list;
1660 my @error_list;
1661 my $act_status = "none";
1662 foreach my $product (@{$htmp}){
1664 if ($product->{'installationStatus'} ne "not_installed" or
1665 $product->{'actionRequest'} eq "setup"){
1667 # Increase number of products for this host
1668 $products++;
1670 if ($product->{'installationStatus'} eq "failed"){
1671 $result->{$product->{'productId'}}= "error";
1672 unshift(@error_list, $product->{'productId'});
1673 $error++;
1674 }
1675 if ($product->{'installationStatus'} eq "installed" && $product->{'actionRequest'} eq "none"){
1676 $result->{$product->{'productId'}}= "installed";
1677 unshift(@installed_list, $product->{'productId'});
1678 $installed++;
1679 }
1680 if ($product->{'installationStatus'} eq "installing"){
1681 $result->{$product->{'productId'}}= "installing";
1682 $installing++;
1683 $act_status = "installing - ".$product->{'productId'};
1684 }
1685 }
1686 }
1688 # Estimate "rough" progress, avoid division by zero
1689 if ($products == 0) {
1690 $result->{'progress'}= 0;
1691 } else {
1692 $result->{'progress'}= int($installed * 100 / $products);
1693 }
1695 # Set updates in job queue
1696 if ((not $error) && (not $installing) && ($installed)) {
1697 $act_status = "installed - ".join(", ", @installed_list);
1698 }
1699 if ($error) {
1700 $act_status = "error - ".join(", ", @error_list);
1701 }
1702 if ($progress ne $result->{'progress'} ) {
1703 # Updating progress and result
1704 my $update_statement = "UPDATE $job_queue_tn SET modified='1', progress='".$result->{'progress'}."', result='$act_status' WHERE macaddress LIKE '$macaddress' AND siserver='localhost'";
1705 my $update_res = $job_db->update_dbentry($update_statement);
1706 }
1707 if ($progress eq 100) {
1708 # Updateing status
1709 my $done_statement = "UPDATE $job_queue_tn SET modified='1', ";
1710 if ($error) {
1711 $done_statement .= "status='error'";
1712 } else {
1713 $done_statement .= "status='done'";
1714 }
1715 $done_statement .= " WHERE macaddress LIKE '$macaddress' AND siserver='localhost'";
1716 my $done_res = $job_db->update_dbentry($done_statement);
1717 }
1720 }
1721 }
1723 $kernel->delay_set('watch_for_opsi_jobs', $job_queue_opsi_delay);
1724 }
1727 # If a job got an update or was modified anyway, send to all other si-server an update message of this jobs.
1728 sub watch_for_modified_jobs {
1729 my ($kernel,$heap) = @_[KERNEL, HEAP];
1731 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE (modified='1')";
1732 my $res = $job_db->select_dbentry( $sql_statement );
1734 # if db contains no jobs which should be update, do nothing
1735 if (keys %$res != 0) {
1737 if ($job_synchronization eq "true") {
1738 # make out of the db result a gosa-si message
1739 my $update_msg = &db_res2si_msg ($res, "foreign_job_updates", "KNOWN_SERVER", "MY_LOCAL_ADDRESS");
1741 # update all other SI-server
1742 &inform_all_other_si_server($update_msg);
1743 }
1745 # set jobs all jobs to modified = 0, wait until the next modification for updates of other si-server
1746 $sql_statement = "UPDATE $job_queue_tn SET modified='0' ";
1747 $res = $job_db->update_dbentry($sql_statement);
1748 }
1750 $kernel->delay_set('watch_for_modified_jobs', $modified_jobs_loop_delay);
1751 }
1754 sub watch_for_new_jobs {
1755 if($watch_for_new_jobs_in_progress == 0) {
1756 $watch_for_new_jobs_in_progress = 1;
1757 my ($kernel,$heap) = @_[KERNEL, HEAP];
1759 # check gosa job queue for jobs with executable timestamp
1760 my $timestamp = &get_time();
1761 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE siserver='localhost' AND status='waiting' AND (CAST(timestamp AS UNSIGNED)) < $timestamp ORDER BY timestamp";
1762 my $res = $job_db->exec_statement( $sql_statement );
1764 # Merge all new jobs that would do the same actions
1765 my @drops;
1766 my $hits;
1767 foreach my $hit (reverse @{$res} ) {
1768 my $macaddress= lc @{$hit}[8];
1769 my $headertag= @{$hit}[5];
1770 if(
1771 defined($hits->{$macaddress}) &&
1772 defined($hits->{$macaddress}->{$headertag}) &&
1773 defined($hits->{$macaddress}->{$headertag}[0])
1774 ) {
1775 push @drops, "DELETE FROM $job_queue_tn WHERE id = $hits->{$macaddress}->{$headertag}[0]";
1776 }
1777 $hits->{$macaddress}->{$headertag}= $hit;
1778 }
1780 # Delete new jobs with a matching job in state 'processing'
1781 foreach my $macaddress (keys %{$hits}) {
1782 foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
1783 my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
1784 if(defined($jobdb_id)) {
1785 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND headertag='$jobdb_headertag' AND status='processing'";
1786 my $res = $job_db->exec_statement( $sql_statement );
1787 foreach my $hit (@{$res}) {
1788 push @drops, "DELETE FROM $job_queue_tn WHERE id=$jobdb_id";
1789 }
1790 } else {
1791 daemon_log("J ERROR: Job without id exists for macaddress $macaddress!", 1);
1792 }
1793 }
1794 }
1796 # Commit deletion
1797 $job_db->exec_statementlist(\@drops);
1799 # Look for new jobs that could be executed
1800 foreach my $macaddress (keys %{$hits}) {
1802 # Look if there is an executing job
1803 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND status='processing'";
1804 my $res = $job_db->exec_statement( $sql_statement );
1806 # Skip new jobs for host if there is a processing job
1807 if(defined($res) and defined @{$res}[0]) {
1808 # Prevent race condition if there is a trigger_activate job waiting and a goto-activation job processing
1809 my $row = @{$res}[0] if (ref $res eq 'ARRAY');
1810 if(@{$row}[5] eq 'trigger_action_reinstall') {
1811 my $sql_statement_2 = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND status='waiting' AND headertag = 'trigger_activate_new'";
1812 my $res_2 = $job_db->exec_statement( $sql_statement_2 );
1813 if(defined($res_2) and defined @{$res_2}[0]) {
1814 # Set status from goto-activation to 'waiting' and update timestamp
1815 $job_db->exec_statement("UPDATE $job_queue_tn SET status='waiting' WHERE macaddress LIKE '$macaddress' AND headertag = 'trigger_action_reinstall'");
1816 $job_db->exec_statement("UPDATE $job_queue_tn SET timestamp='".&calc_timestamp(&get_time(), 'plus', 30)."' WHERE macaddress LIKE '$macaddress' AND headertag = 'trigger_action_reinstall'");
1817 }
1818 }
1819 next;
1820 }
1822 foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
1823 my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
1824 if(defined($jobdb_id)) {
1825 my $job_msg = @{$hits->{$macaddress}->{$jobdb_headertag}}[7];
1827 daemon_log("J DEBUG: its time to execute $job_msg", 7);
1828 my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$macaddress'";
1829 my $res_hash = $known_clients_db->select_dbentry( $sql_statement );
1831 # expect macaddress is unique!!!!!!
1832 my $target = $res_hash->{1}->{hostname};
1834 # change header
1835 $job_msg =~ s/<header>job_/<header>gosa_/;
1837 # add sqlite_id
1838 $job_msg =~ s/<\/xml>$/<jobdb_id>$jobdb_id<\/jobdb_id><\/xml>/;
1840 $job_msg =~ /<header>(\S+)<\/header>/;
1841 my $header = $1 ;
1842 my $func_error = &send_msg_to_target($job_msg, $server_address, $GosaPackages_key, $header, "J");
1844 # update status in job queue to ...
1845 # ... 'processing', for jobs: 'reinstall', 'update'
1846 if (($header =~ /gosa_trigger_action_reinstall/)
1847 || ($header =~ /gosa_trigger_activate_new/)
1848 || ($header =~ /gosa_trigger_action_update/)) {
1849 my $sql_statement = "UPDATE $job_queue_tn SET status='processing' WHERE id=$jobdb_id";
1850 my $dbres = $job_db->update_dbentry($sql_statement);
1851 }
1853 # ... 'done', for all other jobs, they are no longer needed in the jobqueue
1854 else {
1855 my $sql_statement = "UPDATE $job_queue_tn SET status='done' WHERE id=$jobdb_id";
1856 my $dbres = $job_db->update_dbentry($sql_statement);
1857 }
1860 # We don't want parallel processing
1861 last;
1862 }
1863 }
1864 }
1866 $watch_for_new_jobs_in_progress = 0;
1867 $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
1868 }
1869 }
1872 sub watch_for_new_messages {
1873 my ($kernel,$heap) = @_[KERNEL, HEAP];
1874 my @coll_user_msg; # collection list of outgoing messages
1876 # check messaging_db for new incoming messages with executable timestamp
1877 my $timestamp = &get_time();
1878 my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( (CAST(timestamp AS UNSIGNED))<$timestamp AND flag='n' AND direction='in' )";
1879 my $res = $messaging_db->exec_statement( $sql_statement );
1880 foreach my $hit (@{$res}) {
1882 # create outgoing messages
1883 my $message_to = @{$hit}[3];
1884 # translate message_to to plain login name
1885 my @message_to_l = split(/,/, $message_to);
1886 my %receiver_h;
1887 foreach my $receiver (@message_to_l) {
1888 if ($receiver =~ /^u_([\s\S]*)$/) {
1889 $receiver_h{$1} = 0;
1890 } elsif ($receiver =~ /^g_([\s\S]*)$/) {
1891 my $group_name = $1;
1892 # fetch all group members from ldap and add them to receiver hash
1893 my $ldap_handle = &get_ldap_handle();
1894 if (defined $ldap_handle) {
1895 my $mesg = $ldap_handle->search(
1896 base => $ldap_base,
1897 scope => 'sub',
1898 attrs => ['memberUid'],
1899 filter => "cn=$group_name",
1900 );
1901 if ($mesg->count) {
1902 my @entries = $mesg->entries;
1903 foreach my $entry (@entries) {
1904 my @receivers= $entry->get_value("memberUid");
1905 foreach my $receiver (@receivers) {
1906 $receiver_h{$receiver} = 0;
1907 }
1908 }
1909 }
1910 # translating errors ?
1911 if ($mesg->code) {
1912 daemon_log("M ERROR: unable to translate group '$group_name' to user list for message delivery: $mesg->error", 1);
1913 }
1914 &release_ldap_handle($ldap_handle);
1915 # ldap handle error ?
1916 } else {
1917 daemon_log("M ERROR: unable to translate group '$group_name' to user list for message delivery: no ldap handle available", 1);
1918 }
1919 } else {
1920 my $sbjct = &encode_base64(@{$hit}[1]);
1921 my $msg = &encode_base64(@{$hit}[7]);
1922 &daemon_log("M WARNING: unknown receiver '$receiver' for a user-message '$sbjct - $msg'", 3);
1923 }
1924 }
1925 my @receiver_l = keys(%receiver_h);
1927 my $message_id = @{$hit}[0];
1929 #add each outgoing msg to messaging_db
1930 my $receiver;
1931 foreach $receiver (@receiver_l) {
1932 my $sql_statement = "INSERT INTO $messaging_tn (id, subject, message_from, message_to, flag, direction, delivery_time, message, timestamp) ".
1933 "VALUES ('".
1934 $message_id."', '". # id
1935 @{$hit}[1]."', '". # subject
1936 @{$hit}[2]."', '". # message_from
1937 $receiver."', '". # message_to
1938 "none"."', '". # flag
1939 "out"."', '". # direction
1940 @{$hit}[6]."', '". # delivery_time
1941 @{$hit}[7]."', '". # message
1942 $timestamp."'". # timestamp
1943 ")";
1944 &daemon_log("M DEBUG: $sql_statement", 1);
1945 my $res = $messaging_db->exec_statement($sql_statement);
1946 &daemon_log("M INFO: message '".@{$hit}[0]."' is prepared for delivery to receiver '$receiver'", 5);
1947 }
1949 # set incoming message to flag d=deliverd
1950 $sql_statement = "UPDATE $messaging_tn SET flag='p' WHERE id='$message_id'";
1951 &daemon_log("M DEBUG: $sql_statement", 7);
1952 $res = $messaging_db->update_dbentry($sql_statement);
1953 &daemon_log("M INFO: message '$message_id' is set to flag 'p' (processed)", 5);
1954 }
1956 $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
1957 return;
1958 }
1960 sub watch_for_delivery_messages {
1961 my ($kernel, $heap) = @_[KERNEL, HEAP];
1963 # select outgoing messages
1964 my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( flag='p' AND direction='out' )";
1965 #&daemon_log("0 DEBUG: $sql", 7);
1966 my $res = $messaging_db->exec_statement( $sql_statement );
1968 # build out msg for each usr
1969 foreach my $hit (@{$res}) {
1970 my $receiver = @{$hit}[3];
1971 my $msg_id = @{$hit}[0];
1972 my $subject = @{$hit}[1];
1973 my $message = @{$hit}[7];
1975 # resolve usr -> host where usr is logged in
1976 my $sql = "SELECT * FROM $login_users_tn WHERE (user='$receiver')";
1977 #&daemon_log("0 DEBUG: $sql", 7);
1978 my $res = $login_users_db->exec_statement($sql);
1980 # receiver is logged in nowhere
1981 if (not ref(@$res[0]) eq "ARRAY") { next; }
1983 # receiver ist logged in at a client registered at local server
1984 my $send_succeed = 0;
1985 foreach my $hit (@$res) {
1986 my $receiver_host = @$hit[0];
1987 my $delivered2host = 0;
1988 &daemon_log("M DEBUG: user '$receiver' is logged in at host '$receiver_host'", 7);
1990 # Looking for host in know_clients_db
1991 my $sql = "SELECT * FROM $known_clients_tn WHERE (hostname='$receiver_host')";
1992 my $res = $known_clients_db->exec_statement($sql);
1994 # Host is known in known_clients_db
1995 if (ref(@$res[0]) eq "ARRAY") {
1996 my $receiver_key = @{@{$res}[0]}[2];
1997 my %data = ('subject' => $subject, 'message' => $message, 'usr' => $receiver);
1998 my $out_msg = &build_msg("usr_msg", $server_address, $receiver_host, \%data );
1999 my $error = &send_msg_to_target($out_msg, $receiver_host, $receiver_key, "usr_msg", 0);
2000 if ($error == 0 ) {
2001 $send_succeed++ ;
2002 $delivered2host++ ;
2003 &daemon_log("M DEBUG: send message for user '$receiver' to host '$receiver_host'", 7);
2004 } else {
2005 &daemon_log("M DEBUG: cannot send message for user '$receiver' to host '$receiver_host'", 7);
2006 }
2007 }
2009 # Message already send, do not need to do anything more, otherwise ...
2010 if ($delivered2host) { next;}
2012 # ...looking for host in foreign_clients_db
2013 $sql = "SELECT * FROM $foreign_clients_tn WHERE (hostname='$receiver_host')";
2014 $res = $foreign_clients_db->exec_statement($sql);
2016 # Host is known in foreign_clients_db
2017 if (ref(@$res[0]) eq "ARRAY") {
2018 my $registration_server = @{@{$res}[0]}[2];
2020 # Fetch encryption key for registration server
2021 my $sql = "SELECT * FROM $known_server_tn WHERE (hostname='$registration_server')";
2022 my $res = $known_server_db->exec_statement($sql);
2023 if (ref(@$res[0]) eq "ARRAY") {
2024 my $registration_server_key = @{@{$res}[0]}[3];
2025 my %data = ('subject' => $subject, 'message' => $message, 'usr' => $receiver);
2026 my $out_msg = &build_msg("usr_msg", $server_address, $receiver_host, \%data );
2027 my $error = &send_msg_to_target($out_msg, $registration_server, $registration_server_key, "usr_msg", 0);
2028 if ($error == 0 ) {
2029 $send_succeed++ ;
2030 $delivered2host++ ;
2031 &daemon_log("M DEBUG: send message for user '$receiver' to server '$registration_server'", 7);
2032 } else {
2033 &daemon_log("M ERROR: cannot send message for user '$receiver' to server '$registration_server'", 1);
2034 }
2036 } else {
2037 &daemon_log("M ERROR: host '$receiver_host' is reported to be ".
2038 "registrated at server '$registration_server', ".
2039 "but no data available in known_server_db ", 1);
2040 }
2041 }
2043 if (not $delivered2host) {
2044 &daemon_log("M ERROR: unable to send user message to host '$receiver_host'", 1);
2045 }
2046 }
2048 if ($send_succeed) {
2049 # set outgoing msg at db to deliverd
2050 my $sql = "UPDATE $messaging_tn SET flag='d' WHERE (id='$msg_id' AND direction='out' AND message_to='$receiver')";
2051 my $res = $messaging_db->exec_statement($sql);
2052 &daemon_log("M INFO: send message for user '$receiver' to logged in hosts", 5);
2053 } else {
2054 &daemon_log("M WARNING: failed to deliver message for user '$receiver'", 3);
2055 }
2056 }
2058 $kernel->delay_set('watch_for_delivery_messages', $messaging_db_loop_delay);
2059 return;
2060 }
2063 sub watch_for_done_messages {
2064 my ($kernel,$heap) = @_[KERNEL, HEAP];
2066 my $sql = "SELECT * FROM $messaging_tn WHERE (flag='p' AND direction='in')";
2067 #&daemon_log("0 DEBUG: $sql", 7);
2068 my $res = $messaging_db->exec_statement($sql);
2070 foreach my $hit (@{$res}) {
2071 my $msg_id = @{$hit}[0];
2073 my $sql = "SELECT * FROM $messaging_tn WHERE (id='$msg_id' AND direction='out' AND (NOT flag='s'))";
2074 #&daemon_log("0 DEBUG: $sql", 7);
2075 my $res = $messaging_db->exec_statement($sql);
2077 # not all usr msgs have been seen till now
2078 if ( ref(@$res[0]) eq "ARRAY") { next; }
2080 $sql = "DELETE FROM $messaging_tn WHERE (id='$msg_id')";
2081 #&daemon_log("0 DEBUG: $sql", 7);
2082 $res = $messaging_db->exec_statement($sql);
2084 }
2086 $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
2087 return;
2088 }
2091 sub watch_for_old_known_clients {
2092 my ($kernel,$heap) = @_[KERNEL, HEAP];
2094 my $sql_statement = "SELECT * FROM $known_clients_tn";
2095 my $res = $known_clients_db->select_dbentry( $sql_statement );
2097 my $cur_time = int(&get_time());
2099 while ( my ($hit_num, $hit) = each %$res) {
2100 my $expired_timestamp = int($hit->{'timestamp'});
2101 $expired_timestamp =~ /(\d{4})(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)/;
2102 my $dt = DateTime->new( year => $1,
2103 month => $2,
2104 day => $3,
2105 hour => $4,
2106 minute => $5,
2107 second => $6,
2108 );
2110 $dt->add( seconds => 2 * int($hit->{'keylifetime'}) );
2111 $expired_timestamp = $dt->ymd('').$dt->hms('');
2112 if ($cur_time > $expired_timestamp) {
2113 my $hostname = $hit->{'hostname'};
2114 my $del_sql = "DELETE FROM $known_clients_tn WHERE hostname='$hostname'";
2115 my $del_res = $known_clients_db->exec_statement($del_sql);
2117 &main::daemon_log("0 INFO: timestamp '".$hit->{'timestamp'}."' of client '$hostname' is expired('$expired_timestamp'), client will be deleted from known_clients_db", 5);
2118 }
2120 }
2122 $kernel->delay_set('watch_for_old_known_clients', $job_queue_loop_delay);
2123 }
2126 sub watch_for_next_tasks {
2127 my ($kernel,$heap) = @_[KERNEL, HEAP];
2129 my $sql = "SELECT * FROM $incoming_tn";
2130 my $res = $incoming_db->select_dbentry($sql);
2132 while ( my ($hit_num, $hit) = each %$res) {
2133 my $headertag = $hit->{'headertag'};
2134 if ($headertag =~ /^answer_(\d+)/) {
2135 # do not start processing, this message is for a still running POE::Wheel
2136 next;
2137 }
2138 my $message_id = $hit->{'id'};
2139 my $session_id = $hit->{'sessionid'};
2140 &daemon_log("$session_id DEBUG: start processing for message with incoming id: '$message_id'", 7);
2142 $kernel->yield('next_task', $hit);
2144 my $sql = "DELETE FROM $incoming_tn WHERE id=$message_id";
2145 my $res = $incoming_db->exec_statement($sql);
2146 }
2148 $kernel->delay_set('watch_for_next_tasks', 1);
2149 }
2152 sub get_ldap_handle {
2153 my ($session_id) = @_;
2154 my $heap;
2156 if (not defined $session_id ) { $session_id = 0 };
2157 if ($session_id =~ /[^0-9]*/) { $session_id = 0 };
2159 my ($package, $file, $row, $subroutine, $hasArgs, $wantArray, $evalText, $isRequire) = caller(1);
2160 my $caller_text = "subroutine $subroutine";
2161 if ($subroutine eq "(eval)") {
2162 $caller_text = "eval block within file '$file' for '$evalText'";
2163 }
2164 daemon_log("$session_id INFO: new ldap handle for '$caller_text' required!", 7);
2166 get_handle:
2167 my $ldap_handle = Net::LDAP->new( $ldap_uri );
2168 if (not ref $ldap_handle) {
2169 daemon_log("$session_id ERROR: Connection to LDAP URI '$ldap_uri' failed! Retrying!", 1);
2170 usleep(1000);
2171 goto get_handle;
2172 } else {
2173 daemon_log("$session_id DEBUG: Connection to LDAP URI '$ldap_uri' established.", 6);
2174 }
2176 $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);
2177 return $ldap_handle;
2178 }
2181 sub release_ldap_handle {
2182 my ($ldap_handle) = @_ ;
2183 if(ref $ldap_handle) {
2184 $ldap_handle->disconnect();
2185 }
2186 &main::daemon_log("0 DEBUG: Released a ldap handle!", 6);
2187 return;
2188 }
2191 sub change_fai_state {
2192 my ($st, $targets, $session_id) = @_;
2193 $session_id = 0 if not defined $session_id;
2194 # Set FAI state to localboot
2195 my %mapActions= (
2196 reboot => '',
2197 update => 'softupdate',
2198 localboot => 'localboot',
2199 reinstall => 'install',
2200 rescan => '',
2201 wake => '',
2202 memcheck => 'memcheck',
2203 sysinfo => 'sysinfo',
2204 install => 'install',
2205 );
2207 # Return if this is unknown
2208 if (!exists $mapActions{ $st }){
2209 daemon_log("$session_id ERROR: unknown action '$st', can not translate ot FAIstate", 1);
2210 return;
2211 }
2213 my $state= $mapActions{ $st };
2215 # Build search filter for hosts
2216 my $search= "(&(objectClass=GOhard)";
2217 foreach (@{$targets}){
2218 $search.= "(macAddress=$_)";
2219 }
2220 $search.= ")";
2222 # If there's any host inside of the search string, procress them
2223 if (!($search =~ /macAddress/)){
2224 daemon_log("$session_id ERROR: no macAddress found in filter statement for LDAP search: '$search'", 1);
2225 return;
2226 }
2228 my $ldap_handle = &get_ldap_handle($session_id);
2229 # Perform search for Unit Tag
2230 my $mesg = $ldap_handle->search(
2231 base => $ldap_base,
2232 scope => 'sub',
2233 attrs => ['dn', 'FAIstate', 'objectClass'],
2234 filter => "$search"
2235 );
2237 if ($mesg->count) {
2238 my @entries = $mesg->entries;
2239 if (0 == @entries) {
2240 daemon_log("$session_id ERROR: ldap search failed: ldap_base=$ldap_base, filter=$search", 1);
2241 }
2243 foreach my $entry (@entries) {
2244 # Only modify entry if it is not set to '$state'
2245 if ($entry->get_value("FAIstate") ne "$state"){
2246 daemon_log("$session_id INFO: Setting FAIstate to '$state' for ".$entry->dn, 5);
2247 my $result;
2248 my %tmp = map { $_ => 1 } $entry->get_value("objectClass");
2249 if (exists $tmp{'FAIobject'}){
2250 if ($state eq ''){
2251 $result= $ldap_handle->modify($entry->dn, changes => [ delete => [ FAIstate => [] ] ]);
2252 } else {
2253 $result= $ldap_handle->modify($entry->dn, changes => [ replace => [ FAIstate => $state ] ]);
2254 }
2255 } elsif ($state ne ''){
2256 $result= $ldap_handle->modify($entry->dn, changes => [ add => [ objectClass => 'FAIobject' ], add => [ FAIstate => $state ] ]);
2257 }
2259 # Errors?
2260 if ($result->code){
2261 daemon_log("$session_id Error: Setting FAIstate to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
2262 }
2263 } else {
2264 daemon_log("$session_id DEBUG FAIstate at host '".$entry->dn."' already at state '$st'", 7);
2265 }
2266 }
2267 } else {
2268 daemon_log("$session_id ERROR: LDAP search failed: ldap_base=$ldap_base, filter=$search", 1);
2269 }
2270 &release_ldap_handle($ldap_handle);
2272 return;
2273 }
2276 sub change_goto_state {
2277 my ($st, $targets, $session_id) = @_;
2278 $session_id = 0 if not defined $session_id;
2280 # Switch on or off?
2281 my $state= $st eq 'active' ? 'active': 'locked';
2283 my $ldap_handle = &get_ldap_handle($session_id);
2284 if( defined($ldap_handle) ) {
2286 # Build search filter for hosts
2287 my $search= "(&(objectClass=GOhard)";
2288 foreach (@{$targets}){
2289 $search.= "(macAddress=$_)";
2290 }
2291 $search.= ")";
2293 # If there's any host inside of the search string, procress them
2294 if (!($search =~ /macAddress/)){
2295 &release_ldap_handle($ldap_handle);
2296 return;
2297 }
2299 # Perform search for Unit Tag
2300 my $mesg = $ldap_handle->search(
2301 base => $ldap_base,
2302 scope => 'sub',
2303 attrs => ['dn', 'gotoMode'],
2304 filter => "$search"
2305 );
2307 if ($mesg->count) {
2308 my @entries = $mesg->entries;
2309 foreach my $entry (@entries) {
2311 # Only modify entry if it is not set to '$state'
2312 if ($entry->get_value("gotoMode") ne $state){
2314 daemon_log("$session_id INFO: Setting gotoMode to '$state' for ".$entry->dn, 5);
2315 my $result;
2316 $result= $ldap_handle->modify($entry->dn, changes => [replace => [ gotoMode => $state ] ]);
2318 # Errors?
2319 if ($result->code){
2320 &daemon_log("$session_id Error: Setting gotoMode to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
2321 }
2323 }
2324 }
2325 } else {
2326 daemon_log("$session_id ERROR: LDAP search failed in function change_goto_state: ldap_base=$ldap_base, filter=$search", 1);
2327 }
2329 }
2330 &release_ldap_handle($ldap_handle);
2331 return;
2332 }
2335 sub run_recreate_packages_db {
2336 my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];
2337 my $session_id = $session->ID;
2338 &main::daemon_log("$session_id INFO: Recreating FAI Packages DB ('$fai_release_tn', '$fai_server_tn', '$packages_list_tn')", 5);
2339 $kernel->yield('create_fai_release_db', $fai_release_tn);
2340 $kernel->yield('create_fai_server_db', $fai_server_tn);
2341 return;
2342 }
2345 sub run_create_fai_server_db {
2346 my ($kernel, $session, $heap, $table_name) = @_[KERNEL, SESSION, HEAP, ARG0];
2347 my $session_id = $session->ID;
2348 my $task = POE::Wheel::Run->new(
2349 Program => sub { &create_fai_server_db($table_name,$kernel, undef, $session_id) },
2350 StdoutEvent => "session_run_result",
2351 StderrEvent => "session_run_debug",
2352 CloseEvent => "session_run_done",
2353 );
2355 $heap->{task}->{ $task->ID } = $task;
2356 return;
2357 }
2360 sub create_fai_server_db {
2361 my ($table_name, $kernel, $dont_create_packages_list, $session_id) = @_;
2362 my $result;
2364 if (not defined $session_id) { $session_id = 0; }
2365 my $ldap_handle = &get_ldap_handle($session_id);
2366 if(defined($ldap_handle)) {
2367 daemon_log("$session_id INFO: create_fai_server_db: start", 5);
2368 my $mesg= $ldap_handle->search(
2369 base => $ldap_base,
2370 scope => 'sub',
2371 attrs => ['FAIrepository', 'gosaUnitTag'],
2372 filter => "(&(FAIrepository=*)(objectClass=FAIrepositoryServer))",
2373 );
2374 if($mesg->{'resultCode'} == 0 &&
2375 $mesg->count != 0) {
2376 foreach my $entry (@{$mesg->{entries}}) {
2377 if($entry->exists('FAIrepository')) {
2378 # Add an entry for each Repository configured for server
2379 foreach my $repo(@{$entry->get_value('FAIrepository', asref => 1)}) {
2380 my($tmp_url,$tmp_server,$tmp_release,$tmp_sections) = split(/\|/, $repo);
2381 my $tmp_tag= $entry->get_value('gosaUnitTag') || "";
2382 $result= $fai_server_db->add_dbentry( {
2383 table => $table_name,
2384 primkey => ['server', 'fai_release', 'tag'],
2385 server => $tmp_url,
2386 fai_release => $tmp_release,
2387 sections => $tmp_sections,
2388 tag => (length($tmp_tag)>0)?$tmp_tag:"",
2389 } );
2390 }
2391 }
2392 }
2393 }
2394 daemon_log("$session_id INFO: create_fai_server_db: finished", 5);
2395 &release_ldap_handle($ldap_handle);
2397 # TODO: Find a way to post the 'create_packages_list_db' event
2398 if(not defined($dont_create_packages_list)) {
2399 &create_packages_list_db(undef, $session_id);
2400 }
2401 }
2403 return $result;
2404 }
2407 sub run_create_fai_release_db {
2408 my ($kernel, $session, $heap, $table_name) = @_[KERNEL, SESSION, HEAP, ARG0];
2409 my $session_id = $session->ID;
2410 my $task = POE::Wheel::Run->new(
2411 Program => sub { &create_fai_release_db($table_name, $session_id) },
2412 StdoutEvent => "session_run_result",
2413 StderrEvent => "session_run_debug",
2414 CloseEvent => "session_run_done",
2415 );
2417 $heap->{task}->{ $task->ID } = $task;
2418 return;
2419 }
2422 sub create_fai_release_db {
2423 my ($table_name, $session_id) = @_;
2424 my $result;
2426 # used for logging
2427 if (not defined $session_id) { $session_id = 0; }
2429 my $ldap_handle = &get_ldap_handle($session_id);
2430 if(defined($ldap_handle)) {
2431 daemon_log("$session_id INFO: create_fai_release_db: start",5);
2432 my $mesg= $ldap_handle->search(
2433 base => $ldap_base,
2434 scope => 'sub',
2435 attrs => [],
2436 filter => "(&(objectClass=organizationalUnit)(ou=fai))",
2437 );
2438 if(($mesg->code == 0) && ($mesg->count != 0))
2439 {
2440 daemon_log("$session_id DEBUG: create_fai_release_db: count " . $mesg->count,8);
2442 # Walk through all possible FAI container ou's
2443 my @sql_list;
2444 my $timestamp= &get_time();
2445 foreach my $ou (@{$mesg->{entries}}) {
2446 my $tmp_classes= resolve_fai_classes($ou->dn, $ldap_handle, $session_id);
2447 if(defined($tmp_classes) && ref($tmp_classes) eq 'HASH') {
2448 my @tmp_array=get_fai_release_entries($tmp_classes);
2449 if(@tmp_array) {
2450 foreach my $entry (@tmp_array) {
2451 if(defined($entry) && ref($entry) eq 'HASH') {
2452 my $sql=
2453 "INSERT INTO $table_name "
2454 ."(timestamp, fai_release, class, type, state) VALUES ("
2455 .$timestamp.","
2456 ."'".$entry->{'release'}."',"
2457 ."'".$entry->{'class'}."',"
2458 ."'".$entry->{'type'}."',"
2459 ."'".$entry->{'state'}."')";
2460 push @sql_list, $sql;
2461 }
2462 }
2463 }
2464 }
2465 }
2467 daemon_log("$session_id DEBUG: create_fai_release_db: Inserting ".scalar @sql_list." entries to DB",8);
2468 &release_ldap_handle($ldap_handle);
2469 if(@sql_list) {
2470 unshift @sql_list, "VACUUM";
2471 unshift @sql_list, "DELETE FROM $table_name";
2472 $fai_release_db->exec_statementlist(\@sql_list);
2473 }
2474 daemon_log("$session_id DEBUG: create_fai_release_db: Done with inserting",7);
2475 } else {
2476 daemon_log("$session_id INFO: create_fai_release_db: error: " . $mesg->code, 5);
2477 }
2478 daemon_log("$session_id INFO: create_fai_release_db: finished",5);
2479 }
2480 return $result;
2481 }
2483 sub get_fai_types {
2484 my $tmp_classes = shift || return undef;
2485 my @result;
2487 foreach my $type(keys %{$tmp_classes}) {
2488 if(defined($tmp_classes->{$type}[0]) && (!($tmp_classes->{$type}[0] =~ /^.*?removed.*?$/))) {
2489 my $entry = {
2490 type => $type,
2491 state => $tmp_classes->{$type}[0],
2492 };
2493 push @result, $entry;
2494 }
2495 }
2497 return @result;
2498 }
2500 sub get_fai_state {
2501 my $result = "";
2502 my $tmp_classes = shift || return $result;
2504 foreach my $type(keys %{$tmp_classes}) {
2505 if(defined($tmp_classes->{$type}[0])) {
2506 $result = $tmp_classes->{$type}[0];
2508 # State is equal for all types in class
2509 last;
2510 }
2511 }
2513 return $result;
2514 }
2516 sub resolve_fai_classes {
2517 my ($fai_base, $ldap_handle, $session_id) = @_;
2518 if (not defined $session_id) { $session_id = 0; }
2519 my $result;
2520 my @possible_fai_classes= ("FAIscript", "FAIhook", "FAIpartitionTable", "FAItemplate", "FAIvariable", "FAIprofile", "FAIpackageList");
2521 my $fai_filter= "(|(&(objectClass=FAIclass)(|(objectClass=".join(")(objectClass=", @possible_fai_classes).")))(objectClass=FAIbranch))";
2522 my $fai_classes;
2524 daemon_log("$session_id DEBUG: Searching for FAI entries in base $fai_base",7);
2525 my $mesg= $ldap_handle->search(
2526 base => $fai_base,
2527 scope => 'sub',
2528 attrs => ['cn','objectClass','FAIstate'],
2529 filter => $fai_filter,
2530 );
2531 daemon_log("$session_id DEBUG: Found ".$mesg->count()." FAI entries",7);
2533 if($mesg->{'resultCode'} == 0 &&
2534 $mesg->count != 0) {
2535 foreach my $entry (@{$mesg->{entries}}) {
2536 if($entry->exists('cn')) {
2537 my $tmp_dn= $entry->dn();
2538 $tmp_dn= substr( $tmp_dn, 0, length($tmp_dn)
2539 - length($fai_base) - 1 );
2541 # Skip classname and ou dn parts for class
2542 my $tmp_release = ($1) if $tmp_dn =~ /^[^,]+,[^,]+,(.*?)$/;
2544 # Skip classes without releases
2545 if((!defined($tmp_release)) || length($tmp_release)==0) {
2546 next;
2547 }
2549 my $tmp_cn= $entry->get_value('cn');
2550 my $tmp_state= $entry->get_value('FAIstate');
2552 my $tmp_type;
2553 # Get FAI type
2554 for my $oclass(@{$entry->get_value('objectClass', asref => 1)}) {
2555 if(grep $_ eq $oclass, @possible_fai_classes) {
2556 $tmp_type= $oclass;
2557 last;
2558 }
2559 }
2561 if($tmp_release =~ /^.*?,.*?$/ && (!($tmp_release =~ /^.*?\\,.*?$/))) {
2562 # A Subrelease
2563 my @sub_releases = split(/,/, $tmp_release);
2565 # Walk through subreleases and build hash tree
2566 my $hash;
2567 while(my $tmp_sub_release = pop @sub_releases) {
2568 $hash .= "\{'$tmp_sub_release'\}->";
2569 }
2570 eval('push @{$fai_classes->'.$hash.'{$tmp_cn}->{$tmp_type}}, (defined($tmp_state) && length($tmp_state)>0)?$tmp_state:"";');
2571 } else {
2572 # A branch, no subrelease
2573 push @{$fai_classes->{$tmp_release}->{$tmp_cn}->{$tmp_type}}, (defined($tmp_state) && length($tmp_state)>0)?$tmp_state:"";
2574 }
2575 } elsif (!$entry->exists('cn')) {
2576 my $tmp_dn= $entry->dn();
2577 $tmp_dn= substr( $tmp_dn, 0, length($tmp_dn)
2578 - length($fai_base) - 1 );
2579 my $tmp_release = ($1) if $tmp_dn =~ /^(.*?)$/;
2581 # Skip classes without releases
2582 if((!defined($tmp_release)) || length($tmp_release)==0) {
2583 next;
2584 }
2586 if($tmp_release =~ /^.*?,.*?$/ && (!($tmp_release =~ /^.*?\\,.*?$/))) {
2587 # A Subrelease
2588 my @sub_releases= split(/,/, $tmp_release);
2590 # Walk through subreleases and build hash tree
2591 my $hash;
2592 while(my $tmp_sub_release = pop @sub_releases) {
2593 $hash .= "\{'$tmp_sub_release'\}->";
2594 }
2595 # Remove the last two characters
2596 chop($hash);
2597 chop($hash);
2599 eval('$fai_classes->'.$hash.'= {}');
2600 } else {
2601 # A branch, no subrelease
2602 if(!exists($fai_classes->{$tmp_release})) {
2603 $fai_classes->{$tmp_release} = {};
2604 }
2605 }
2606 }
2607 }
2609 # The hash is complete, now we can honor the copy-on-write based missing entries
2610 foreach my $release (keys %$fai_classes) {
2611 $result->{$release}= deep_copy(apply_fai_inheritance($fai_classes->{$release}));
2612 }
2613 }
2614 return $result;
2615 }
2617 sub apply_fai_inheritance {
2618 my $fai_classes = shift || return {};
2619 my $tmp_classes;
2621 # Get the classes from the branch
2622 foreach my $class (keys %{$fai_classes}) {
2623 # Skip subreleases
2624 if($class =~ /^ou=.*$/) {
2625 next;
2626 } else {
2627 $tmp_classes->{$class}= deep_copy($fai_classes->{$class});
2628 }
2629 }
2631 # Apply to each subrelease
2632 foreach my $subrelease (keys %{$fai_classes}) {
2633 if($subrelease =~ /ou=/) {
2634 foreach my $tmp_class (keys %{$tmp_classes}) {
2635 if(!exists($fai_classes->{$subrelease}->{$tmp_class})) {
2636 $fai_classes->{$subrelease}->{$tmp_class} =
2637 deep_copy($tmp_classes->{$tmp_class});
2638 } else {
2639 foreach my $type (keys %{$tmp_classes->{$tmp_class}}) {
2640 if(!exists($fai_classes->{$subrelease}->{$tmp_class}->{$type})) {
2641 $fai_classes->{$subrelease}->{$tmp_class}->{$type}=
2642 deep_copy($tmp_classes->{$tmp_class}->{$type});
2643 }
2644 }
2645 }
2646 }
2647 }
2648 }
2650 # Find subreleases in deeper levels
2651 foreach my $subrelease (keys %{$fai_classes}) {
2652 if($subrelease =~ /ou=/) {
2653 foreach my $subsubrelease (keys %{$fai_classes->{$subrelease}}) {
2654 if($subsubrelease =~ /ou=/) {
2655 apply_fai_inheritance($fai_classes->{$subrelease});
2656 }
2657 }
2658 }
2659 }
2661 return $fai_classes;
2662 }
2664 sub get_fai_release_entries {
2665 my $tmp_classes = shift || return;
2666 my $parent = shift || "";
2667 my @result = shift || ();
2669 foreach my $entry (keys %{$tmp_classes}) {
2670 if(defined($entry)) {
2671 if($entry =~ /^ou=.*$/) {
2672 my $release_name = $entry;
2673 $release_name =~ s/ou=//g;
2674 if(length($parent)>0) {
2675 $release_name = $parent."/".$release_name;
2676 }
2677 my @bufentries = get_fai_release_entries($tmp_classes->{$entry}, $release_name, @result);
2678 foreach my $bufentry(@bufentries) {
2679 push @result, $bufentry;
2680 }
2681 } else {
2682 my @types = get_fai_types($tmp_classes->{$entry});
2683 foreach my $type (@types) {
2684 push @result,
2685 {
2686 'class' => $entry,
2687 'type' => $type->{'type'},
2688 'release' => $parent,
2689 'state' => $type->{'state'},
2690 };
2691 }
2692 }
2693 }
2694 }
2696 return @result;
2697 }
2699 sub deep_copy {
2700 my $this = shift;
2701 if (not ref $this) {
2702 $this;
2703 } elsif (ref $this eq "ARRAY") {
2704 [map deep_copy($_), @$this];
2705 } elsif (ref $this eq "HASH") {
2706 +{map { $_ => deep_copy($this->{$_}) } keys %$this};
2707 } else { die "what type is $_?" }
2708 }
2711 sub session_run_result {
2712 my ($kernel, $heap, $client_answer) = @_[KERNEL, HEAP, ARG0];
2713 $kernel->sig(CHLD => "child_reap");
2714 }
2716 sub session_run_debug {
2717 my $result = $_[ARG0];
2718 print STDERR "$result\n";
2719 }
2721 sub session_run_done {
2722 my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
2723 delete $heap->{task}->{$task_id};
2724 if (exists $heap->{ldap_handle}->{$task_id}) {
2725 &release_ldap_handle($heap->{ldap_handle}->{$task_id});
2726 }
2727 delete $heap->{ldap_handle}->{$task_id};
2728 }
2731 sub create_sources_list {
2732 my $session_id = shift || 0;
2733 my $result="/tmp/gosa_si_tmp_sources_list";
2735 # Remove old file
2736 if(stat($result)) {
2737 unlink($result);
2738 &main::daemon_log("$session_id DEBUG: remove an old version of '$result'", 7);
2739 }
2741 my $fh;
2742 open($fh, ">$result");
2743 if (not defined $fh) {
2744 &main::daemon_log("$session_id DEBUG: cannot open '$result' for writing", 7);
2745 return undef;
2746 }
2747 if(defined($main::ldap_server_dn) and length($main::ldap_server_dn) > 0) {
2748 my $ldap_handle = &get_ldap_handle($session_id);
2749 my $mesg=$ldap_handle->search(
2750 base => $main::ldap_server_dn,
2751 scope => 'base',
2752 attrs => 'FAIrepository',
2753 filter => 'objectClass=FAIrepositoryServer'
2754 );
2755 if($mesg->count) {
2756 foreach my $entry(@{$mesg->{'entries'}}) {
2757 foreach my $value(@{$entry->get_value('FAIrepository', asref => 1)}) {
2758 my ($server, $tag, $release, $sections)= split /\|/, $value;
2759 my $line = "deb $server $release";
2760 $sections =~ s/,/ /g;
2761 $line.= " $sections";
2762 print $fh $line."\n";
2763 }
2764 }
2765 }
2766 &release_ldap_handle($ldap_handle);
2767 } else {
2768 if (defined $main::ldap_server_dn){
2769 &main::daemon_log("$session_id ERROR: something wrong with ldap_server_dn '$main::ldap_server_dn', abort create_sources_list", 1);
2770 } else {
2771 &main::daemon_log("$session_id ERROR: no ldap_server_dn found, abort create_sources_list", 1);
2772 }
2773 }
2774 close($fh);
2776 return $result;
2777 }
2780 sub run_create_packages_list_db {
2781 my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];
2782 my $session_id = $session->ID;
2783 my $task = POE::Wheel::Run->new(
2784 Priority => +20,
2785 Program => sub {&create_packages_list_db(undef, $session_id)},
2786 StdoutEvent => "session_run_result",
2787 StderrEvent => "session_run_debug",
2788 CloseEvent => "session_run_done",
2789 );
2790 $heap->{task}->{ $task->ID } = $task;
2791 }
2794 sub create_packages_list_db {
2795 my ($sources_file, $session_id) = @_;
2797 # it should not be possible to trigger a recreation of packages_list_db
2798 # while packages_list_db is under construction, so set flag packages_list_under_construction
2799 # which is tested befor recreation can be started
2800 if (-r $packages_list_under_construction) {
2801 daemon_log("$session_id WARNING: packages_list_db is right now under construction, please wait until this process is finished", 3);
2802 return;
2803 } else {
2804 daemon_log("$session_id INFO: create_packages_list_db: start", 5);
2805 # set packages_list_under_construction to true
2806 system("touch $packages_list_under_construction");
2807 @packages_list_statements=();
2808 }
2810 if (not defined $session_id) { $session_id = 0; }
2812 if (not defined $sources_file) {
2813 &main::daemon_log("$session_id INFO: no sources_file given for creating packages list so trigger creation of it", 5);
2814 $sources_file = &create_sources_list($session_id);
2815 }
2817 if (not defined $sources_file) {
2818 &main::daemon_log("$session_id ERROR: no sources_file given under '$sources_file', skip create_packages_list_db", 1);
2819 unlink($packages_list_under_construction);
2820 return;
2821 }
2823 my $line;
2825 open(CONFIG, "<$sources_file") or do {
2826 daemon_log( "$session_id ERROR: create_packages_list_db: Failed to open '$sources_file'", 1);
2827 unlink($packages_list_under_construction);
2828 return;
2829 };
2831 # Read lines
2832 while ($line = <CONFIG>){
2833 # Unify
2834 chop($line);
2835 $line =~ s/^\s+//;
2836 $line =~ s/^\s+/ /;
2838 # Strip comments
2839 $line =~ s/#.*$//g;
2841 # Skip empty lines
2842 if ($line =~ /^\s*$/){
2843 next;
2844 }
2846 # Interpret deb line
2847 if ($line =~ /^deb [^\s]+\s[^\s]+\s[^\s]+/){
2848 my( $baseurl, $dist, $sections ) = ($line =~ /^deb\s([^\s]+)\s+([^\s]+)\s+(.*)$/);
2849 my $section;
2850 foreach $section (split(' ', $sections)){
2851 &parse_package_info( $baseurl, $dist, $section, $session_id );
2852 }
2853 }
2854 }
2856 close (CONFIG);
2858 if(keys(%repo_dirs)) {
2859 find(\&cleanup_and_extract, keys( %repo_dirs ));
2860 &main::strip_packages_list_statements();
2861 $packages_list_db->exec_statementlist(\@packages_list_statements);
2862 }
2863 unlink($packages_list_under_construction);
2864 daemon_log("$session_id INFO: create_packages_list_db: finished", 5);
2865 return;
2866 }
2868 # This function should do some intensive task to minimize the db-traffic
2869 sub strip_packages_list_statements {
2870 my @existing_entries= @{$packages_list_db->exec_statement("SELECT * FROM $main::packages_list_tn")};
2871 my @new_statement_list=();
2872 my $hash;
2873 my $insert_hash;
2874 my $update_hash;
2875 my $delete_hash;
2876 my $known_packages_hash;
2877 my $local_timestamp=get_time();
2879 foreach my $existing_entry (@existing_entries) {
2880 $hash->{@{$existing_entry}[0]}->{@{$existing_entry}[1]}->{@{$existing_entry}[2]}= $existing_entry;
2881 }
2883 foreach my $statement (@packages_list_statements) {
2884 if($statement =~ /^INSERT/i) {
2885 # Assign the values from the insert statement
2886 my ($distribution,$package,$version,$section,$description,$template,$timestamp) = ($1,$2,$3,$4,$5,$6,$7) if $statement =~
2887 /^INSERT\s+?INTO\s+?$main::packages_list_tn\s+?VALUES\s*?\('(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)'\s*?\)$/si;
2888 if(exists($hash->{$distribution}->{$package}->{$version})) {
2889 # If section or description has changed, update the DB
2890 if(
2891 (! (@{$hash->{$distribution}->{$package}->{$version}}[3] eq $section)) or
2892 (! (@{$hash->{$distribution}->{$package}->{$version}}[4] eq $description))
2893 ) {
2894 @{$update_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,undef);
2895 } else {
2896 # package is already present in database. cache this knowledge for later use
2897 @{$known_packages_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,$template);
2898 }
2899 } else {
2900 # Insert a non-existing entry to db
2901 @{$insert_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,$template);
2902 }
2903 } elsif ($statement =~ /^UPDATE/i) {
2904 my ($template,$package,$version) = ($1,$2,$3) if $statement =~
2905 /^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;
2906 foreach my $distribution (keys %{$hash}) {
2907 if(exists($insert_hash->{$distribution}->{$package}->{$version})) {
2908 # update the insertion hash to execute only one query per package (insert instead insert+update)
2909 @{$insert_hash->{$distribution}->{$package}->{$version}}[5]= $template;
2910 } elsif(exists($hash->{$distribution}->{$package}->{$version})) {
2911 if( ! (@{$hash->{$distribution}->{$package}->{$version}}[5] eq $template)) {
2912 my $section;
2913 my $description;
2914 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[3]) and
2915 length(@{$update_hash->{$distribution}->{$package}->{$version}}[3]) > 0 ) {
2916 $section= @{$update_hash->{$distribution}->{$package}->{$version}}[3];
2917 }
2918 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[4])) {
2919 $description= @{$update_hash->{$distribution}->{$package}->{$version}}[4];
2920 }
2921 @{$update_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,$template);
2922 }
2923 }
2924 }
2925 }
2926 }
2928 # Check for orphaned entries
2929 foreach my $existing_entry (@existing_entries) {
2930 my $distribution= @{$existing_entry}[0];
2931 my $package= @{$existing_entry}[1];
2932 my $version= @{$existing_entry}[2];
2933 my $section= @{$existing_entry}[3];
2935 if(
2936 exists($insert_hash->{$distribution}->{$package}->{$version}) ||
2937 exists($update_hash->{$distribution}->{$package}->{$version}) ||
2938 exists($known_packages_hash->{$distribution}->{$package}->{$version})
2939 ) {
2940 next;
2941 } else {
2942 # Insert entry to delete hash
2943 @{$delete_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section);
2944 }
2945 }
2947 # unroll the insert hash
2948 foreach my $distribution (keys %{$insert_hash}) {
2949 foreach my $package (keys %{$insert_hash->{$distribution}}) {
2950 foreach my $version (keys %{$insert_hash->{$distribution}->{$package}}) {
2951 push @new_statement_list, "INSERT INTO $main::packages_list_tn VALUES ('$distribution','$package','$version',"
2952 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[3]',"
2953 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[4]',"
2954 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[5]',"
2955 ."'$local_timestamp')";
2956 }
2957 }
2958 }
2960 # unroll the update hash
2961 foreach my $distribution (keys %{$update_hash}) {
2962 foreach my $package (keys %{$update_hash->{$distribution}}) {
2963 foreach my $version (keys %{$update_hash->{$distribution}->{$package}}) {
2964 my $set = "";
2965 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[3])) {
2966 $set .= "section = '@{$update_hash->{$distribution}->{$package}->{$version}}[3]', ";
2967 }
2968 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[4])) {
2969 $set .= "description = '@{$update_hash->{$distribution}->{$package}->{$version}}[4]', ";
2970 }
2971 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[5])) {
2972 $set .= "template = '@{$update_hash->{$distribution}->{$package}->{$version}}[5]', ";
2973 }
2974 if(defined($set) and length($set) > 0) {
2975 $set .= "timestamp = '$local_timestamp'";
2976 } else {
2977 next;
2978 }
2979 push @new_statement_list,
2980 "UPDATE $main::packages_list_tn SET $set WHERE"
2981 ." distribution = '$distribution'"
2982 ." AND package = '$package'"
2983 ." AND version = '$version'";
2984 }
2985 }
2986 }
2988 # unroll the delete hash
2989 foreach my $distribution (keys %{$delete_hash}) {
2990 foreach my $package (keys %{$delete_hash->{$distribution}}) {
2991 foreach my $version (keys %{$delete_hash->{$distribution}->{$package}}) {
2992 my $section = @{$delete_hash->{$distribution}->{$package}->{$version}}[3];
2993 push @new_statement_list, "DELETE FROM $main::packages_list_tn WHERE distribution='$distribution' AND package='$package' AND version='$version' AND section='$section'";
2994 }
2995 }
2996 }
2998 unshift(@new_statement_list, "VACUUM");
3000 @packages_list_statements = @new_statement_list;
3001 }
3004 sub parse_package_info {
3005 my ($baseurl, $dist, $section, $session_id)= @_;
3006 my ($package);
3007 if (not defined $session_id) { $session_id = 0; }
3008 my ($path) = ($baseurl =~ m%://[^/]*(.*)$%);
3009 $repo_dirs{ "${repo_path}/pool" } = 1;
3011 foreach $package ("Packages.gz"){
3012 daemon_log("$session_id DEBUG: create_packages_list: fetch $baseurl, $dist, $section", 7);
3013 get_package( "$baseurl/dists/$dist/$section/binary-$arch/$package", "$outdir/$dist/$section", $session_id );
3014 parse_package( "$outdir/$dist/$section", $dist, $path, $session_id );
3015 }
3017 }
3020 sub get_package {
3021 my ($url, $dest, $session_id)= @_;
3022 if (not defined $session_id) { $session_id = 0; }
3024 my $tpath = dirname($dest);
3025 -d "$tpath" || mkpath "$tpath";
3027 # This is ugly, but I've no time to take a look at "how it works in perl"
3028 if(0 == system("wget '$url' -O '$dest' 2>/dev/null") ) {
3029 system("gunzip -cd '$dest' > '$dest.in'");
3030 daemon_log("$session_id DEBUG: run command: gunzip -cd '$dest' > '$dest.in'", 7);
3031 unlink($dest);
3032 daemon_log("$session_id DEBUG: delete file '$dest'", 7);
3033 } else {
3034 daemon_log("$session_id ERROR: create_packages_list_db: get_packages: fetching '$url' into '$dest' failed!", 1);
3035 }
3036 return 0;
3037 }
3040 sub parse_package {
3041 my ($path, $dist, $srv_path, $session_id)= @_;
3042 if (not defined $session_id) { $session_id = 0;}
3043 my ($package, $version, $section, $description);
3044 my $PACKAGES;
3045 my $timestamp = &get_time();
3047 if(not stat("$path.in")) {
3048 daemon_log("$session_id ERROR: create_packages_list: parse_package: file '$path.in' is not readable",1);
3049 return;
3050 }
3052 open($PACKAGES, "<$path.in");
3053 if(not defined($PACKAGES)) {
3054 daemon_log("$session_id ERROR: create_packages_list_db: parse_package: cannot open '$path.in'",1);
3055 return;
3056 }
3058 # Read lines
3059 while (<$PACKAGES>){
3060 my $line = $_;
3061 # Unify
3062 chop($line);
3064 # Use empty lines as a trigger
3065 if ($line =~ /^\s*$/){
3066 my $sql = "INSERT INTO packages_list VALUES ('$dist', '$package', '$version', '$section', '$description', '', '$timestamp')";
3067 push(@packages_list_statements, $sql);
3068 $package = "none";
3069 $version = "none";
3070 $section = "none";
3071 $description = "none";
3072 next;
3073 }
3075 # Trigger for package name
3076 if ($line =~ /^Package:\s/){
3077 ($package)= ($line =~ /^Package: (.*)$/);
3078 next;
3079 }
3081 # Trigger for version
3082 if ($line =~ /^Version:\s/){
3083 ($version)= ($line =~ /^Version: (.*)$/);
3084 next;
3085 }
3087 # Trigger for description
3088 if ($line =~ /^Description:\s/){
3089 ($description)= &encode_base64(($line =~ /^Description: (.*)$/));
3090 next;
3091 }
3093 # Trigger for section
3094 if ($line =~ /^Section:\s/){
3095 ($section)= ($line =~ /^Section: (.*)$/);
3096 next;
3097 }
3099 # Trigger for filename
3100 if ($line =~ /^Filename:\s/){
3101 my ($filename) = ($line =~ /^Filename: (.*)$/);
3102 store_fileinfo( $package, $filename, $dist, $srv_path, $version, $repo_path );
3103 next;
3104 }
3105 }
3107 close( $PACKAGES );
3108 unlink( "$path.in" );
3109 }
3112 sub store_fileinfo {
3113 my( $package, $file, $dist, $path, $vers, $srvdir) = @_;
3115 my %fileinfo = (
3116 'package' => $package,
3117 'dist' => $dist,
3118 'version' => $vers,
3119 );
3121 $repo_files{ "${srvdir}/$file" } = \%fileinfo;
3122 }
3125 sub cleanup_and_extract {
3126 my $fileinfo = $repo_files{ $File::Find::name };
3128 if( defined $fileinfo ) {
3129 my $dir = "$outdir/$fileinfo->{ 'dist' }/debconf.d";
3130 my $sql;
3131 my $package = $fileinfo->{ 'package' };
3132 my $newver = $fileinfo->{ 'version' };
3134 mkpath($dir);
3135 system( "dpkg -e '$File::Find::name' '$dir/DEBIAN'" );
3137 if( -f "$dir/DEBIAN/templates" ) {
3139 daemon_log("0 DEBUG: Found debconf templates in '$package' - $newver", 7);
3141 my $tmpl= ""; {
3142 local $/=undef;
3143 open FILE, "$dir/DEBIAN/templates";
3144 $tmpl = &encode_base64(<FILE>);
3145 close FILE;
3146 }
3147 rmtree("$dir/DEBIAN/templates");
3149 $sql= "update $main::packages_list_tn set template = '$tmpl' where package = '$package' and version = '$newver';";
3150 push @packages_list_statements, $sql;
3151 }
3152 }
3154 return;
3155 }
3158 sub register_at_foreign_servers {
3159 my ($kernel) = $_[KERNEL];
3161 # Set current delay of register_at_foreign_servers to 0
3163 # Update status and update-time of all si-server with expired update_time and
3164 # block them for race conditional registration processes of other si-servers.
3165 my $act_time = &get_time();
3166 my $block_statement = "UPDATE $known_server_tn SET status='new_server',update_time='19700101000000' WHERE (CAST(update_time AS UNSIGNED))<$act_time ";
3167 &daemon_log("0 DEBUG: $block_statement", 7);
3168 my $block_res = $known_server_db->exec_statement($block_statement);
3170 # Fetch all si-server from db where update_time is younger than act_time
3171 my $fetch_statement = "SELECT * FROM $known_server_tn WHERE update_time='19700101000000'";
3172 &daemon_log("0 DEBUG: $fetch_statement", 7);
3173 my $fetch_res = $known_server_db->exec_statement($fetch_statement);
3175 # Detect already connected clients. Will be added to registration msg later.
3176 my $client_sql = "SELECT * FROM $known_clients_tn";
3177 my $client_res = $known_clients_db->exec_statement($client_sql);
3179 # Send registration messag to all fetched si-server
3180 foreach my $hit (@$fetch_res) {
3181 my $hostname = @$hit[0];
3182 my $hostkey = &create_passwd;
3184 # Add already connected clients to registration message
3185 my $myhash = &create_xml_hash('new_server', $server_address, $hostname);
3186 &add_content2xml_hash($myhash, 'key', $hostkey);
3187 map(&add_content2xml_hash($myhash, 'client', @{$_}[0].",".@{$_}[4]), @$client_res);
3189 # Add locally loaded gosa-si modules to registration message
3190 my $loaded_modules = {};
3191 while (my ($package, $pck_info) = each %$known_modules) {
3192 next if ((!defined(@$pck_info[2])) || (!(ref (@$pck_info[2]) eq 'HASH')));
3193 foreach my $act_module (keys(%{@$pck_info[2]})) {
3194 $loaded_modules->{$act_module} = "";
3195 }
3196 }
3197 map(&add_content2xml_hash($myhash, "loaded_modules", $_), keys(%$loaded_modules));
3199 # Add macaddress to registration message
3200 my ($host_ip, $host_port) = split(/:/, $hostname);
3201 my $local_ip = &get_local_ip_for_remote_ip($host_ip);
3202 my $network_interface= &get_interface_for_ip($local_ip);
3203 my $host_mac = &get_mac_for_interface($network_interface);
3204 &add_content2xml_hash($myhash, 'macaddress', $host_mac);
3206 # Build registration message and send it
3207 my $foreign_server_msg = &create_xml_string($myhash);
3208 my $error = &send_msg_to_target($foreign_server_msg, $hostname, $ServerPackages_key, "new_server", 0);
3209 }
3212 # After n sec perform a check of all server registration processes
3213 $kernel->delay_set("control_server_registration", 2);
3215 return;
3216 }
3219 sub control_server_registration {
3220 my ($kernel) = $_[KERNEL];
3222 # Check if all registration processes succeed or not
3223 my $select_statement = "SELECT * FROM $known_server_tn WHERE status='new_server'";
3224 &daemon_log("0 DEBUG $select_statement", 7);
3225 my $select_res = $known_server_db->exec_statement($select_statement);
3227 # If at least one registration process failed, maybe in case of a race condition
3228 # with a foreign registration process
3229 if (@$select_res > 0)
3230 {
3231 # Release block statement 'new_server' to make the server accessible
3232 # for foreign registration processes
3233 my $update_statement = "UPDATE $known_server_tn SET status='waiting' WHERE status='new_server'";
3234 &daemon_log("0 DEBUG: $update_statement", 7);
3235 my $update_res = $known_server_db->exec_statement($update_statement);
3237 # Set a random delay to avoid the registration race condition
3238 my $new_foreign_servers_register_delay = int(rand(4))+1;
3239 $kernel->delay_set("register_at_foreign_servers", $new_foreign_servers_register_delay);
3240 }
3241 # If all registration processes succeed
3242 else
3243 {
3244 $kernel->delay_set("register_at_foreign_servers", $foreign_servers_register_delay);
3245 }
3247 return;
3248 }
3251 #==== MAIN = main ==============================================================
3252 # parse commandline options
3253 Getopt::Long::Configure( "bundling" );
3254 GetOptions("h|help" => \&usage,
3255 "c|config=s" => \$cfg_file,
3256 "f|foreground" => \$foreground,
3257 "v|verbose+" => \$verbose,
3258 "no-arp+" => \$no_arp,
3259 );
3261 # read and set config parameters
3262 &check_cmdline_param ;
3263 &read_configfile($cfg_file, %cfg_defaults);
3264 &check_pid;
3266 $SIG{CHLD} = 'IGNORE';
3268 # forward error messages to logfile
3269 if( ! $foreground ) {
3270 open( STDIN, '+>/dev/null' );
3271 open( STDOUT, '+>&STDIN' );
3272 open( STDERR, '+>&STDIN' );
3273 }
3275 # Just fork, if we are not in foreground mode
3276 if( ! $foreground ) {
3277 chdir '/' or die "Can't chdir to /: $!";
3278 $pid = fork;
3279 setsid or die "Can't start a new session: $!";
3280 umask 0;
3281 } else {
3282 $pid = $$;
3283 }
3285 # Do something useful - put our PID into the pid_file
3286 if( 0 != $pid ) {
3287 open( LOCK_FILE, ">$pid_file" );
3288 print LOCK_FILE "$pid\n";
3289 close( LOCK_FILE );
3290 if( !$foreground ) {
3291 exit( 0 )
3292 };
3293 }
3295 # parse head url and revision from svn
3296 my $server_status_hash = { 'developmental'=>'revision', 'stable'=>'release'};
3297 $server_version =~ /^\$HeadURL: (\S+) \$:\$Rev: (\d+) \$$/;
3298 $server_headURL = defined $1 ? $1 : 'unknown' ;
3299 $server_revision = defined $2 ? $2 : 'unknown' ;
3300 if ($server_headURL =~ /\/tag\// ||
3301 $server_headURL =~ /\/branches\// ) {
3302 $server_status = "stable";
3303 } else {
3304 $server_status = "developmental" ;
3305 }
3306 # Prepare log file and set permissions
3307 $root_uid = getpwnam('root');
3308 $adm_gid = getgrnam('adm');
3309 open(FH, ">>$log_file");
3310 close FH;
3311 chmod(0440, $log_file);
3312 chown($root_uid, $adm_gid, $log_file);
3313 chown($root_uid, $adm_gid, "/var/lib/gosa-si");
3315 daemon_log(" ", 1);
3316 daemon_log("$0 started!", 1);
3317 daemon_log("status: $server_status", 1);
3318 daemon_log($server_status_hash->{$server_status}.": $server_revision", 1);
3320 # Buildup data bases
3321 {
3322 no strict "refs";
3324 if ($db_module eq "DBmysql") {
3325 # connect to incoming_db
3326 $incoming_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3328 # connect to gosa-si job queue
3329 $job_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3331 # connect to known_clients_db
3332 $known_clients_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3334 # connect to foreign_clients_db
3335 $foreign_clients_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3337 # connect to known_server_db
3338 $known_server_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3340 # connect to login_usr_db
3341 $login_users_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3343 # connect to fai_server_db
3344 $fai_server_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3346 # connect to fai_release_db
3347 $fai_release_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3349 # connect to packages_list_db
3350 $packages_list_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3352 # connect to messaging_db
3353 $messaging_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3355 } elsif ($db_module eq "DBsqlite") {
3356 # connect to incoming_db
3357 unlink($incoming_file_name);
3358 $incoming_db = GOSA::DBsqlite->new($incoming_file_name);
3360 # connect to gosa-si job queue
3361 $job_db = GOSA::DBsqlite->new($job_queue_file_name);
3362 chmod(0640, $job_queue_file_name);
3363 chown($root_uid, $adm_gid, $job_queue_file_name);
3365 # connect to known_clients_db
3366 $known_clients_db = GOSA::DBsqlite->new($known_clients_file_name);
3367 chmod(0640, $known_clients_file_name);
3368 chown($root_uid, $adm_gid, $known_clients_file_name);
3370 # connect to foreign_clients_db
3371 unlink($foreign_clients_file_name);
3372 $foreign_clients_db = GOSA::DBsqlite->new($foreign_clients_file_name);
3373 chmod(0640, $foreign_clients_file_name);
3374 chown($root_uid, $adm_gid, $foreign_clients_file_name);
3376 # connect to known_server_db
3377 unlink($known_server_file_name);
3378 $known_server_db = GOSA::DBsqlite->new($known_server_file_name);
3379 chmod(0640, $known_server_file_name);
3380 chown($root_uid, $adm_gid, $known_server_file_name);
3382 # connect to login_usr_db
3383 unlink($login_users_file_name);
3384 $login_users_db = GOSA::DBsqlite->new($login_users_file_name);
3385 chmod(0640, $login_users_file_name);
3386 chown($root_uid, $adm_gid, $login_users_file_name);
3388 # connect to fai_server_db
3389 unlink($fai_server_file_name);
3390 $fai_server_db = GOSA::DBsqlite->new($fai_server_file_name);
3391 chmod(0640, $fai_server_file_name);
3392 chown($root_uid, $adm_gid, $fai_server_file_name);
3394 # connect to fai_release_db
3395 unlink($fai_release_file_name);
3396 $fai_release_db = GOSA::DBsqlite->new($fai_release_file_name);
3397 chmod(0640, $fai_release_file_name);
3398 chown($root_uid, $adm_gid, $fai_release_file_name);
3400 # connect to packages_list_db
3401 #unlink($packages_list_file_name);
3402 unlink($packages_list_under_construction);
3403 $packages_list_db = GOSA::DBsqlite->new($packages_list_file_name);
3404 chmod(0640, $packages_list_file_name);
3405 chown($root_uid, $adm_gid, $packages_list_file_name);
3407 # connect to messaging_db
3408 unlink($messaging_file_name);
3409 $messaging_db = GOSA::DBsqlite->new($messaging_file_name);
3410 chmod(0640, $messaging_file_name);
3411 chown($root_uid, $adm_gid, $messaging_file_name);
3412 }
3413 }
3416 # Creating tables
3417 $messaging_db->create_table($messaging_tn, \@messaging_col_names);
3418 $packages_list_db->create_table($packages_list_tn, \@packages_list_col_names);
3419 $fai_release_db->create_table($fai_release_tn, \@fai_release_col_names);
3420 $fai_server_db->create_table($fai_server_tn, \@fai_server_col_names);
3421 $login_users_db->create_table($login_users_tn, \@login_users_col_names);
3422 $known_server_db->create_table($known_server_tn, \@known_server_col_names);
3423 $foreign_clients_db->create_table($foreign_clients_tn, \@foreign_clients_col_names);
3424 $known_clients_db->create_table($known_clients_tn, \@known_clients_col_names);
3425 $incoming_db->create_table($incoming_tn, \@incoming_col_names);
3426 $job_db->create_table($job_queue_tn, \@job_queue_col_names);
3428 # create xml object used for en/decrypting
3429 $xml = new XML::Simple();
3432 # foreign servers
3433 my @foreign_server_list;
3435 # add foreign server from cfg file
3436 if ($foreign_server_string ne "") {
3437 my @cfg_foreign_server_list = split(",", $foreign_server_string);
3438 foreach my $foreign_server (@cfg_foreign_server_list) {
3439 push(@foreign_server_list, $foreign_server);
3440 }
3442 daemon_log("0 INFO: found foreign server in config file: ".join(", ", @foreign_server_list), 5);
3443 }
3445 # Perform a DNS lookup for server registration if flag is true
3446 if ($dns_lookup eq "true") {
3447 # Add foreign server from dns
3448 my @tmp_servers;
3449 if (not $server_domain) {
3450 # Try our DNS Searchlist
3451 for my $domain(get_dns_domains()) {
3452 chomp($domain);
3453 my ($tmp_domains, $error_string) = &get_server_addresses($domain);
3454 if(@$tmp_domains) {
3455 for my $tmp_server(@$tmp_domains) {
3456 push @tmp_servers, $tmp_server;
3457 }
3458 }
3459 }
3460 if(@tmp_servers && length(@tmp_servers)==0) {
3461 daemon_log("0 WARNING: no foreign gosa-si-server found in DNS for domain '$server_domain'", 3);
3462 }
3463 } else {
3464 @tmp_servers = &get_server_addresses($server_domain);
3465 if( 0 == @tmp_servers ) {
3466 daemon_log("0 WARNING: no foreign gosa-si-server found in DNS for domain '$server_domain'", 3);
3467 }
3468 }
3470 daemon_log("0 INFO: found foreign server via DNS ".join(", ", @tmp_servers), 5);
3472 foreach my $server (@tmp_servers) {
3473 unshift(@foreign_server_list, $server);
3474 }
3475 } else {
3476 daemon_log("0 INFO: DNS lookup for server registration is disabled", 5);
3477 }
3480 # eliminate duplicate entries
3481 @foreign_server_list = &del_doubles(@foreign_server_list);
3482 my $all_foreign_server = join(", ", @foreign_server_list);
3483 daemon_log("0 INFO: found foreign server in config file and DNS: '$all_foreign_server'", 5);
3485 # add all found foreign servers to known_server
3486 my $cur_timestamp = &get_time();
3487 foreach my $foreign_server (@foreign_server_list) {
3489 # do not add myself to known_server_db
3490 if (&is_local($foreign_server)) { next; }
3491 ######################################
3493 my $res = $known_server_db->add_dbentry( {table=>$known_server_tn,
3494 primkey=>['hostname'],
3495 hostname=>$foreign_server,
3496 macaddress=>"",
3497 status=>'not_yet_registered',
3498 hostkey=>"none",
3499 loaded_modules => "none",
3500 timestamp=>$cur_timestamp,
3501 update_time=>'19700101000000',
3502 } );
3503 }
3506 # Import all modules
3507 &import_modules;
3509 # Check wether all modules are gosa-si valid passwd check
3510 &password_check;
3512 # Prepare for using Opsi
3513 if ($opsi_enabled eq "true") {
3514 use JSON::RPC::Client;
3515 use XML::Quote qw(:all);
3516 $opsi_url= "https://".$opsi_admin.":".$opsi_password."@".$opsi_server.":4447/rpc";
3517 $opsi_client = new JSON::RPC::Client;
3518 }
3521 POE::Component::Server::TCP->new(
3522 Alias => "TCP_SERVER",
3523 Port => $server_port,
3524 ClientInput => sub {
3525 my ($kernel, $input, $heap, $session) = @_[KERNEL, ARG0, HEAP, SESSION];
3526 my $session_id = $session->ID;
3527 my $remote_ip = $heap->{'remote_ip'};
3528 push(@msgs_to_decrypt, $input);
3529 &daemon_log("$session_id DEBUG: incoming message from '$remote_ip'", 7);
3530 $kernel->yield("msg_to_decrypt");
3531 },
3532 InlineStates => {
3533 msg_to_decrypt => \&msg_to_decrypt,
3534 next_task => \&next_task,
3535 task_result => \&handle_task_result,
3536 task_done => \&handle_task_done,
3537 task_debug => \&handle_task_debug,
3538 child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!" },
3539 }
3540 );
3542 daemon_log("0 INFO: start socket for incoming xml messages at port '$server_port' ", 1);
3544 # create session for repeatedly checking the job queue for jobs
3545 POE::Session->create(
3546 inline_states => {
3547 _start => \&session_start,
3548 register_at_foreign_servers => \®ister_at_foreign_servers,
3549 control_server_registration => \&control_server_registration,
3550 sig_handler => \&sig_handler,
3551 next_task => \&next_task,
3552 task_result => \&handle_task_result,
3553 task_done => \&handle_task_done,
3554 task_debug => \&handle_task_debug,
3555 watch_for_next_tasks => \&watch_for_next_tasks,
3556 watch_for_new_messages => \&watch_for_new_messages,
3557 watch_for_delivery_messages => \&watch_for_delivery_messages,
3558 watch_for_done_messages => \&watch_for_done_messages,
3559 watch_for_new_jobs => \&watch_for_new_jobs,
3560 watch_for_modified_jobs => \&watch_for_modified_jobs,
3561 watch_for_done_jobs => \&watch_for_done_jobs,
3562 watch_for_opsi_jobs => \&watch_for_opsi_jobs,
3563 watch_for_old_known_clients => \&watch_for_old_known_clients,
3564 create_packages_list_db => \&run_create_packages_list_db,
3565 create_fai_server_db => \&run_create_fai_server_db,
3566 create_fai_release_db => \&run_create_fai_release_db,
3567 recreate_packages_db => \&run_recreate_packages_db,
3568 session_run_result => \&session_run_result,
3569 session_run_debug => \&session_run_debug,
3570 session_run_done => \&session_run_done,
3571 child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!" },
3572 }
3573 );
3576 POE::Kernel->run();
3577 exit;