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