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