2d3b7b3a043d6322534885ad3d4c4bdf41ee287c
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);
53 use ResourcePool;
54 use ResourcePool::Factory::Net::LDAP;
56 # revision number of server and program name
57 my $server_headURL;
58 my $server_revision;
59 my $server_status;
60 our $prg= basename($0);
61 our $verbose= 0;
63 my $db_module = "DBsqlite";
64 {
65 no strict "refs";
66 require ("GOSA/".$db_module.".pm");
67 ("GOSA/".$db_module)->import;
68 daemon_log("0 INFO: importing database module '$db_module'", 1);
69 }
71 my $modules_path = "/usr/lib/gosa-si/modules";
72 use lib "/usr/lib/gosa-si/modules";
74 our $global_kernel;
75 my ($foreground, $ping_timeout);
76 my ($server);
77 my ($gosa_server, $job_queue_timeout, $job_queue_loop_delay);
78 my ($messaging_db_loop_delay);
79 my ($procid, $pid);
80 my ($arp_fifo, $ldap_pool, $ldap_factory);
81 my ($xml);
82 my $sources_list;
83 my $max_clients;
84 my %repo_files=();
85 my $repo_path;
86 my %repo_dirs=();
88 # Variables declared in config file are always set to 'our'
89 our (%cfg_defaults, $log_file, $pid_file,
90 $server_ip, $server_port, $ClientPackages_key, $dns_lookup,
91 $arp_activ, $gosa_unit_tag,
92 $GosaPackages_key, $gosa_timeout,
93 $foreign_server_string, $server_domain, $ServerPackages_key, $foreign_servers_register_delay,
94 $wake_on_lan_passwd, $job_synchronization, $modified_jobs_loop_delay,
95 $arp_enabled, $arp_interface,
96 $opsi_enabled, $opsi_server, $opsi_admin, $opsi_password,
97 $new_systems_ou,
98 );
100 # additional variable which should be globaly accessable
101 our $server_address;
102 our $server_mac_address;
103 our $gosa_address;
104 our $no_arp;
105 our $forground;
106 our $cfg_file;
107 our ($ldap_uri, $ldap_base, $ldap_admin_dn, $ldap_admin_password, $ldap_server_dn, $ldap_version, $max_ldap_handle, $precreate_ldap_handle);
108 our ($mysql_username, $mysql_password, $mysql_database, $mysql_host);
109 our $known_modules;
110 our $root_uid;
111 our $adm_gid;
113 # if foreground is not null, script will be not forked to background
114 $foreground = 0 ;
116 # specifies the timeout seconds while checking the online status of a registrating client
117 $ping_timeout = 5;
119 $no_arp = 0;
120 my $packages_list_under_construction = "/tmp/packages_list_creation_in_progress";
121 my @packages_list_statements;
122 my $watch_for_new_jobs_in_progress = 0;
124 # holds all incoming decrypted messages
125 our $incoming_db;
126 our $incoming_tn = 'incoming';
127 my $incoming_file_name;
128 my @incoming_col_names = ("id INTEGER PRIMARY KEY",
129 "timestamp VARCHAR(14) DEFAULT 'none'",
130 "headertag VARCHAR(255) DEFAULT 'none'",
131 "targettag VARCHAR(255) DEFAULT 'none'",
132 "xmlmessage TEXT",
133 "module VARCHAR(255) DEFAULT 'none'",
134 "sessionid VARCHAR(255) DEFAULT '0'",
135 );
137 # holds all gosa jobs
138 our $job_db;
139 our $job_queue_tn = 'jobs';
140 my $job_queue_file_name;
141 my @job_queue_col_names = ("id INTEGER PRIMARY KEY",
142 "timestamp VARCHAR(14) DEFAULT 'none'",
143 "status VARCHAR(255) DEFAULT 'none'",
144 "result TEXT",
145 "progress VARCHAR(255) DEFAULT 'none'",
146 "headertag VARCHAR(255) DEFAULT 'none'",
147 "targettag VARCHAR(255) DEFAULT 'none'",
148 "xmlmessage TEXT",
149 "macaddress VARCHAR(17) DEFAULT 'none'",
150 "plainname VARCHAR(255) DEFAULT 'none'",
151 "siserver VARCHAR(255) DEFAULT 'none'",
152 "modified INTEGER DEFAULT '0'",
153 );
155 # holds all other gosa-si-server
156 our $known_server_db;
157 our $known_server_tn = "known_server";
158 my $known_server_file_name;
159 my @known_server_col_names = ("hostname VARCHAR(255)", "macaddress VARCHAR(17)", "status VARCHAR(255)", "hostkey VARCHAR(255)", "loaded_modules TEXT", "timestamp VARCHAR(14)");
161 # holds all registrated clients
162 our $known_clients_db;
163 our $known_clients_tn = "known_clients";
164 my $known_clients_file_name;
165 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)");
167 # holds all registered clients at a foreign server
168 our $foreign_clients_db;
169 our $foreign_clients_tn = "foreign_clients";
170 my $foreign_clients_file_name;
171 my @foreign_clients_col_names = ("hostname VARCHAR(255)", "macaddress VARCHAR(17)", "regserver VARCHAR(255)", "timestamp VARCHAR(14)");
173 # holds all logged in user at each client
174 our $login_users_db;
175 our $login_users_tn = "login_users";
176 my $login_users_file_name;
177 my @login_users_col_names = ("client VARCHAR(255)", "user VARCHAR(255)", "timestamp VARCHAR(14)", "regserver VARCHAR(255) DEFAULT 'localhost'");
179 # holds all fai server, the debian release and tag
180 our $fai_server_db;
181 our $fai_server_tn = "fai_server";
182 my $fai_server_file_name;
183 our @fai_server_col_names = ("timestamp VARCHAR(14)", "server VARCHAR(255)", "fai_release VARCHAR(255)", "sections VARCHAR(255)", "tag VARCHAR(255)");
185 our $fai_release_db;
186 our $fai_release_tn = "fai_release";
187 my $fai_release_file_name;
188 our @fai_release_col_names = ("timestamp VARCHAR(14)", "fai_release VARCHAR(255)", "class VARCHAR(255)", "type VARCHAR(255)", "state VARCHAR(255)");
190 # holds all packages available from different repositories
191 our $packages_list_db;
192 our $packages_list_tn = "packages_list";
193 my $packages_list_file_name;
194 our @packages_list_col_names = ("distribution VARCHAR(255)", "package VARCHAR(255)", "version VARCHAR(255)", "section VARCHAR(255)", "description TEXT", "template LONGBLOB", "timestamp VARCHAR(14)");
195 my $outdir = "/tmp/packages_list_db";
196 my $arch = "i386";
198 # holds all messages which should be delivered to a user
199 our $messaging_db;
200 our $messaging_tn = "messaging";
201 our @messaging_col_names = ("id INTEGER", "subject TEXT", "message_from VARCHAR(255)", "message_to VARCHAR(255)",
202 "flag VARCHAR(255)", "direction VARCHAR(255)", "delivery_time VARCHAR(255)", "message TEXT", "timestamp VARCHAR(14)" );
203 my $messaging_file_name;
205 # path to directory to store client install log files
206 our $client_fai_log_dir = "/var/log/fai";
208 # queue which stores taskes until one of the $max_children children are ready to process the task
209 #my @tasks = qw();
210 my @msgs_to_decrypt = qw();
211 my $max_children = 2;
214 # loop delay for job queue to look for opsi jobs
215 my $job_queue_opsi_delay = 10;
216 our $opsi_client;
217 our $opsi_url;
219 # Lifetime of logged in user information. If no update information comes after n seconds,
220 # the user is expeceted to be no longer logged in or the host is no longer running. Because
221 # of this, the user is deleted from login_users_db
222 our $logged_in_user_date_of_expiry = 600;
225 %cfg_defaults = (
226 "general" => {
227 "log-file" => [\$log_file, "/var/run/".$prg.".log"],
228 "pid-file" => [\$pid_file, "/var/run/".$prg.".pid"],
229 },
230 "server" => {
231 "ip" => [\$server_ip, "0.0.0.0"],
232 "port" => [\$server_port, "20081"],
233 "known-clients" => [\$known_clients_file_name, '/var/lib/gosa-si/clients.db' ],
234 "known-servers" => [\$known_server_file_name, '/var/lib/gosa-si/servers.db'],
235 "incoming" => [\$incoming_file_name, '/var/lib/gosa-si/incoming.db'],
236 "login-users" => [\$login_users_file_name, '/var/lib/gosa-si/users.db'],
237 "fai-server" => [\$fai_server_file_name, '/var/lib/gosa-si/fai_server.db'],
238 "fai-release" => [\$fai_release_file_name, '/var/lib/gosa-si/fai_release.db'],
239 "packages-list" => [\$packages_list_file_name, '/var/lib/gosa-si/packages.db'],
240 "messaging" => [\$messaging_file_name, '/var/lib/gosa-si/messaging.db'],
241 "foreign-clients" => [\$foreign_clients_file_name, '/var/lib/gosa-si/foreign_clients.db'],
242 "source-list" => [\$sources_list, '/etc/apt/sources.list'],
243 "repo-path" => [\$repo_path, '/srv/www/repository'],
244 "ldap-uri" => [\$ldap_uri, ""],
245 "ldap-base" => [\$ldap_base, ""],
246 "ldap-admin-dn" => [\$ldap_admin_dn, ""],
247 "ldap-admin-password" => [\$ldap_admin_password, ""],
248 "ldap-version" => [\$ldap_version, 3],
249 "max-ldap-handle" => [\$max_ldap_handle, 10],
250 "precreate-ldap-handle" => [\$precreate_ldap_handle, 5],
251 "gosa-unit-tag" => [\$gosa_unit_tag, ""],
252 "max-clients" => [\$max_clients, 10],
253 "wol-password" => [\$wake_on_lan_passwd, ""],
254 "mysql-username" => [\$mysql_username, "gosa_si"],
255 "mysql-password" => [\$mysql_password, ""],
256 "mysql-database" => [\$mysql_database, "gosa_si"],
257 "mysql-host" => [\$mysql_host, "127.0.0.1"],
258 },
259 "GOsaPackages" => {
260 "job-queue" => [\$job_queue_file_name, '/var/lib/gosa-si/jobs.db'],
261 "job-queue-loop-delay" => [\$job_queue_loop_delay, 3],
262 "messaging-db-loop-delay" => [\$messaging_db_loop_delay, 3],
263 "key" => [\$GosaPackages_key, "none"],
264 "new-systems-ou" => [\$new_systems_ou, 'ou=workstations,ou=systems'],
265 },
266 "ClientPackages" => {
267 "key" => [\$ClientPackages_key, "none"],
268 "user-date-of-expiry" => [\$logged_in_user_date_of_expiry, 600],
269 },
270 "ServerPackages"=> {
271 "address" => [\$foreign_server_string, ""],
272 "dns-lookup" => [\$dns_lookup, "true"],
273 "domain" => [\$server_domain, ""],
274 "key" => [\$ServerPackages_key, "none"],
275 "key-lifetime" => [\$foreign_servers_register_delay, 120],
276 "job-synchronization-enabled" => [\$job_synchronization, "true"],
277 "synchronization-loop" => [\$modified_jobs_loop_delay, 5],
278 },
279 "ArpHandler" => {
280 "enabled" => [\$arp_enabled, "true"],
281 "interface" => [\$arp_interface, "all"],
282 },
283 "Opsi" => {
284 "enabled" => [\$opsi_enabled, "false"],
285 "server" => [\$opsi_server, "localhost"],
286 "admin" => [\$opsi_admin, "opsi-admin"],
287 "password" => [\$opsi_password, "secret"],
288 },
290 );
293 #=== FUNCTION ================================================================
294 # NAME: usage
295 # PARAMETERS: nothing
296 # RETURNS: nothing
297 # DESCRIPTION: print out usage text to STDERR
298 #===============================================================================
299 sub usage {
300 print STDERR << "EOF" ;
301 usage: $prg [-hvf] [-c config]
303 -h : this (help) message
304 -c <file> : config file
305 -f : foreground, process will not be forked to background
306 -v : be verbose (multiple to increase verbosity)
307 -no-arp : starts $prg without connection to arp module
309 EOF
310 print "\n" ;
311 }
314 #=== FUNCTION ================================================================
315 # NAME: logging
316 # PARAMETERS: level - string - default 'info'
317 # msg - string -
318 # facility - string - default 'LOG_DAEMON'
319 # RETURNS: nothing
320 # DESCRIPTION: function for logging
321 #===============================================================================
322 sub daemon_log {
323 # log into log_file
324 my( $msg, $level ) = @_;
325 if(not defined $msg) { return }
326 if(not defined $level) { $level = 1 }
327 if($level > $verbose) { return }
328 if(defined $log_file){
329 my $open_log_fh = sysopen(LOG_HANDLE, $log_file, O_WRONLY | O_CREAT | O_APPEND , 0440);
330 if(not $open_log_fh) {
331 print STDERR "cannot open $log_file: $!";
332 return;
333 }
334 # check owner and group of log_file and update settings if necessary
335 my ($dev, $ino, $mode, $nlink, $uid, $gid, $rdev, $size, $atime, $mtime, $ctime, $blksize, $blocks) = stat($log_file);
336 if((not $uid eq $root_uid) || (not $gid eq $adm_gid)) {
337 chown($root_uid, $adm_gid, $log_file);
338 }
340 chomp($msg);
341 #$msg =~s/\n//g; # no newlines are allowed in log messages, this is important for later log parsing
342 if($level <= $verbose){
343 my ($seconds, $minutes, $hours, $monthday, $month,
344 $year, $weekday, $yearday, $sommertime) = localtime(time);
345 $hours = $hours < 10 ? $hours = "0".$hours : $hours;
346 $minutes = $minutes < 10 ? $minutes = "0".$minutes : $minutes;
347 $seconds = $seconds < 10 ? $seconds = "0".$seconds : $seconds;
348 my @monthnames = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
349 $month = $monthnames[$month];
350 $monthday = $monthday < 10 ? $monthday = "0".$monthday : $monthday;
351 $year+=1900;
352 my $name = $prg;
354 my $log_msg = "$month $monthday $hours:$minutes:$seconds $name $msg\n";
355 flock(LOG_HANDLE, LOCK_EX);
356 seek(LOG_HANDLE, 0, 2);
357 print LOG_HANDLE $log_msg;
358 flock(LOG_HANDLE, LOCK_UN);
359 if( $foreground ) {
360 print STDERR $log_msg;
361 }
362 }
363 close( LOG_HANDLE );
364 }
365 }
368 #=== FUNCTION ================================================================
369 # NAME: check_cmdline_param
370 # PARAMETERS: nothing
371 # RETURNS: nothing
372 # DESCRIPTION: validates commandline parameter
373 #===============================================================================
374 sub check_cmdline_param () {
375 my $err_config;
376 my $err_counter = 0;
377 if(not defined($cfg_file)) {
378 $cfg_file = "/etc/gosa-si/server.conf";
379 if(! -r $cfg_file) {
380 $err_config = "please specify a config file";
381 $err_counter += 1;
382 }
383 }
384 if( $err_counter > 0 ) {
385 &usage( "", 1 );
386 if( defined( $err_config)) { print STDERR "$err_config\n"}
387 print STDERR "\n";
388 exit( -1 );
389 }
390 }
393 #=== FUNCTION ================================================================
394 # NAME: check_pid
395 # PARAMETERS: nothing
396 # RETURNS: nothing
397 # DESCRIPTION: handels pid processing
398 #===============================================================================
399 sub check_pid {
400 $pid = -1;
401 # Check, if we are already running
402 if( open(LOCK_FILE, "<$pid_file") ) {
403 $pid = <LOCK_FILE>;
404 if( defined $pid ) {
405 chomp( $pid );
406 if( -f "/proc/$pid/stat" ) {
407 my($stat) = `cat /proc/$pid/stat` =~ m/$pid \((.+)\).*/;
408 if( $stat ) {
409 print STDERR "\nERROR: Already running!\n";
410 close( LOCK_FILE );
411 exit -1;
412 }
413 }
414 }
415 close( LOCK_FILE );
416 unlink( $pid_file );
417 }
419 # create a syslog msg if it is not to possible to open PID file
420 if (not sysopen(LOCK_FILE, $pid_file, O_WRONLY|O_CREAT|O_EXCL, 0644)) {
421 my($msg) = "Couldn't obtain lockfile '$pid_file' ";
422 if (open(LOCK_FILE, '<', $pid_file)
423 && ($pid = <LOCK_FILE>))
424 {
425 chomp($pid);
426 $msg .= "(PID $pid)\n";
427 } else {
428 $msg .= "(unable to read PID)\n";
429 }
430 if( ! ($foreground) ) {
431 openlog( $0, "cons,pid", "daemon" );
432 syslog( "warning", $msg );
433 closelog();
434 }
435 else {
436 print( STDERR " $msg " );
437 }
438 exit( -1 );
439 }
440 }
442 #=== FUNCTION ================================================================
443 # NAME: import_modules
444 # PARAMETERS: module_path - string - abs. path to the directory the modules
445 # are stored
446 # RETURNS: nothing
447 # DESCRIPTION: each file in module_path which ends with '.pm' and activation
448 # state is on is imported by "require 'file';"
449 #===============================================================================
450 sub import_modules {
451 daemon_log(" ", 1);
453 if (not -e $modules_path) {
454 daemon_log("0 ERROR: cannot find directory or directory is not readable: $modules_path", 1);
455 }
457 opendir (DIR, $modules_path) or die "ERROR while loading modules from directory $modules_path : $!\n";
459 my $ldap_handle = &get_ldap_handle;
460 while (defined (my $file = readdir (DIR))) {
461 if (not $file =~ /(\S*?).pm$/) {
462 next;
463 }
464 my $mod_name = $1;
466 # ArpHandler switch
467 if( $file =~ /ArpHandler.pm/ ) {
468 if( $arp_enabled eq "false" ) { next; }
469 }
471 eval { require $file; };
472 if ($@) {
473 daemon_log("0 ERROR: gosa-si-server could not load module $file", 1);
474 daemon_log("$@", 1);
475 exit;
476 } else {
477 my $info = eval($mod_name.'::get_module_info($ldap_handle)');
478 # Only load module if get_module_info() returns a non-null object
479 if( $info ) {
480 my ($input_address, $input_key, $event_hash) = @{$info};
481 $known_modules->{$mod_name} = $info;
482 daemon_log("0 INFO: module $mod_name loaded", 5);
483 }
484 }
485 }
486 &release_ldap_handle($ldap_handle);
487 close (DIR);
488 }
490 #=== FUNCTION ================================================================
491 # NAME: password_check
492 # PARAMETERS: nothing
493 # RETURNS: nothing
494 # DESCRIPTION: escalates an critical error if two modules exist which are avaialable by
495 # the same password
496 #===============================================================================
497 sub password_check {
498 my $passwd_hash = {};
499 while (my ($mod_name, $mod_info) = each %$known_modules) {
500 my $mod_passwd = @$mod_info[1];
501 if (not defined $mod_passwd) { next; }
502 if (not exists $passwd_hash->{$mod_passwd}) {
503 $passwd_hash->{$mod_passwd} = $mod_name;
505 # escalates critical error
506 } else {
507 &daemon_log("0 ERROR: two loaded modules do have the same password. Please modify the 'key'-parameter in config file");
508 &daemon_log("0 ERROR: module='$mod_name' and module='".$passwd_hash->{$mod_passwd}."'");
509 exit( -1 );
510 }
511 }
513 }
516 #=== FUNCTION ================================================================
517 # NAME: sig_int_handler
518 # PARAMETERS: signal - string - signal arose from system
519 # RETURNS: nothing
520 # DESCRIPTION: handels tasks to be done befor signal becomes active
521 #===============================================================================
522 sub sig_int_handler {
523 my ($signal) = @_;
525 # if (defined($ldap_handle)) {
526 # $ldap_handle->disconnect;
527 # }
528 # TODO alle verbliebenden ldap verbindungen aus allen heaps beenden
531 daemon_log("shutting down gosa-si-server", 1);
532 system("kill `ps -C gosa-si-server -o pid=`");
533 }
534 $SIG{INT} = \&sig_int_handler;
537 sub check_key_and_xml_validity {
538 my ($crypted_msg, $module_key, $session_id) = @_;
539 my $msg;
540 my $msg_hash;
541 my $error_string;
542 eval{
543 $msg = &decrypt_msg($crypted_msg, $module_key);
545 if ($msg =~ /<xml>/i){
546 $msg =~ s/\s+/ /g; # just for better daemon_log
547 daemon_log("$session_id DEBUG: decrypted_msg: \n$msg", 9);
548 $msg_hash = $xml->XMLin($msg, ForceArray=>1);
550 ##############
551 # check header
552 if( not exists $msg_hash->{'header'} ) { die "no header specified"; }
553 my $header_l = $msg_hash->{'header'};
554 if( (1 > @{$header_l}) || ( ( 'HASH' eq ref @{$header_l}[0]) && (1 > keys %{@{$header_l}[0]}) ) ) { die 'empty header tag'; }
555 if( 1 < @{$header_l} ) { die 'more than one header specified'; }
556 my $header = @{$header_l}[0];
557 if( 0 == length $header) { die 'empty string in header tag'; }
559 ##############
560 # check source
561 if( not exists $msg_hash->{'source'} ) { die "no source specified"; }
562 my $source_l = $msg_hash->{'source'};
563 if( (1 > @{$source_l}) || ( ( 'HASH' eq ref @{$source_l}[0]) && (1 > keys %{@{$source_l}[0]}) ) ) { die 'empty source tag'; }
564 if( 1 < @{$source_l} ) { die 'more than one source specified'; }
565 my $source = @{$source_l}[0];
566 if( 0 == length $source) { die 'source error'; }
568 ##############
569 # check target
570 if( not exists $msg_hash->{'target'} ) { die "no target specified"; }
571 my $target_l = $msg_hash->{'target'};
572 if( (1 > @{$target_l}) || ( ('HASH' eq ref @{$target_l}[0]) && (1 > keys %{@{$target_l}[0]}) ) ) { die 'empty target tag'; }
573 }
574 };
575 if($@) {
576 daemon_log("$session_id ERROR: do not understand the message: $@", 1);
577 $msg = undef;
578 $msg_hash = undef;
579 }
581 return ($msg, $msg_hash);
582 }
585 sub check_outgoing_xml_validity {
586 my ($msg, $session_id) = @_;
588 my $msg_hash;
589 eval{
590 $msg_hash = $xml->XMLin($msg, ForceArray=>1);
592 ##############
593 # check header
594 my $header_l = $msg_hash->{'header'};
595 if( 1 != @{$header_l} ) {
596 die 'no or more than one headers specified';
597 }
598 my $header = @{$header_l}[0];
599 if( 0 == length $header) {
600 die 'header has length 0';
601 }
603 ##############
604 # check source
605 my $source_l = $msg_hash->{'source'};
606 if( 1 != @{$source_l} ) {
607 die 'no or more than 1 sources specified';
608 }
609 my $source = @{$source_l}[0];
610 if( 0 == length $source) {
611 die 'source has length 0';
612 }
614 # Check if source contains hostname instead of ip address
615 if($source =~ /^[a-z][a-z0-9\.]+:\d+$/i) {
616 my ($hostname,$port) = split(/:/, $source);
617 my $ip_address = inet_ntoa(scalar gethostbyname($hostname));
618 if(defined($ip_address) && $ip_address =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/ && $port =~ /^\d+$/) {
619 # Write ip address to $source variable
620 $source = "$ip_address:$port";
621 }
622 }
623 unless( $source =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+$/ ||
624 $source =~ /^GOSA$/i) {
625 die "source '$source' is neither a complete ip-address with port nor 'GOSA'";
626 }
628 ##############
629 # check target
630 my $target_l = $msg_hash->{'target'};
631 if( 0 == @{$target_l} ) {
632 die "no targets specified";
633 }
634 foreach my $target (@$target_l) {
635 if( 0 == length $target) {
636 die "target has length 0";
637 }
638 unless( $target =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+$/ ||
639 $target =~ /^GOSA$/i ||
640 $target =~ /^\*$/ ||
641 $target =~ /KNOWN_SERVER/i ||
642 $target =~ /JOBDB/i ||
643 $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 ){
644 die "target '$target' is not a complete ip-address with port or a valid target name or a mac-address";
645 }
646 }
647 };
648 if($@) {
649 daemon_log("$session_id ERROR: outgoing msg is not gosa-si envelope conform: $@", 1);
650 daemon_log("$@ ".(defined($msg) && length($msg)>0)?$msg:"Empty Message", 1);
651 $msg_hash = undef;
652 }
654 return ($msg_hash);
655 }
658 sub input_from_known_server {
659 my ($input, $remote_ip, $session_id) = @_ ;
660 my ($msg, $msg_hash, $module);
662 my $sql_statement= "SELECT * FROM known_server";
663 my $query_res = $known_server_db->select_dbentry( $sql_statement );
665 while( my ($hit_num, $hit) = each %{ $query_res } ) {
666 my $host_name = $hit->{hostname};
667 if( not $host_name =~ "^$remote_ip") {
668 next;
669 }
670 my $host_key = $hit->{hostkey};
671 daemon_log("$session_id DEBUG: input_from_known_server: host_name: $host_name", 7);
672 daemon_log("$session_id DEBUG: input_from_known_server: host_key: $host_key", 7);
674 # check if module can open msg envelope with module key
675 my ($tmp_msg, $tmp_msg_hash) = &check_key_and_xml_validity($input, $host_key, $session_id);
676 if( (!$tmp_msg) || (!$tmp_msg_hash) ) {
677 daemon_log("$session_id DEBUG: input_from_known_server: deciphering raise error", 7);
678 daemon_log("$@", 8);
679 next;
680 }
681 else {
682 $msg = $tmp_msg;
683 $msg_hash = $tmp_msg_hash;
684 $module = "ServerPackages";
685 daemon_log("$session_id DEBUG: check_key_and_xml_validity... ok", 7);
686 last;
687 }
688 }
690 if( (!$msg) || (!$msg_hash) || (!$module) ) {
691 daemon_log("$session_id DEBUG: Incoming message is not from a known server", 7);
692 }
694 return ($msg, $msg_hash, $module);
695 }
698 sub input_from_known_client {
699 my ($input, $remote_ip, $session_id) = @_ ;
700 my ($msg, $msg_hash, $module);
702 my $sql_statement= "SELECT * FROM known_clients";
703 my $query_res = $known_clients_db->select_dbentry( $sql_statement );
704 while( my ($hit_num, $hit) = each %{ $query_res } ) {
705 my $host_name = $hit->{hostname};
706 if( not $host_name =~ /^$remote_ip:\d*$/) {
707 next;
708 }
709 my $host_key = $hit->{hostkey};
710 &daemon_log("$session_id DEBUG: input_from_known_client: host_name: $host_name", 7);
711 &daemon_log("$session_id DEBUG: input_from_known_client: host_key: $host_key", 7);
713 # check if module can open msg envelope with module key
714 ($msg, $msg_hash) = &check_key_and_xml_validity($input, $host_key, $session_id);
716 if( (!$msg) || (!$msg_hash) ) {
717 &daemon_log("$session_id DEGUG: input_from_known_client: deciphering raise error", 7);
718 &daemon_log("$@", 8);
719 next;
720 }
721 else {
722 $module = "ClientPackages";
723 daemon_log("$session_id DEBUG: check_key_and_xml_validity... ok", 7);
724 last;
725 }
726 }
728 if( (!$msg) || (!$msg_hash) || (!$module) ) {
729 &daemon_log("$session_id DEBUG: Incoming message is not from a known client", 7);
730 }
732 return ($msg, $msg_hash, $module);
733 }
736 sub input_from_unknown_host {
737 no strict "refs";
738 my ($input, $session_id) = @_ ;
739 my ($msg, $msg_hash, $module);
740 my $error_string;
742 my %act_modules = %$known_modules;
744 while( my ($mod, $info) = each(%act_modules)) {
746 # check a key exists for this module
747 my $module_key = ${$mod."_key"};
748 if( not defined $module_key ) {
749 if( $mod eq 'ArpHandler' ) {
750 next;
751 }
752 daemon_log("$session_id ERROR: no key specified in config file for $mod", 1);
753 next;
754 }
755 daemon_log("$session_id DEBUG: $mod: $module_key", 7);
757 # check if module can open msg envelope with module key
758 ($msg, $msg_hash) = &check_key_and_xml_validity($input, $module_key, $session_id);
759 if( (not defined $msg) || (not defined $msg_hash) ) {
760 next;
761 } else {
762 $module = $mod;
763 daemon_log("$session_id DEBUG: check_key_and_xml_validity... ok", 7);
764 last;
765 }
766 }
768 if( (!$msg) || (!$msg_hash) || (!$module)) {
769 daemon_log("$session_id DEBUG: Incoming message is not from an unknown host", 7);
770 }
772 return ($msg, $msg_hash, $module);
773 }
776 sub create_ciphering {
777 my ($passwd) = @_;
778 if((!defined($passwd)) || length($passwd)==0) {
779 $passwd = "";
780 }
781 $passwd = substr(md5_hex("$passwd") x 32, 0, 32);
782 my $iv = substr(md5_hex('GONICUS GmbH'),0, 16);
783 my $my_cipher = Crypt::Rijndael->new($passwd , Crypt::Rijndael::MODE_CBC());
784 $my_cipher->set_iv($iv);
785 return $my_cipher;
786 }
789 sub encrypt_msg {
790 my ($msg, $key) = @_;
791 my $my_cipher = &create_ciphering($key);
792 my $len;
793 {
794 use bytes;
795 $len= 16-length($msg)%16;
796 }
797 $msg = "\0"x($len).$msg;
798 $msg = $my_cipher->encrypt($msg);
799 chomp($msg = &encode_base64($msg));
800 # there are no newlines allowed inside msg
801 $msg=~ s/\n//g;
802 return $msg;
803 }
806 sub decrypt_msg {
808 my ($msg, $key) = @_ ;
809 $msg = &decode_base64($msg);
810 my $my_cipher = &create_ciphering($key);
811 $msg = $my_cipher->decrypt($msg);
812 $msg =~ s/\0*//g;
813 return $msg;
814 }
817 sub get_encrypt_key {
818 my ($target) = @_ ;
819 my $encrypt_key;
820 my $error = 0;
822 # target can be in known_server
823 if( not defined $encrypt_key ) {
824 my $sql_statement= "SELECT * FROM known_server WHERE hostname='$target'";
825 my $query_res = $known_server_db->select_dbentry( $sql_statement );
826 while( my ($hit_num, $hit) = each %{ $query_res } ) {
827 my $host_name = $hit->{hostname};
828 if( $host_name ne $target ) {
829 next;
830 }
831 $encrypt_key = $hit->{hostkey};
832 last;
833 }
834 }
836 # target can be in known_client
837 if( not defined $encrypt_key ) {
838 my $sql_statement= "SELECT * FROM known_clients WHERE hostname='$target'";
839 my $query_res = $known_clients_db->select_dbentry( $sql_statement );
840 while( my ($hit_num, $hit) = each %{ $query_res } ) {
841 my $host_name = $hit->{hostname};
842 if( $host_name ne $target ) {
843 next;
844 }
845 $encrypt_key = $hit->{hostkey};
846 last;
847 }
848 }
850 return $encrypt_key;
851 }
854 #=== FUNCTION ================================================================
855 # NAME: open_socket
856 # PARAMETERS: PeerAddr string something like 192.168.1.1 or 192.168.1.1:10000
857 # [PeerPort] string necessary if port not appended by PeerAddr
858 # RETURNS: socket IO::Socket::INET
859 # DESCRIPTION: open a socket to PeerAddr
860 #===============================================================================
861 sub open_socket {
862 my ($PeerAddr, $PeerPort) = @_ ;
863 if(defined($PeerPort)){
864 $PeerAddr = $PeerAddr.":".$PeerPort;
865 }
866 my $socket;
867 $socket = new IO::Socket::INET(PeerAddr => $PeerAddr,
868 Porto => "tcp",
869 Type => SOCK_STREAM,
870 Timeout => 5,
871 );
872 if(not defined $socket) {
873 return;
874 }
875 # &daemon_log("DEBUG: open_socket: $PeerAddr", 7);
876 return $socket;
877 }
880 sub send_msg_to_target {
881 my ($msg, $address, $encrypt_key, $msg_header, $session_id) = @_ ;
882 my $error = 0;
883 my $header;
884 my $timestamp = &get_time();
885 my $new_status;
886 my $act_status;
887 my ($sql_statement, $res);
889 if( $msg_header ) {
890 $header = "'$msg_header'-";
891 } else {
892 $header = "";
893 }
895 # Patch the source ip
896 if($msg =~ /<source>0\.0\.0\.0:\d*?<\/source>/) {
897 my $remote_ip = &get_local_ip_for_remote_ip(sprintf("%s", $address =~ /^([0-9\.]*?):.*$/));
898 $msg =~ s/<source>(0\.0\.0\.0):(\d*?)<\/source>/<source>$remote_ip:$2<\/source>/s;
899 }
901 # encrypt xml msg
902 my $crypted_msg = &encrypt_msg($msg, $encrypt_key);
904 # opensocket
905 my $socket = &open_socket($address);
906 if( !$socket ) {
907 daemon_log("$session_id WARNING: cannot send ".$header."msg to $address , host not reachable", 3);
908 $error++;
909 }
911 if( $error == 0 ) {
912 # send xml msg
913 print $socket $crypted_msg."\n";
915 daemon_log("$session_id INFO: send ".$header."msg to $address", 5);
916 daemon_log("$session_id DEBUG: message:\n$msg", 9);
918 }
920 # close socket in any case
921 if( $socket ) {
922 close $socket;
923 }
925 if( $error > 0 ) { $new_status = "down"; }
926 else { $new_status = $msg_header; }
929 # known_clients
930 $sql_statement = "SELECT * FROM $known_clients_tn WHERE hostname='$address'";
931 $res = $known_clients_db->select_dbentry($sql_statement);
932 if( keys(%$res) == 1) {
933 $act_status = exists $res->{1}->{'status'} ? $res->{1}->{'status'} : "";
934 if ($act_status eq "down" && $new_status eq "down") {
935 $sql_statement = "DELETE FROM known_clients WHERE hostname='$address'";
936 $res = $known_clients_db->del_dbentry($sql_statement);
937 daemon_log("$session_id WARNING: failed 2x to send msg to host '$address', delete host from known_clients", 3);
938 } else {
939 $sql_statement = "UPDATE known_clients SET status='$new_status', timestamp='$timestamp' WHERE hostname='$address'";
940 $res = $known_clients_db->update_dbentry($sql_statement);
941 if($new_status eq "down"){
942 daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
943 } else {
944 daemon_log("$session_id INFO: set '$address' from status '$act_status' to '$new_status'", 5);
945 }
946 }
947 }
949 # known_server
950 $sql_statement = "SELECT * FROM $known_server_tn WHERE hostname='$address'";
951 $res = $known_server_db->select_dbentry($sql_statement);
952 if( keys(%$res) == 1) {
953 $act_status = exists $res->{1}->{'status'} ? $res->{1}->{'status'} : "";
954 if ($act_status eq "down" && $new_status eq "down") {
955 $sql_statement = "DELETE FROM known_server WHERE hostname='$address'";
956 $res = $known_server_db->del_dbentry($sql_statement);
957 daemon_log("$session_id WARNING: failed 2x to send a message to host '$address', delete host from known_server", 3);
958 }
959 else {
960 $sql_statement = "UPDATE known_server SET status='$new_status', timestamp='$timestamp' WHERE hostname='$address'";
961 $res = $known_server_db->update_dbentry($sql_statement);
962 if($new_status eq "down"){
963 daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
964 } else {
965 daemon_log("$session_id INFO: set '$address' from status '$act_status' to '$new_status'", 5);
966 }
967 }
968 }
969 return $error;
970 }
973 sub update_jobdb_status_for_send_msgs {
974 my ($session_id, $answer, $error) = @_;
975 &daemon_log("$session_id DEBUG: try to update job status", 7);
976 if( $answer =~ /<jobdb_id>(\d+)<\/jobdb_id>/ ) {
977 my $jobdb_id = $1;
979 $answer =~ /<header>(.*)<\/header>/;
980 my $job_header = $1;
982 $answer =~ /<target>(.*)<\/target>/;
983 my $job_target = $1;
985 # Sending msg failed
986 if( $error ) {
988 # Set jobs to done, jobs do not need to deliver their message in any case
989 if (($job_header eq "trigger_action_localboot")
990 ||($job_header eq "trigger_action_lock")
991 ||($job_header eq "trigger_action_halt")
992 ) {
993 my $sql_statement = "UPDATE $job_queue_tn SET status='done' WHERE id=$jobdb_id";
994 &daemon_log("$session_id DEBUG: $sql_statement", 7);
995 my $res = $job_db->update_dbentry($sql_statement);
997 # Reactivate jobs, jobs need to deliver their message
998 } elsif (($job_header eq "trigger_action_activate")
999 ||($job_header eq "trigger_action_update")
1000 ||($job_header eq "trigger_action_reinstall")
1001 ||($job_header eq "trigger_activate_new")
1002 ) {
1003 &reactivate_job_with_delay($session_id, $job_target, $job_header, 30 );
1005 # For all other messages
1006 } else {
1007 my $sql_statement = "UPDATE $job_queue_tn ".
1008 "SET status='error', result='can not deliver msg, please consult log file' ".
1009 "WHERE id=$jobdb_id";
1010 &daemon_log("$session_id DEBUG: $sql_statement", 7);
1011 my $res = $job_db->update_dbentry($sql_statement);
1012 }
1014 # Sending msg was successful
1015 } else {
1016 # Set jobs localboot, lock, activate, halt, reboot and wake to done
1017 # jobs reinstall, update, inst_update do themself setting to done
1018 if (($job_header eq "trigger_action_localboot")
1019 ||($job_header eq "trigger_action_lock")
1020 ||($job_header eq "trigger_action_activate")
1021 ||($job_header eq "trigger_action_halt")
1022 ||($job_header eq "trigger_action_reboot")
1023 ||($job_header eq "trigger_action_wake")
1024 ||($job_header eq "trigger_wake")
1025 ) {
1027 my $sql_statement = "UPDATE $job_queue_tn ".
1028 "SET status='done' ".
1029 "WHERE id=$jobdb_id AND status='processed'";
1030 &daemon_log("$session_id DEBUG: $sql_statement", 7);
1031 my $res = $job_db->update_dbentry($sql_statement);
1032 } else {
1033 &daemon_log("$session_id DEBUG: sending message succeed but cannot update job status.", 7);
1034 }
1035 }
1036 } else {
1037 &daemon_log("$session_id DEBUG: cannot update job status, msg has no jobdb_id-tag: $answer", 7);
1038 }
1039 }
1041 sub reactivate_job_with_delay {
1042 my ($session_id, $target, $header, $delay) = @_ ;
1043 # 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
1045 if (not defined $delay) { $delay = 30 } ;
1046 my $delay_timestamp = &calc_timestamp(&get_time(), "plus", $delay);
1048 my $sql = "UPDATE $job_queue_tn Set timestamp='$delay_timestamp', status='waiting' WHERE (macaddress LIKE 'target' AND headertag='$header')";
1049 my $res = $job_db->update_dbentry($sql);
1050 daemon_log("$session_id INFO: '$header'-job will be reactivated at '$delay_timestamp' ".
1051 "cause client '$target' is currently not available", 5);
1052 daemon_log("$session_id $sql", 7);
1053 return;
1054 }
1057 sub sig_handler {
1058 my ($kernel, $signal) = @_[KERNEL, ARG0] ;
1059 daemon_log("0 INFO got signal '$signal'", 1);
1060 $kernel->sig_handled();
1061 return;
1062 }
1065 sub msg_to_decrypt {
1066 my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];
1067 my $session_id = $session->ID;
1068 my ($msg, $msg_hash, $module);
1069 my $error = 0;
1071 # fetch new msg out of @msgs_to_decrypt
1072 my $tmp_next_msg = shift @msgs_to_decrypt;
1073 my ($next_msg, $msg_source) = split(/;/, $tmp_next_msg);
1075 # msg is from a new client or gosa
1076 ($msg, $msg_hash, $module) = &input_from_unknown_host($next_msg, $session_id);
1078 # msg is from a gosa-si-server
1079 if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1080 ($msg, $msg_hash, $module) = &input_from_known_server($next_msg, $heap->{'remote_ip'}, $session_id);
1081 }
1082 # msg is from a gosa-si-client
1083 if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1084 ($msg, $msg_hash, $module) = &input_from_known_client($next_msg, $heap->{'remote_ip'}, $session_id);
1085 }
1086 # an error occurred
1087 if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1088 # if an incoming msg could not be decrypted (maybe a wrong key), send client a ping. If the client
1089 # could not understand a msg from its server the client cause a re-registering process
1090 my $remote_ip = $heap->{'remote_ip'};
1091 my $remote_port = $heap->{'remote_port'};
1092 my $ping_msg = "<xml> <header>gosa_ping</header> <source>$server_address</source><target>$msg_source</target></xml>";
1093 my ($test_error, $test_error_string) = &send_msg_to_target($ping_msg, "$msg_source", "dummy-key", "gosa_ping", $session_id);
1095 daemon_log("$session_id WARNING cannot understand incoming msg, send 'ping'-msg to all host with ip '".$heap->{remote_ip}.
1096 "' to cause a re-registering of the client if necessary", 3);
1097 $error++;
1098 }
1101 my $header;
1102 my $target;
1103 my $source;
1104 my $done = 0;
1105 my $sql;
1106 my $res;
1108 # check whether this message should be processed here
1109 if ($error == 0) {
1110 $header = @{$msg_hash->{'header'}}[0];
1111 $target = @{$msg_hash->{'target'}}[0];
1112 $source = @{$msg_hash->{'source'}}[0];
1113 my $not_found_in_known_clients_db = 0;
1114 my $not_found_in_known_server_db = 0;
1115 my $not_found_in_foreign_clients_db = 0;
1116 my $local_address;
1117 my $local_mac;
1118 my ($target_ip, $target_port) = split(':', $target);
1120 # Determine the local ip address if target is an ip address
1121 if ($target =~ /^\d+\.\d+\.\d+\.\d+:\d+$/) {
1122 $local_address = &get_local_ip_for_remote_ip($target_ip).":$server_port";
1123 } else {
1124 $local_address = $server_address;
1125 }
1127 # Determine the local mac address if target is a mac address
1128 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) {
1129 my $loc_ip = &get_local_ip_for_remote_ip($heap->{'remote_ip'});
1130 my $network_interface= &get_interface_for_ip($loc_ip);
1131 $local_mac = &get_mac_for_interface($network_interface);
1132 } else {
1133 $local_mac = $server_mac_address;
1134 }
1136 # target and source is equal to GOSA -> process here
1137 if (not $done) {
1138 if ($target eq "GOSA" && $source eq "GOSA") {
1139 $done = 1;
1140 &daemon_log("$session_id DEBUG: target and source is 'GOSA' -> process here", 7);
1141 }
1142 }
1144 # target is own address without forward_to_gosa-tag -> process here
1145 if (not $done) {
1146 #if ((($target eq $local_address) || ($target eq $local_mac) ) && (not exists $msg_hash->{'forward_to_gosa'})) {
1147 if (($target eq $local_address) && (not exists $msg_hash->{'forward_to_gosa'})) {
1148 $done = 1;
1149 if ($source eq "GOSA") {
1150 $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1151 }
1152 &daemon_log("$session_id DEBUG: target is own address without forward_to_gosa-tag -> process here", 7);
1153 }
1154 }
1156 # target is a client address in known_clients -> process here
1157 if (not $done) {
1158 $sql = "SELECT * FROM $known_clients_tn WHERE (hostname='$target' OR macaddress LIKE '$target')";
1159 $res = $known_clients_db->select_dbentry($sql);
1160 if (keys(%$res) > 0) {
1161 $done = 1;
1162 my $hostname = $res->{1}->{'hostname'};
1163 $msg =~ s/<target>$target<\/target>/<target>$hostname<\/target>/;
1164 my $local_address = &get_local_ip_for_remote_ip($target_ip).":$server_port";
1165 if ($source eq "GOSA") {
1166 $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1167 }
1168 &daemon_log("$session_id DEBUG: target is a client address in known_clients -> process here", 7);
1170 } else {
1171 $not_found_in_known_clients_db = 1;
1172 }
1173 }
1175 # target ist own address with forward_to_gosa-tag not pointing to myself -> process here
1176 if (not $done) {
1177 my $forward_to_gosa = @{$msg_hash->{'forward_to_gosa'}}[0];
1178 my $gosa_at;
1179 my $gosa_session_id;
1180 if (($target eq $local_address) && (defined $forward_to_gosa)){
1181 my ($gosa_at, $gosa_session_id) = split(/,/, $forward_to_gosa);
1182 if ($gosa_at ne $local_address) {
1183 $done = 1;
1184 &daemon_log("$session_id DEBUG: target is own address with forward_to_gosa-tag not pointing to myself -> process here", 7);
1185 }
1186 }
1187 }
1189 # if message should be processed here -> add message to incoming_db
1190 if ($done) {
1191 # if a job or a gosa message comes from a foreign server, fake module to GosaPackages
1192 # so gosa-si-server knows how to process this kind of messages
1193 if ($header =~ /^gosa_/ || $header =~ /^job_/) {
1194 $module = "GosaPackages";
1195 }
1197 my $res = $incoming_db->add_dbentry( {table=>$incoming_tn,
1198 primkey=>[],
1199 headertag=>$header,
1200 targettag=>$target,
1201 xmlmessage=>&encode_base64($msg),
1202 timestamp=>&get_time,
1203 module=>$module,
1204 sessionid=>$session_id,
1205 } );
1207 }
1209 # target is own address with forward_to_gosa-tag pointing at myself -> forward to gosa
1210 if (not $done) {
1211 my $forward_to_gosa = @{$msg_hash->{'forward_to_gosa'}}[0];
1212 my $gosa_at;
1213 my $gosa_session_id;
1214 if (($target eq $local_address) && (defined $forward_to_gosa)){
1215 my ($gosa_at, $gosa_session_id) = split(/,/, $forward_to_gosa);
1216 if ($gosa_at eq $local_address) {
1217 my $session_reference = $kernel->ID_id_to_session($gosa_session_id);
1218 if( defined $session_reference ) {
1219 $heap = $session_reference->get_heap();
1220 }
1221 if(exists $heap->{'client'}) {
1222 $msg = &encrypt_msg($msg, $GosaPackages_key);
1223 $heap->{'client'}->put($msg);
1224 &daemon_log("$session_id INFO: incoming '$header' message forwarded to GOsa", 5);
1225 }
1226 $done = 1;
1227 &daemon_log("$session_id DEBUG: target is own address with forward_to_gosa-tag pointing at myself -> forward to gosa", 7);
1228 }
1229 }
1231 }
1233 # target is a client address in foreign_clients -> forward to registration server
1234 if (not $done) {
1235 $sql = "SELECT * FROM $foreign_clients_tn WHERE (hostname='$target' OR macaddress LIKE '$target')";
1236 $res = $foreign_clients_db->select_dbentry($sql);
1237 if (keys(%$res) > 0) {
1238 my $hostname = $res->{1}->{'hostname'};
1239 my ($host_ip, $host_port) = split(/:/, $hostname);
1240 my $local_address = &get_local_ip_for_remote_ip($host_ip).":$server_port";
1241 my $regserver = $res->{1}->{'regserver'};
1242 my $sql = "SELECT * FROM $known_server_tn WHERE hostname='$regserver'";
1243 my $res = $known_server_db->select_dbentry($sql);
1244 if (keys(%$res) > 0) {
1245 my $regserver_key = $res->{1}->{'hostkey'};
1246 $msg =~ s/<source>GOSA<\/source>/<source>$local_address<\/source>/;
1247 $msg =~ s/<target>$target<\/target>/<target>$hostname<\/target>/;
1248 if ($source eq "GOSA") {
1249 $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1250 }
1251 my $error= &send_msg_to_target($msg, $regserver, $regserver_key, $header, $session_id);
1252 if ($error) {
1253 &daemon_log("$session_id ERROR: some problems (error=$error) occurred while trying to send msg to registration server: $msg", 1);
1254 }
1255 }
1256 $done = 1;
1257 &daemon_log("$session_id DEBUG: target is a client address in foreign_clients -> forward to registration server", 7);
1258 } else {
1259 $not_found_in_foreign_clients_db = 1;
1260 }
1261 }
1263 # target is a server address -> forward to server
1264 if (not $done) {
1265 $sql = "SELECT * FROM $known_server_tn WHERE (hostname='$target' OR macaddress LIKE '$target')";
1266 $res = $known_server_db->select_dbentry($sql);
1267 if (keys(%$res) > 0) {
1268 my $hostkey = $res->{1}->{'hostkey'};
1270 if ($source eq "GOSA") {
1271 $msg =~ s/<source>GOSA<\/source>/<source>$local_address<\/source>/;
1272 $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1274 }
1276 &send_msg_to_target($msg, $target, $hostkey, $header, $session_id);
1277 $done = 1;
1278 &daemon_log("$session_id DEBUG: target is a server address -> forward to server", 7);
1279 } else {
1280 $not_found_in_known_server_db = 1;
1281 }
1282 }
1285 # target is not in foreign_clients_db, known_server_db or known_clients_db, maybe it is a complete new one -> process here
1286 if ( $not_found_in_foreign_clients_db
1287 && $not_found_in_known_server_db
1288 && $not_found_in_known_clients_db) {
1289 &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);
1290 if ($header =~ /^gosa_/ || $header =~ /^job_/) {
1291 $module = "GosaPackages";
1292 }
1293 my $res = $incoming_db->add_dbentry( {table=>$incoming_tn,
1294 primkey=>[],
1295 headertag=>$header,
1296 targettag=>$target,
1297 xmlmessage=>&encode_base64($msg),
1298 timestamp=>&get_time,
1299 module=>$module,
1300 sessionid=>$session_id,
1301 } );
1302 $done = 1;
1303 }
1306 if (not $done) {
1307 daemon_log("$session_id ERROR: do not know what to do with this message: $msg", 1);
1308 if ($source eq "GOSA") {
1309 my %data = ('error_msg' => &encode_base64($msg), 'error_string' => "Do not know what to do with this message!");
1310 my $error_msg = &build_msg("error", $local_address, "GOSA", \%data );
1312 my $session_reference = $kernel->ID_id_to_session($session_id);
1313 if( defined $session_reference ) {
1314 $heap = $session_reference->get_heap();
1315 }
1316 if(exists $heap->{'client'}) {
1317 $error_msg = &encrypt_msg($error_msg, $GosaPackages_key);
1318 $heap->{'client'}->put($error_msg);
1319 }
1320 }
1321 }
1323 }
1325 return;
1326 }
1329 sub next_task {
1330 my ($session, $heap, $task, $ldap_handle) = @_[SESSION, HEAP, ARG0, ARG1];
1331 my $running_task = POE::Wheel::Run->new(
1332 Program => sub { process_task($session, $heap, $task, $ldap_handle) },
1333 StdioFilter => POE::Filter::Reference->new(),
1334 StdoutEvent => "task_result",
1335 StderrEvent => "task_debug",
1336 CloseEvent => "task_done",
1337 );
1338 $heap->{task}->{ $running_task->ID } = $running_task;
1339 $heap->{ldap_handle}->{$running_task->ID} = $ldap_handle;
1340 }
1342 sub handle_task_result {
1343 my ($kernel, $heap, $result) = @_[KERNEL, HEAP, ARG0];
1344 my $client_answer = $result->{'answer'};
1345 if( $client_answer =~ s/session_id=(\d+)$// ) {
1346 my $session_id = $1;
1347 if( defined $session_id ) {
1348 my $session_reference = $kernel->ID_id_to_session($session_id);
1349 if( defined $session_reference ) {
1350 $heap = $session_reference->get_heap();
1351 }
1352 }
1354 if(exists $heap->{'client'}) {
1355 $heap->{'client'}->put($client_answer);
1356 }
1357 }
1358 $kernel->sig(CHLD => "child_reap");
1359 }
1361 sub handle_task_debug {
1362 my $result = $_[ARG0];
1363 print STDERR "$result\n";
1364 }
1366 sub handle_task_done {
1367 my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
1368 delete $heap->{task}->{$task_id};
1369 if (exists $heap->{ldap_handle}->{$task_id}) {
1370 &release_ldap_handle($heap->{ldap_handle}->{$task_id});
1371 }
1372 }
1374 sub process_task {
1375 no strict "refs";
1376 #CHECK: Not @_[...]?
1377 my ($session, $heap, $task, $ldap_handle) = @_;
1378 my $error = 0;
1379 my $answer_l;
1380 my ($answer_header, @answer_target_l, $answer_source);
1381 my $client_answer = "";
1383 # prepare all variables needed to process message
1384 #my $msg = $task->{'xmlmessage'};
1385 my $msg = &decode_base64($task->{'xmlmessage'});
1386 my $incoming_id = $task->{'id'};
1387 my $module = $task->{'module'};
1388 my $header = $task->{'headertag'};
1389 my $session_id = $task->{'sessionid'};
1390 my $msg_hash;
1391 eval {
1392 $msg_hash = $xml->XMLin($msg, ForceArray=>1);
1393 };
1394 daemon_log("ERROR: XML failure '$@'") if ($@);
1395 my $source = @{$msg_hash->{'source'}}[0];
1397 # set timestamp of incoming client uptodate, so client will not
1398 # be deleted from known_clients because of expiration
1399 my $cur_time = &get_time();
1400 my $sql = "UPDATE $known_clients_tn SET timestamp='$cur_time' WHERE hostname='$source'";
1401 my $res = $known_clients_db->exec_statement($sql);
1403 ######################
1404 # process incoming msg
1405 if( $error == 0) {
1406 daemon_log("$session_id INFO: Incoming msg (session_id=$session_id) with header '".@{$msg_hash->{'header'}}[0]."'", 5);
1407 daemon_log("$session_id DEBUG: Processing module ".$module, 7);
1408 $answer_l = &{ $module."::process_incoming_msg" }($msg, $msg_hash, $session_id, $ldap_handle);
1410 if ( 0 < @{$answer_l} ) {
1411 my $answer_str = join("\n", @{$answer_l});
1412 while ($answer_str =~ /<header>(\w+)<\/header>/g) {
1413 daemon_log("$session_id INFO: got answer message with header '$1'", 5);
1414 }
1415 daemon_log("$session_id DEBUG: $module: got answer from module: \n".$answer_str,9);
1416 } else {
1417 daemon_log("$session_id DEBUG: $module: got no answer from module!" ,7);
1418 }
1420 }
1421 if( !$answer_l ) { $error++ };
1423 ########
1424 # answer
1425 if( $error == 0 ) {
1427 foreach my $answer ( @{$answer_l} ) {
1428 # check outgoing msg to xml validity
1429 my $answer_hash = &check_outgoing_xml_validity($answer, $session_id);
1430 if( not defined $answer_hash ) { next; }
1432 $answer_header = @{$answer_hash->{'header'}}[0];
1433 @answer_target_l = @{$answer_hash->{'target'}};
1434 $answer_source = @{$answer_hash->{'source'}}[0];
1436 # deliver msg to all targets
1437 foreach my $answer_target ( @answer_target_l ) {
1439 # targets of msg are all gosa-si-clients in known_clients_db
1440 if( $answer_target eq "*" ) {
1441 # answer is for all clients
1442 my $sql_statement= "SELECT * FROM known_clients";
1443 my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1444 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1445 my $host_name = $hit->{hostname};
1446 my $host_key = $hit->{hostkey};
1447 my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1448 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1449 }
1450 }
1452 # targets of msg are all gosa-si-server in known_server_db
1453 elsif( $answer_target eq "KNOWN_SERVER" ) {
1454 # answer is for all server in known_server
1455 my $sql_statement= "SELECT * FROM $known_server_tn";
1456 my $query_res = $known_server_db->select_dbentry( $sql_statement );
1457 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1458 my $host_name = $hit->{hostname};
1459 my $host_key = $hit->{hostkey};
1460 $answer =~ s/<target>\S+<\/target>/<target>$host_name<\/target>/g;
1461 my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1462 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1463 }
1464 }
1466 # target of msg is GOsa
1467 elsif( $answer_target eq "GOSA" ) {
1468 my $session_id = ($1) if $answer =~ /<session_id>(\d+?)<\/session_id>/;
1469 my $add_on = "";
1470 if( defined $session_id ) {
1471 $add_on = ".session_id=$session_id";
1472 }
1473 # answer is for GOSA and has to returned to connected client
1474 my $gosa_answer = &encrypt_msg($answer, $GosaPackages_key);
1475 $client_answer = $gosa_answer.$add_on;
1476 }
1478 # target of msg is job queue at this host
1479 elsif( $answer_target eq "JOBDB") {
1480 $answer =~ /<header>(\S+)<\/header>/;
1481 my $header;
1482 if( defined $1 ) { $header = $1; }
1483 my $error = &send_msg_to_target($answer, $server_address, $GosaPackages_key, $header, $session_id);
1484 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1485 }
1487 # Target of msg is a mac address
1488 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 ) {
1489 daemon_log("$session_id INFO: target is mac address '$answer_target', looking for host in known_clients and foreign_clients", 5);
1491 # Looking for macaddress in known_clients
1492 my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$answer_target'";
1493 my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1494 my $found_ip_flag = 0;
1495 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1496 my $host_name = $hit->{hostname};
1497 my $host_key = $hit->{hostkey};
1498 $answer =~ s/$answer_target/$host_name/g;
1499 daemon_log("$session_id INFO: found host '$host_name', associated to '$answer_target'", 5);
1500 my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1501 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1502 $found_ip_flag++ ;
1503 }
1505 # Looking for macaddress in foreign_clients
1506 if ($found_ip_flag == 0) {
1507 my $sql = "SELECT * FROM $foreign_clients_tn WHERE macaddress LIKE '$answer_target'";
1508 my $res = $foreign_clients_db->select_dbentry($sql);
1509 while( my ($hit_num, $hit) = each %{ $res } ) {
1510 my $host_name = $hit->{hostname};
1511 my $reg_server = $hit->{regserver};
1512 daemon_log("$session_id INFO: found host '$host_name' with mac '$answer_target', registered at '$reg_server'", 5);
1514 # Fetch key for reg_server
1515 my $reg_server_key;
1516 my $sql = "SELECT * FROM $known_server_tn WHERE hostname='$reg_server'";
1517 my $res = $known_server_db->select_dbentry($sql);
1518 if (exists $res->{1}) {
1519 $reg_server_key = $res->{1}->{'hostkey'};
1520 } else {
1521 daemon_log("$session_id ERROR: cannot find hostkey for '$host_name' in '$known_server_tn'", 1);
1522 daemon_log("$session_id ERROR: unable to forward answer to correct registration server, processing is aborted!", 1);
1523 $reg_server_key = undef;
1524 }
1526 # Send answer to server where client is registered
1527 if (defined $reg_server_key) {
1528 $answer =~ s/$answer_target/$host_name/g;
1529 my $error = &send_msg_to_target($answer, $reg_server, $reg_server_key, $answer_header, $session_id);
1530 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1531 $found_ip_flag++ ;
1532 }
1533 }
1534 }
1536 # No mac to ip matching found
1537 if( $found_ip_flag == 0) {
1538 daemon_log("$session_id WARNING: no host found in known_clients or foreign_clients with mac address '$answer_target'", 3);
1539 &reactivate_job_with_delay($session_id, $answer_target, $answer_header, 30);
1540 }
1542 # Answer is for one specific host
1543 } else {
1544 # get encrypt_key
1545 my $encrypt_key = &get_encrypt_key($answer_target);
1546 if( not defined $encrypt_key ) {
1547 # unknown target
1548 daemon_log("$session_id WARNING: unknown target '$answer_target'", 3);
1549 next;
1550 }
1551 my $error = &send_msg_to_target($answer, $answer_target, $encrypt_key, $answer_header,$session_id);
1552 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1553 }
1554 }
1555 }
1556 }
1558 my $filter = POE::Filter::Reference->new();
1559 my %result = (
1560 status => "seems ok to me",
1561 answer => $client_answer,
1562 );
1564 my $output = $filter->put( [ \%result ] );
1565 print @$output;
1568 }
1570 sub session_start {
1571 my ($kernel) = $_[KERNEL];
1572 $global_kernel = $kernel;
1573 $kernel->yield('register_at_foreign_servers');
1574 $kernel->yield('create_fai_server_db', $fai_server_tn );
1575 $kernel->yield('create_fai_release_db', $fai_release_tn );
1576 $kernel->yield('watch_for_next_tasks');
1577 $kernel->sig(USR1 => "sig_handler");
1578 $kernel->sig(USR2 => "recreate_packages_db");
1579 $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
1580 $kernel->delay_set('watch_for_done_jobs', $job_queue_loop_delay);
1581 $kernel->delay_set('watch_for_modified_jobs', $modified_jobs_loop_delay);
1582 $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
1583 $kernel->delay_set('watch_for_delivery_messages', $messaging_db_loop_delay);
1584 $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
1585 $kernel->delay_set('watch_for_old_known_clients', $job_queue_loop_delay);
1587 # Start opsi check
1588 if ($opsi_enabled eq "true") {
1589 $kernel->delay_set('watch_for_opsi_jobs', $job_queue_opsi_delay);
1590 }
1592 }
1595 sub watch_for_done_jobs {
1596 #CHECK: $heap for what?
1597 my ($kernel,$heap) = @_[KERNEL, HEAP];
1599 my $sql_statement = "SELECT * FROM ".$job_queue_tn." WHERE ((status='done') AND (modified='0'))";
1600 my $res = $job_db->select_dbentry( $sql_statement );
1602 while( my ($id, $hit) = each %{$res} ) {
1603 my $jobdb_id = $hit->{id};
1604 my $sql_statement = "DELETE FROM $job_queue_tn WHERE id=$jobdb_id";
1605 my $res = $job_db->del_dbentry($sql_statement);
1606 }
1608 $kernel->delay_set('watch_for_done_jobs',$job_queue_loop_delay);
1609 }
1612 sub watch_for_opsi_jobs {
1613 my ($kernel) = $_[KERNEL];
1615 # 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
1616 # opsi install job is to parse the xml message. There is still the correct header.
1617 my $sql_statement = "SELECT * FROM ".$job_queue_tn." WHERE ((xmlmessage LIKE '%opsi_install_client</header>%') AND (status='processing') AND (siserver='localhost'))";
1618 my $res = $job_db->select_dbentry( $sql_statement );
1620 # Ask OPSI for an update of the running jobs
1621 while (my ($id, $hit) = each %$res ) {
1622 # Determine current parameters of the job
1623 my $hostId = $hit->{'plainname'};
1624 my $macaddress = $hit->{'macaddress'};
1625 my $progress = $hit->{'progress'};
1627 my $result= {};
1629 # For hosts, only return the products that are or get installed
1630 my $callobj;
1631 $callobj = {
1632 method => 'getProductStates_hash',
1633 params => [ $hostId ],
1634 id => 1,
1635 };
1637 my $hres = $opsi_client->call($opsi_url, $callobj);
1638 #my ($hres_err, $hres_err_string) = &check_opsi_res($hres);
1639 if (not &check_opsi_res($hres)) {
1640 my $htmp= $hres->result->{$hostId};
1642 # Check state != not_installed or action == setup -> load and add
1643 my $products= 0;
1644 my $installed= 0;
1645 my $installing = 0;
1646 my $error= 0;
1647 my @installed_list;
1648 my @error_list;
1649 my $act_status = "none";
1650 foreach my $product (@{$htmp}){
1652 if ($product->{'installationStatus'} ne "not_installed" or
1653 $product->{'actionRequest'} eq "setup"){
1655 # Increase number of products for this host
1656 $products++;
1658 if ($product->{'installationStatus'} eq "failed"){
1659 $result->{$product->{'productId'}}= "error";
1660 unshift(@error_list, $product->{'productId'});
1661 $error++;
1662 }
1663 if ($product->{'installationStatus'} eq "installed" && $product->{'actionRequest'} eq "none"){
1664 $result->{$product->{'productId'}}= "installed";
1665 unshift(@installed_list, $product->{'productId'});
1666 $installed++;
1667 }
1668 if ($product->{'installationStatus'} eq "installing"){
1669 $result->{$product->{'productId'}}= "installing";
1670 $installing++;
1671 $act_status = "installing - ".$product->{'productId'};
1672 }
1673 }
1674 }
1676 # Estimate "rough" progress, avoid division by zero
1677 if ($products == 0) {
1678 $result->{'progress'}= 0;
1679 } else {
1680 $result->{'progress'}= int($installed * 100 / $products);
1681 }
1683 # Set updates in job queue
1684 if ((not $error) && (not $installing) && ($installed)) {
1685 $act_status = "installed - ".join(", ", @installed_list);
1686 }
1687 if ($error) {
1688 $act_status = "error - ".join(", ", @error_list);
1689 }
1690 if ($progress ne $result->{'progress'} ) {
1691 # Updating progress and result
1692 my $update_statement = "UPDATE $job_queue_tn SET modified='1', progress='".$result->{'progress'}."', result='$act_status' WHERE macaddress LIKE '$macaddress' AND siserver='localhost'";
1693 my $update_res = $job_db->update_dbentry($update_statement);
1694 }
1695 if ($progress eq 100) {
1696 # Updateing status
1697 my $done_statement = "UPDATE $job_queue_tn SET modified='1', ";
1698 if ($error) {
1699 $done_statement .= "status='error'";
1700 } else {
1701 $done_statement .= "status='done'";
1702 }
1703 $done_statement .= " WHERE macaddress LIKE '$macaddress' AND siserver='localhost'";
1704 my $done_res = $job_db->update_dbentry($done_statement);
1705 }
1708 }
1709 }
1711 $kernel->delay_set('watch_for_opsi_jobs', $job_queue_opsi_delay);
1712 }
1715 # If a job got an update or was modified anyway, send to all other si-server an update message of this jobs.
1716 sub watch_for_modified_jobs {
1717 my ($kernel,$heap) = @_[KERNEL, HEAP];
1719 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE (modified='1')";
1720 my $res = $job_db->select_dbentry( $sql_statement );
1722 # if db contains no jobs which should be update, do nothing
1723 if (keys %$res != 0) {
1725 if ($job_synchronization eq "true") {
1726 # make out of the db result a gosa-si message
1727 my $update_msg = &db_res2si_msg ($res, "foreign_job_updates", "KNOWN_SERVER", "MY_LOCAL_ADDRESS");
1729 # update all other SI-server
1730 &inform_all_other_si_server($update_msg);
1731 }
1733 # set jobs all jobs to modified = 0, wait until the next modification for updates of other si-server
1734 $sql_statement = "UPDATE $job_queue_tn SET modified='0' ";
1735 $res = $job_db->update_dbentry($sql_statement);
1736 }
1738 $kernel->delay_set('watch_for_modified_jobs', $modified_jobs_loop_delay);
1739 }
1742 sub watch_for_new_jobs {
1743 if($watch_for_new_jobs_in_progress == 0) {
1744 $watch_for_new_jobs_in_progress = 1;
1745 my ($kernel,$heap) = @_[KERNEL, HEAP];
1747 # check gosa job queue for jobs with executable timestamp
1748 my $timestamp = &get_time();
1749 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE siserver='localhost' AND status='waiting' AND (CAST(timestamp AS UNSIGNED)) < $timestamp ORDER BY timestamp";
1750 my $res = $job_db->exec_statement( $sql_statement );
1752 # Merge all new jobs that would do the same actions
1753 my @drops;
1754 my $hits;
1755 foreach my $hit (reverse @{$res} ) {
1756 my $macaddress= lc @{$hit}[8];
1757 my $headertag= @{$hit}[5];
1758 if(
1759 defined($hits->{$macaddress}) &&
1760 defined($hits->{$macaddress}->{$headertag}) &&
1761 defined($hits->{$macaddress}->{$headertag}[0])
1762 ) {
1763 push @drops, "DELETE FROM $job_queue_tn WHERE id = $hits->{$macaddress}->{$headertag}[0]";
1764 }
1765 $hits->{$macaddress}->{$headertag}= $hit;
1766 }
1768 # Delete new jobs with a matching job in state 'processing'
1769 foreach my $macaddress (keys %{$hits}) {
1770 foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
1771 my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
1772 if(defined($jobdb_id)) {
1773 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND headertag='$jobdb_headertag' AND status='processing'";
1774 my $res = $job_db->exec_statement( $sql_statement );
1775 foreach my $hit (@{$res}) {
1776 push @drops, "DELETE FROM $job_queue_tn WHERE id=$jobdb_id";
1777 }
1778 } else {
1779 daemon_log("J ERROR: Job without id exists for macaddress $macaddress!", 1);
1780 }
1781 }
1782 }
1784 # Commit deletion
1785 $job_db->exec_statementlist(\@drops);
1787 # Look for new jobs that could be executed
1788 foreach my $macaddress (keys %{$hits}) {
1790 # Look if there is an executing job
1791 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND status='processing'";
1792 my $res = $job_db->exec_statement( $sql_statement );
1794 # Skip new jobs for host if there is a processing job
1795 if(defined($res) and defined @{$res}[0]) {
1796 # Prevent race condition if there is a trigger_activate job waiting and a goto-activation job processing
1797 my $row = @{$res}[0] if (ref $res eq 'ARRAY');
1798 if(@{$row}[5] eq 'trigger_action_reinstall') {
1799 my $sql_statement_2 = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND status='waiting' AND headertag = 'trigger_activate_new'";
1800 my $res_2 = $job_db->exec_statement( $sql_statement_2 );
1801 if(defined($res_2) and defined @{$res_2}[0]) {
1802 # Set status from goto-activation to 'waiting' and update timestamp
1803 $job_db->exec_statement("UPDATE $job_queue_tn SET status='waiting' WHERE macaddress LIKE '$macaddress' AND headertag = 'trigger_action_reinstall'");
1804 $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'");
1805 }
1806 }
1807 next;
1808 }
1810 foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
1811 my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
1812 if(defined($jobdb_id)) {
1813 my $job_msg = @{$hits->{$macaddress}->{$jobdb_headertag}}[7];
1815 daemon_log("J DEBUG: its time to execute $job_msg", 7);
1816 my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$macaddress'";
1817 my $res_hash = $known_clients_db->select_dbentry( $sql_statement );
1819 # expect macaddress is unique!!!!!!
1820 my $target = $res_hash->{1}->{hostname};
1822 # change header
1823 $job_msg =~ s/<header>job_/<header>gosa_/;
1825 # add sqlite_id
1826 $job_msg =~ s/<\/xml>$/<jobdb_id>$jobdb_id<\/jobdb_id><\/xml>/;
1828 $job_msg =~ /<header>(\S+)<\/header>/;
1829 my $header = $1 ;
1830 my $func_error = &send_msg_to_target($job_msg, $server_address, $GosaPackages_key, $header, "J");
1832 # update status in job queue to ...
1833 # ... 'processing', for jobs: 'reinstall', 'update'
1834 if (($header =~ /gosa_trigger_action_reinstall/)
1835 || ($header =~ /gosa_trigger_activate_new/)
1836 || ($header =~ /gosa_trigger_action_update/)) {
1837 my $sql_statement = "UPDATE $job_queue_tn SET status='processing' WHERE id=$jobdb_id";
1838 my $dbres = $job_db->update_dbentry($sql_statement);
1839 }
1841 # ... 'done', for all other jobs, they are no longer needed in the jobqueue
1842 else {
1843 my $sql_statement = "UPDATE $job_queue_tn SET status='done' WHERE id=$jobdb_id";
1844 my $dbres = $job_db->update_dbentry($sql_statement);
1845 }
1848 # We don't want parallel processing
1849 last;
1850 }
1851 }
1852 }
1854 $watch_for_new_jobs_in_progress = 0;
1855 $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
1856 }
1857 }
1860 sub watch_for_new_messages {
1861 my ($kernel,$heap) = @_[KERNEL, HEAP];
1862 my @coll_user_msg; # collection list of outgoing messages
1864 # check messaging_db for new incoming messages with executable timestamp
1865 my $timestamp = &get_time();
1866 my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( (CAST(timestamp AS UNSIGNED))<$timestamp AND flag='n' AND direction='in' )";
1867 my $res = $messaging_db->exec_statement( $sql_statement );
1868 foreach my $hit (@{$res}) {
1870 # create outgoing messages
1871 my $message_to = @{$hit}[3];
1872 # translate message_to to plain login name
1873 my @message_to_l = split(/,/, $message_to);
1874 my %receiver_h;
1875 foreach my $receiver (@message_to_l) {
1876 if ($receiver =~ /^u_([\s\S]*)$/) {
1877 $receiver_h{$1} = 0;
1878 } elsif ($receiver =~ /^g_([\s\S]*)$/) {
1879 my $group_name = $1;
1880 # fetch all group members from ldap and add them to receiver hash
1881 my $ldap_handle = &get_ldap_handle();
1882 if (defined $ldap_handle) {
1883 my $mesg = $ldap_handle->search(
1884 base => $ldap_base,
1885 scope => 'sub',
1886 attrs => ['memberUid'],
1887 filter => "cn=$group_name",
1888 );
1889 &release_ldap_handle($ldap_handle);
1890 if ($mesg->count) {
1891 my @entries = $mesg->entries;
1892 foreach my $entry (@entries) {
1893 my @receivers= $entry->get_value("memberUid");
1894 foreach my $receiver (@receivers) {
1895 $receiver_h{$receiver} = 0;
1896 }
1897 }
1898 }
1899 # translating errors ?
1900 if ($mesg->code) {
1901 daemon_log("M ERROR: unable to translate group '$group_name' to user list for message delivery: $mesg->error", 1);
1902 }
1903 # ldap handle error ?
1904 } else {
1905 daemon_log("M ERROR: unable to translate group '$group_name' to user list for message delivery: no ldap handle available", 1);
1906 }
1907 } else {
1908 my $sbjct = &encode_base64(@{$hit}[1]);
1909 my $msg = &encode_base64(@{$hit}[7]);
1910 &daemon_log("M WARNING: unknown receiver '$receiver' for a user-message '$sbjct - $msg'", 3);
1911 }
1912 }
1913 my @receiver_l = keys(%receiver_h);
1915 my $message_id = @{$hit}[0];
1917 #add each outgoing msg to messaging_db
1918 my $receiver;
1919 foreach $receiver (@receiver_l) {
1920 my $sql_statement = "INSERT INTO $messaging_tn (id, subject, message_from, message_to, flag, direction, delivery_time, message, timestamp) ".
1921 "VALUES ('".
1922 $message_id."', '". # id
1923 @{$hit}[1]."', '". # subject
1924 @{$hit}[2]."', '". # message_from
1925 $receiver."', '". # message_to
1926 "none"."', '". # flag
1927 "out"."', '". # direction
1928 @{$hit}[6]."', '". # delivery_time
1929 @{$hit}[7]."', '". # message
1930 $timestamp."'". # timestamp
1931 ")";
1932 &daemon_log("M DEBUG: $sql_statement", 1);
1933 my $res = $messaging_db->exec_statement($sql_statement);
1934 &daemon_log("M INFO: message '".@{$hit}[0]."' is prepared for delivery to receiver '$receiver'", 5);
1935 }
1937 # set incoming message to flag d=deliverd
1938 $sql_statement = "UPDATE $messaging_tn SET flag='p' WHERE id='$message_id'";
1939 &daemon_log("M DEBUG: $sql_statement", 7);
1940 $res = $messaging_db->update_dbentry($sql_statement);
1941 &daemon_log("M INFO: message '$message_id' is set to flag 'p' (processed)", 5);
1942 }
1944 $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
1945 return;
1946 }
1948 sub watch_for_delivery_messages {
1949 my ($kernel, $heap) = @_[KERNEL, HEAP];
1951 # select outgoing messages
1952 my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( flag='p' AND direction='out' )";
1953 #&daemon_log("0 DEBUG: $sql", 7);
1954 my $res = $messaging_db->exec_statement( $sql_statement );
1956 # build out msg for each usr
1957 foreach my $hit (@{$res}) {
1958 my $receiver = @{$hit}[3];
1959 my $msg_id = @{$hit}[0];
1960 my $subject = @{$hit}[1];
1961 my $message = @{$hit}[7];
1963 # resolve usr -> host where usr is logged in
1964 my $sql = "SELECT * FROM $login_users_tn WHERE (user='$receiver')";
1965 #&daemon_log("0 DEBUG: $sql", 7);
1966 my $res = $login_users_db->exec_statement($sql);
1968 # receiver is logged in nowhere
1969 if (not ref(@$res[0]) eq "ARRAY") { next; }
1971 # receiver ist logged in at a client registered at local server
1972 my $send_succeed = 0;
1973 foreach my $hit (@$res) {
1974 my $receiver_host = @$hit[0];
1975 my $delivered2host = 0;
1976 &daemon_log("M DEBUG: user '$receiver' is logged in at host '$receiver_host'", 7);
1978 # Looking for host in know_clients_db
1979 my $sql = "SELECT * FROM $known_clients_tn WHERE (hostname='$receiver_host')";
1980 my $res = $known_clients_db->exec_statement($sql);
1982 # Host is known in known_clients_db
1983 if (ref(@$res[0]) eq "ARRAY") {
1984 my $receiver_key = @{@{$res}[0]}[2];
1985 my %data = ('subject' => $subject, 'message' => $message, 'usr' => $receiver);
1986 my $out_msg = &build_msg("usr_msg", $server_address, $receiver_host, \%data );
1987 my $error = &send_msg_to_target($out_msg, $receiver_host, $receiver_key, "usr_msg", 0);
1988 if ($error == 0 ) {
1989 $send_succeed++ ;
1990 $delivered2host++ ;
1991 &daemon_log("M DEBUG: send message for user '$receiver' to host '$receiver_host'", 7);
1992 } else {
1993 &daemon_log("M DEBUG: cannot send message for user '$receiver' to host '$receiver_host'", 7);
1994 }
1995 }
1997 # Message already send, do not need to do anything more, otherwise ...
1998 if ($delivered2host) { next;}
2000 # ...looking for host in foreign_clients_db
2001 $sql = "SELECT * FROM $foreign_clients_tn WHERE (hostname='$receiver_host')";
2002 $res = $foreign_clients_db->exec_statement($sql);
2004 # Host is known in foreign_clients_db
2005 if (ref(@$res[0]) eq "ARRAY") {
2006 my $registration_server = @{@{$res}[0]}[2];
2008 # Fetch encryption key for registration server
2009 my $sql = "SELECT * FROM $known_server_tn WHERE (hostname='$registration_server')";
2010 my $res = $known_server_db->exec_statement($sql);
2011 if (ref(@$res[0]) eq "ARRAY") {
2012 my $registration_server_key = @{@{$res}[0]}[3];
2013 my %data = ('subject' => $subject, 'message' => $message, 'usr' => $receiver);
2014 my $out_msg = &build_msg("usr_msg", $server_address, $receiver_host, \%data );
2015 my $error = &send_msg_to_target($out_msg, $registration_server, $registration_server_key, "usr_msg", 0);
2016 if ($error == 0 ) {
2017 $send_succeed++ ;
2018 $delivered2host++ ;
2019 &daemon_log("M DEBUG: send message for user '$receiver' to server '$registration_server'", 7);
2020 } else {
2021 &daemon_log("M ERROR: cannot send message for user '$receiver' to server '$registration_server'", 1);
2022 }
2024 } else {
2025 &daemon_log("M ERROR: host '$receiver_host' is reported to be ".
2026 "registrated at server '$registration_server', ".
2027 "but no data available in known_server_db ", 1);
2028 }
2029 }
2031 if (not $delivered2host) {
2032 &daemon_log("M ERROR: unable to send user message to host '$receiver_host'", 1);
2033 }
2034 }
2036 if ($send_succeed) {
2037 # set outgoing msg at db to deliverd
2038 my $sql = "UPDATE $messaging_tn SET flag='d' WHERE (id='$msg_id' AND direction='out' AND message_to='$receiver')";
2039 my $res = $messaging_db->exec_statement($sql);
2040 &daemon_log("M INFO: send message for user '$receiver' to logged in hosts", 5);
2041 } else {
2042 &daemon_log("M WARNING: failed to deliver message for user '$receiver'", 3);
2043 }
2044 }
2046 $kernel->delay_set('watch_for_delivery_messages', $messaging_db_loop_delay);
2047 return;
2048 }
2051 sub watch_for_done_messages {
2052 my ($kernel,$heap) = @_[KERNEL, HEAP];
2054 my $sql = "SELECT * FROM $messaging_tn WHERE (flag='p' AND direction='in')";
2055 #&daemon_log("0 DEBUG: $sql", 7);
2056 my $res = $messaging_db->exec_statement($sql);
2058 foreach my $hit (@{$res}) {
2059 my $msg_id = @{$hit}[0];
2061 my $sql = "SELECT * FROM $messaging_tn WHERE (id='$msg_id' AND direction='out' AND (NOT flag='s'))";
2062 #&daemon_log("0 DEBUG: $sql", 7);
2063 my $res = $messaging_db->exec_statement($sql);
2065 # not all usr msgs have been seen till now
2066 if ( ref(@$res[0]) eq "ARRAY") { next; }
2068 $sql = "DELETE FROM $messaging_tn WHERE (id='$msg_id')";
2069 #&daemon_log("0 DEBUG: $sql", 7);
2070 $res = $messaging_db->exec_statement($sql);
2072 }
2074 $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
2075 return;
2076 }
2079 sub watch_for_old_known_clients {
2080 my ($kernel,$heap) = @_[KERNEL, HEAP];
2082 my $sql_statement = "SELECT * FROM $known_clients_tn";
2083 my $res = $known_clients_db->select_dbentry( $sql_statement );
2085 my $cur_time = int(&get_time());
2087 while ( my ($hit_num, $hit) = each %$res) {
2088 my $expired_timestamp = int($hit->{'timestamp'});
2089 $expired_timestamp =~ /(\d{4})(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)/;
2090 my $dt = DateTime->new( year => $1,
2091 month => $2,
2092 day => $3,
2093 hour => $4,
2094 minute => $5,
2095 second => $6,
2096 );
2098 $dt->add( seconds => 2 * int($hit->{'keylifetime'}) );
2099 $expired_timestamp = $dt->ymd('').$dt->hms('');
2100 if ($cur_time > $expired_timestamp) {
2101 my $hostname = $hit->{'hostname'};
2102 my $del_sql = "DELETE FROM $known_clients_tn WHERE hostname='$hostname'";
2103 my $del_res = $known_clients_db->exec_statement($del_sql);
2105 &main::daemon_log("0 INFO: timestamp '".$hit->{'timestamp'}."' of client '$hostname' is expired('$expired_timestamp'), client will be deleted from known_clients_db", 5);
2106 }
2108 }
2110 $kernel->delay_set('watch_for_old_known_clients', $job_queue_loop_delay);
2111 }
2114 sub watch_for_next_tasks {
2115 my ($kernel,$heap) = @_[KERNEL, HEAP];
2117 my $sql = "SELECT * FROM $incoming_tn";
2118 my $res = $incoming_db->select_dbentry($sql);
2120 while ( my ($hit_num, $hit) = each %$res) {
2121 my $headertag = $hit->{'headertag'};
2122 if ($headertag =~ /^answer_(\d+)/) {
2123 # do not start processing, this message is for a still running POE::Wheel
2124 next;
2125 }
2126 my $message_id = $hit->{'id'};
2127 my $session_id = $hit->{'sessionid'};
2128 &daemon_log("$session_id DEBUG: start processing for message with incoming id: '$message_id'", 7);
2130 my $ldap_handle = &get_ldap_handle();
2131 if (not defined $ldap_handle) { next; }
2132 $kernel->yield('next_task', $hit, $ldap_handle);
2134 my $sql = "DELETE FROM $incoming_tn WHERE id=$message_id";
2135 my $res = $incoming_db->exec_statement($sql);
2136 }
2138 $kernel->delay_set('watch_for_next_tasks', 1);
2139 }
2142 sub get_ldap_handle {
2143 my ($session_id) = @_;
2144 my $heap;
2146 if (not defined $session_id ) { $session_id = 0 };
2147 if ($session_id =~ /[^0-9]*/) { $session_id = 0 };
2149 (my $package, my $file, my $row, my $subroutine, my $hasArgs, my $wantArray, my $evalText, my $isRequire) = caller(1);
2150 my $caller_text = "subroutin $subroutine";
2151 if ($subroutine eq "(eval)") {
2152 $caller_text = "eval block within file '$file' for '$evalText'";
2153 }
2154 daemon_log("$session_id INFO: new ldap handle for $caller_text required", 9);
2156 my $ldap_handle = $ldap_pool->get();
2158 if (not defined $ldap_handle) {
2159 daemon_log("$session_id ERROR: ldap handle for $caller_text not available", 1);
2160 }
2161 return $ldap_handle;
2162 }
2164 sub release_ldap_handle {
2165 my ($ldap_handle) = @_ ;
2166 $ldap_pool->free($ldap_handle);
2167 return;
2168 }
2171 sub change_fai_state {
2172 my ($st, $targets, $session_id) = @_;
2173 $session_id = 0 if not defined $session_id;
2174 # Set FAI state to localboot
2175 my %mapActions= (
2176 reboot => '',
2177 update => 'softupdate',
2178 localboot => 'localboot',
2179 reinstall => 'install',
2180 rescan => '',
2181 wake => '',
2182 memcheck => 'memcheck',
2183 sysinfo => 'sysinfo',
2184 install => 'install',
2185 );
2187 # Return if this is unknown
2188 if (!exists $mapActions{ $st }){
2189 daemon_log("$session_id ERROR: unknown action '$st', can not translate ot FAIstate", 1);
2190 return;
2191 }
2193 my $state= $mapActions{ $st };
2195 #if( defined($ldap_handle) ) {
2197 # Build search filter for hosts
2198 my $search= "(&(objectClass=GOhard)";
2199 foreach (@{$targets}){
2200 $search.= "(macAddress=$_)";
2201 }
2202 $search.= ")";
2204 # If there's any host inside of the search string, procress them
2205 if (!($search =~ /macAddress/)){
2206 daemon_log("$session_id ERROR: no macAddress found in filter statement for LDAP search: '$search'", 1);
2207 return;
2208 }
2210 my $ldap_handle = &get_ldap_handle($session_id);
2211 # Perform search for Unit Tag
2212 my $mesg = $ldap_handle->search(
2213 base => $ldap_base,
2214 scope => 'sub',
2215 attrs => ['dn', 'FAIstate', 'objectClass'],
2216 filter => "$search"
2217 );
2219 if ($mesg->count) {
2220 my @entries = $mesg->entries;
2221 if (0 == @entries) {
2222 daemon_log("$session_id ERROR: ldap search failed: ldap_base=$ldap_base, filter=$search", 1);
2223 }
2225 foreach my $entry (@entries) {
2226 # Only modify entry if it is not set to '$state'
2227 if ($entry->get_value("FAIstate") ne "$state"){
2228 daemon_log("$session_id INFO: Setting FAIstate to '$state' for ".$entry->dn, 5);
2229 my $result;
2230 my %tmp = map { $_ => 1 } $entry->get_value("objectClass");
2231 if (exists $tmp{'FAIobject'}){
2232 if ($state eq ''){
2233 $result= $ldap_handle->modify($entry->dn, changes => [ delete => [ FAIstate => [] ] ]);
2234 } else {
2235 $result= $ldap_handle->modify($entry->dn, changes => [ replace => [ FAIstate => $state ] ]);
2236 }
2237 } elsif ($state ne ''){
2238 $result= $ldap_handle->modify($entry->dn, changes => [ add => [ objectClass => 'FAIobject' ], add => [ FAIstate => $state ] ]);
2239 }
2241 # Errors?
2242 if ($result->code){
2243 daemon_log("$session_id Error: Setting FAIstate to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
2244 }
2245 } else {
2246 daemon_log("$session_id DEBUG FAIstate at host '".$entry->dn."' already at state '$st'", 7);
2247 }
2248 }
2249 } else {
2250 daemon_log("$session_id ERROR: LDAP search failed: ldap_base=$ldap_base, filter=$search", 1);
2251 }
2252 &release_ldap_handle($ldap_handle);
2254 # if no ldap handle defined
2255 #} else {
2256 # daemon_log("$session_id ERROR: no LDAP handle defined for update FAIstate", 1);
2257 #}
2259 return;
2260 }
2263 sub change_goto_state {
2264 my ($st, $targets, $session_id) = @_;
2265 $session_id = 0 if not defined $session_id;
2267 # Switch on or off?
2268 my $state= $st eq 'active' ? 'active': 'locked';
2270 my $ldap_handle = &get_ldap_handle($session_id);
2271 if( defined($ldap_handle) ) {
2273 # Build search filter for hosts
2274 my $search= "(&(objectClass=GOhard)";
2275 foreach (@{$targets}){
2276 $search.= "(macAddress=$_)";
2277 }
2278 $search.= ")";
2280 # If there's any host inside of the search string, procress them
2281 if (!($search =~ /macAddress/)){
2282 return;
2283 }
2285 # Perform search for Unit Tag
2286 my $mesg = $ldap_handle->search(
2287 base => $ldap_base,
2288 scope => 'sub',
2289 attrs => ['dn', 'gotoMode'],
2290 filter => "$search"
2291 );
2293 if ($mesg->count) {
2294 my @entries = $mesg->entries;
2295 foreach my $entry (@entries) {
2297 # Only modify entry if it is not set to '$state'
2298 if ($entry->get_value("gotoMode") ne $state){
2300 daemon_log("$session_id INFO: Setting gotoMode to '$state' for ".$entry->dn, 5);
2301 my $result;
2302 $result= $ldap_handle->modify($entry->dn, changes => [replace => [ gotoMode => $state ] ]);
2304 # Errors?
2305 if ($result->code){
2306 &daemon_log("$session_id Error: Setting gotoMode to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
2307 }
2309 }
2310 }
2311 } else {
2312 daemon_log("$session_id ERROR: LDAP search failed in function change_goto_state: ldap_base=$ldap_base, filter=$search", 1);
2313 }
2315 }
2316 &release_ldap_handle($ldap_handle);
2317 return;
2318 }
2321 sub run_recreate_packages_db {
2322 my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];
2323 my $session_id = $session->ID;
2324 &main::daemon_log("$session_id INFO: Recreating FAI Packages DB ('$fai_release_tn', '$fai_server_tn', '$packages_list_tn')", 5);
2325 $kernel->yield('create_fai_release_db', $fai_release_tn);
2326 $kernel->yield('create_fai_server_db', $fai_server_tn);
2327 return;
2328 }
2331 sub run_create_fai_server_db {
2332 my ($kernel, $session, $heap, $table_name) = @_[KERNEL, SESSION, HEAP, ARG0];
2333 my $session_id = $session->ID;
2334 my $ldap_handle = &get_ldap_handle();
2335 if (not defined $ldap_handle) {
2336 $kernel->delay_set('create_fai_server_db', 1, $table_name);
2337 return;
2338 }
2339 my $task = POE::Wheel::Run->new(
2340 Program => sub { &create_fai_server_db($table_name,$kernel, undef, $session_id, $ldap_handle) },
2341 StdoutEvent => "session_run_result",
2342 StderrEvent => "session_run_debug",
2343 CloseEvent => "session_run_done",
2344 );
2346 $heap->{task}->{ $task->ID } = $task;
2347 $heap->{ldap_handle}->{$task->ID} = $ldap_handle;
2348 return;
2349 }
2352 sub create_fai_server_db {
2353 my ($table_name, $kernel, $dont_create_packages_list, $session_id, $ldap_handle) = @_;
2354 my $result;
2356 if (not defined $session_id) { $session_id = 0; }
2357 if(defined($ldap_handle)) {
2358 daemon_log("$session_id INFO: create_fai_server_db: start", 5);
2359 my $mesg= $ldap_handle->search(
2360 base => $ldap_base,
2361 scope => 'sub',
2362 attrs => ['FAIrepository', 'gosaUnitTag'],
2363 filter => "(&(FAIrepository=*)(objectClass=FAIrepositoryServer))",
2364 );
2365 if($mesg->{'resultCode'} == 0 &&
2366 $mesg->count != 0) {
2367 foreach my $entry (@{$mesg->{entries}}) {
2368 if($entry->exists('FAIrepository')) {
2369 # Add an entry for each Repository configured for server
2370 foreach my $repo(@{$entry->get_value('FAIrepository', asref => 1)}) {
2371 my($tmp_url,$tmp_server,$tmp_release,$tmp_sections) = split(/\|/, $repo);
2372 my $tmp_tag= $entry->get_value('gosaUnitTag') || "";
2373 $result= $fai_server_db->add_dbentry( {
2374 table => $table_name,
2375 primkey => ['server', 'fai_release', 'tag'],
2376 server => $tmp_url,
2377 fai_release => $tmp_release,
2378 sections => $tmp_sections,
2379 tag => (length($tmp_tag)>0)?$tmp_tag:"",
2380 } );
2381 }
2382 }
2383 }
2384 }
2385 daemon_log("$session_id INFO: create_fai_server_db: finished", 5);
2387 # TODO: Find a way to post the 'create_packages_list_db' event
2388 if(not defined($dont_create_packages_list)) {
2389 &create_packages_list_db(undef, $session_id);
2390 }
2391 }
2393 return $result;
2394 }
2397 sub run_create_fai_release_db {
2398 my ($kernel, $session, $heap, $table_name) = @_[KERNEL, SESSION, HEAP, ARG0];
2399 my $session_id = $session->ID;
2400 my $ldap_handle = &get_ldap_handle();
2401 if (not defined $ldap_handle) {
2402 $kernel->delay_set('create_fai_release_db', 1, $table_name);
2403 return;
2404 }
2405 my $task = POE::Wheel::Run->new(
2406 Program => sub { &create_fai_release_db($table_name, $session_id, $ldap_handle) },
2407 StdoutEvent => "session_run_result",
2408 StderrEvent => "session_run_debug",
2409 CloseEvent => "session_run_done",
2410 );
2412 $heap->{task}->{ $task->ID } = $task;
2413 $heap->{ldap_handle}->{$task->ID} = $ldap_handle;
2414 return;
2415 }
2418 sub create_fai_release_db {
2419 my ($table_name, $session_id, $ldap_handle) = @_;
2420 my $result;
2422 # used for logging
2423 if (not defined $session_id) { $session_id = 0; }
2425 #my $ldap_handle = &get_ldap_handle();
2426 if(defined($ldap_handle)) {
2427 daemon_log("$session_id INFO: create_fai_release_db: start",5);
2428 my $mesg= $ldap_handle->search(
2429 base => $ldap_base,
2430 scope => 'sub',
2431 attrs => [],
2432 filter => "(&(objectClass=organizationalUnit)(ou=fai))",
2433 );
2434 if(($mesg->code == 0) && ($mesg->count != 0))
2435 {
2436 daemon_log("$session_id DEBUG: create_fai_release_db: count " . $mesg->count,8);
2438 # Walk through all possible FAI container ou's
2439 my @sql_list;
2440 my $timestamp= &get_time();
2441 foreach my $ou (@{$mesg->{entries}}) {
2442 my $tmp_classes= resolve_fai_classes($ou->dn, $ldap_handle, $session_id);
2443 if(defined($tmp_classes) && ref($tmp_classes) eq 'HASH') {
2444 my @tmp_array=get_fai_release_entries($tmp_classes);
2445 if(@tmp_array) {
2446 foreach my $entry (@tmp_array) {
2447 if(defined($entry) && ref($entry) eq 'HASH') {
2448 my $sql=
2449 "INSERT INTO $table_name "
2450 ."(timestamp, fai_release, class, type, state) VALUES ("
2451 .$timestamp.","
2452 ."'".$entry->{'release'}."',"
2453 ."'".$entry->{'class'}."',"
2454 ."'".$entry->{'type'}."',"
2455 ."'".$entry->{'state'}."')";
2456 push @sql_list, $sql;
2457 }
2458 }
2459 }
2460 }
2461 }
2463 daemon_log("$session_id DEBUG: create_fai_release_db: Inserting ".scalar @sql_list." entries to DB",8);
2464 if(@sql_list) {
2465 unshift @sql_list, "VACUUM";
2466 unshift @sql_list, "DELETE FROM $table_name";
2467 $fai_release_db->exec_statementlist(\@sql_list);
2468 }
2469 daemon_log("$session_id DEBUG: create_fai_release_db: Done with inserting",7);
2470 } else {
2471 daemon_log("$session_id INFO: create_fai_release_db: error: " . $mesg->code, 5);
2472 }
2473 daemon_log("$session_id INFO: create_fai_release_db: finished",5);
2474 }
2475 #&release_ldap_handle($ldap_handle);
2476 return $result;
2477 }
2479 sub get_fai_types {
2480 my $tmp_classes = shift || return undef;
2481 my @result;
2483 foreach my $type(keys %{$tmp_classes}) {
2484 if(defined($tmp_classes->{$type}[0]) && (!($tmp_classes->{$type}[0] =~ /^.*?removed.*?$/))) {
2485 my $entry = {
2486 type => $type,
2487 state => $tmp_classes->{$type}[0],
2488 };
2489 push @result, $entry;
2490 }
2491 }
2493 return @result;
2494 }
2496 sub get_fai_state {
2497 my $result = "";
2498 my $tmp_classes = shift || return $result;
2500 foreach my $type(keys %{$tmp_classes}) {
2501 if(defined($tmp_classes->{$type}[0])) {
2502 $result = $tmp_classes->{$type}[0];
2504 # State is equal for all types in class
2505 last;
2506 }
2507 }
2509 return $result;
2510 }
2512 sub resolve_fai_classes {
2513 my ($fai_base, $ldap_handle, $session_id) = @_;
2514 if (not defined $session_id) { $session_id = 0; }
2515 my $result;
2516 my @possible_fai_classes= ("FAIscript", "FAIhook", "FAIpartitionTable", "FAItemplate", "FAIvariable", "FAIprofile", "FAIpackageList");
2517 my $fai_filter= "(|(&(objectClass=FAIclass)(|(objectClass=".join(")(objectClass=", @possible_fai_classes).")))(objectClass=FAIbranch))";
2518 my $fai_classes;
2520 daemon_log("$session_id DEBUG: Searching for FAI entries in base $fai_base",7);
2521 my $mesg= $ldap_handle->search(
2522 base => $fai_base,
2523 scope => 'sub',
2524 attrs => ['cn','objectClass','FAIstate'],
2525 filter => $fai_filter,
2526 );
2527 daemon_log("$session_id DEBUG: Found ".$mesg->count()." FAI entries",7);
2529 if($mesg->{'resultCode'} == 0 &&
2530 $mesg->count != 0) {
2531 foreach my $entry (@{$mesg->{entries}}) {
2532 if($entry->exists('cn')) {
2533 my $tmp_dn= $entry->dn();
2534 $tmp_dn= substr( $tmp_dn, 0, length($tmp_dn)
2535 - length($fai_base) - 1 );
2537 # Skip classname and ou dn parts for class
2538 my $tmp_release = ($1) if $tmp_dn =~ /^[^,]+,[^,]+,(.*?)$/;
2540 # Skip classes without releases
2541 if((!defined($tmp_release)) || length($tmp_release)==0) {
2542 next;
2543 }
2545 my $tmp_cn= $entry->get_value('cn');
2546 my $tmp_state= $entry->get_value('FAIstate');
2548 my $tmp_type;
2549 # Get FAI type
2550 for my $oclass(@{$entry->get_value('objectClass', asref => 1)}) {
2551 if(grep $_ eq $oclass, @possible_fai_classes) {
2552 $tmp_type= $oclass;
2553 last;
2554 }
2555 }
2557 if($tmp_release =~ /^.*?,.*?$/ && (!($tmp_release =~ /^.*?\\,.*?$/))) {
2558 # A Subrelease
2559 my @sub_releases = split(/,/, $tmp_release);
2561 # Walk through subreleases and build hash tree
2562 my $hash;
2563 while(my $tmp_sub_release = pop @sub_releases) {
2564 $hash .= "\{'$tmp_sub_release'\}->";
2565 }
2566 eval('push @{$fai_classes->'.$hash.'{$tmp_cn}->{$tmp_type}}, (defined($tmp_state) && length($tmp_state)>0)?$tmp_state:"";');
2567 } else {
2568 # A branch, no subrelease
2569 push @{$fai_classes->{$tmp_release}->{$tmp_cn}->{$tmp_type}}, (defined($tmp_state) && length($tmp_state)>0)?$tmp_state:"";
2570 }
2571 } elsif (!$entry->exists('cn')) {
2572 my $tmp_dn= $entry->dn();
2573 $tmp_dn= substr( $tmp_dn, 0, length($tmp_dn)
2574 - length($fai_base) - 1 );
2575 my $tmp_release = ($1) if $tmp_dn =~ /^(.*?)$/;
2577 # Skip classes without releases
2578 if((!defined($tmp_release)) || length($tmp_release)==0) {
2579 next;
2580 }
2582 if($tmp_release =~ /^.*?,.*?$/ && (!($tmp_release =~ /^.*?\\,.*?$/))) {
2583 # A Subrelease
2584 my @sub_releases= split(/,/, $tmp_release);
2586 # Walk through subreleases and build hash tree
2587 my $hash;
2588 while(my $tmp_sub_release = pop @sub_releases) {
2589 $hash .= "\{'$tmp_sub_release'\}->";
2590 }
2591 # Remove the last two characters
2592 chop($hash);
2593 chop($hash);
2595 eval('$fai_classes->'.$hash.'= {}');
2596 } else {
2597 # A branch, no subrelease
2598 if(!exists($fai_classes->{$tmp_release})) {
2599 $fai_classes->{$tmp_release} = {};
2600 }
2601 }
2602 }
2603 }
2605 # The hash is complete, now we can honor the copy-on-write based missing entries
2606 foreach my $release (keys %$fai_classes) {
2607 $result->{$release}= deep_copy(apply_fai_inheritance($fai_classes->{$release}));
2608 }
2609 }
2610 return $result;
2611 }
2613 sub apply_fai_inheritance {
2614 my $fai_classes = shift || return {};
2615 my $tmp_classes;
2617 # Get the classes from the branch
2618 foreach my $class (keys %{$fai_classes}) {
2619 # Skip subreleases
2620 if($class =~ /^ou=.*$/) {
2621 next;
2622 } else {
2623 $tmp_classes->{$class}= deep_copy($fai_classes->{$class});
2624 }
2625 }
2627 # Apply to each subrelease
2628 foreach my $subrelease (keys %{$fai_classes}) {
2629 if($subrelease =~ /ou=/) {
2630 foreach my $tmp_class (keys %{$tmp_classes}) {
2631 if(!exists($fai_classes->{$subrelease}->{$tmp_class})) {
2632 $fai_classes->{$subrelease}->{$tmp_class} =
2633 deep_copy($tmp_classes->{$tmp_class});
2634 } else {
2635 foreach my $type (keys %{$tmp_classes->{$tmp_class}}) {
2636 if(!exists($fai_classes->{$subrelease}->{$tmp_class}->{$type})) {
2637 $fai_classes->{$subrelease}->{$tmp_class}->{$type}=
2638 deep_copy($tmp_classes->{$tmp_class}->{$type});
2639 }
2640 }
2641 }
2642 }
2643 }
2644 }
2646 # Find subreleases in deeper levels
2647 foreach my $subrelease (keys %{$fai_classes}) {
2648 if($subrelease =~ /ou=/) {
2649 foreach my $subsubrelease (keys %{$fai_classes->{$subrelease}}) {
2650 if($subsubrelease =~ /ou=/) {
2651 apply_fai_inheritance($fai_classes->{$subrelease});
2652 }
2653 }
2654 }
2655 }
2657 return $fai_classes;
2658 }
2660 sub get_fai_release_entries {
2661 my $tmp_classes = shift || return;
2662 my $parent = shift || "";
2663 my @result = shift || ();
2665 foreach my $entry (keys %{$tmp_classes}) {
2666 if(defined($entry)) {
2667 if($entry =~ /^ou=.*$/) {
2668 my $release_name = $entry;
2669 $release_name =~ s/ou=//g;
2670 if(length($parent)>0) {
2671 $release_name = $parent."/".$release_name;
2672 }
2673 my @bufentries = get_fai_release_entries($tmp_classes->{$entry}, $release_name, @result);
2674 foreach my $bufentry(@bufentries) {
2675 push @result, $bufentry;
2676 }
2677 } else {
2678 my @types = get_fai_types($tmp_classes->{$entry});
2679 foreach my $type (@types) {
2680 push @result,
2681 {
2682 'class' => $entry,
2683 'type' => $type->{'type'},
2684 'release' => $parent,
2685 'state' => $type->{'state'},
2686 };
2687 }
2688 }
2689 }
2690 }
2692 return @result;
2693 }
2695 sub deep_copy {
2696 my $this = shift;
2697 if (not ref $this) {
2698 $this;
2699 } elsif (ref $this eq "ARRAY") {
2700 [map deep_copy($_), @$this];
2701 } elsif (ref $this eq "HASH") {
2702 +{map { $_ => deep_copy($this->{$_}) } keys %$this};
2703 } else { die "what type is $_?" }
2704 }
2707 sub session_run_result {
2708 my ($kernel, $heap, $client_answer) = @_[KERNEL, HEAP, ARG0];
2709 $kernel->sig(CHLD => "child_reap");
2710 }
2712 sub session_run_debug {
2713 my $result = $_[ARG0];
2714 print STDERR "$result\n";
2715 }
2717 sub session_run_done {
2718 my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
2719 delete $heap->{task}->{$task_id};
2720 if (exists $heap->{ldap_handle}->{$task_id}) {
2721 &release_ldap_handle($heap->{ldap_handle}->{$task_id});
2722 }
2723 delete $heap->{ldap_handle}->{$task_id};
2724 }
2727 sub create_sources_list {
2728 my $session_id = shift;
2729 my $result="/tmp/gosa_si_tmp_sources_list";
2731 # Remove old file
2732 if(stat($result)) {
2733 unlink($result);
2734 &main::daemon_log("$session_id DEBUG: remove an old version of '$result'", 7);
2735 }
2737 my $fh;
2738 open($fh, ">$result");
2739 if (not defined $fh) {
2740 &main::daemon_log("$session_id DEBUG: cannot open '$result' for writing", 7);
2741 return undef;
2742 }
2743 if(defined($main::ldap_server_dn) and length($main::ldap_server_dn) > 0) {
2744 my $ldap_handle = &get_ldap_handle();
2745 my $mesg=$ldap_handle->search(
2746 base => $main::ldap_server_dn,
2747 scope => 'base',
2748 attrs => 'FAIrepository',
2749 filter => 'objectClass=FAIrepositoryServer'
2750 );
2751 &release_ldap_handle($ldap_handle);
2752 if($mesg->count) {
2753 foreach my $entry(@{$mesg->{'entries'}}) {
2754 foreach my $value(@{$entry->get_value('FAIrepository', asref => 1)}) {
2755 my ($server, $tag, $release, $sections)= split /\|/, $value;
2756 my $line = "deb $server $release";
2757 $sections =~ s/,/ /g;
2758 $line.= " $sections";
2759 print $fh $line."\n";
2760 }
2761 }
2762 }
2763 } else {
2764 if (defined $main::ldap_server_dn){
2765 &main::daemon_log("$session_id ERROR: something wrong with ldap_server_dn '$main::ldap_server_dn', abort create_sources_list", 1);
2766 } else {
2767 &main::daemon_log("$session_id ERROR: no ldap_server_dn found, abort create_sources_list", 1);
2768 }
2769 }
2770 close($fh);
2772 return $result;
2773 }
2776 sub run_create_packages_list_db {
2777 my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];
2778 my $session_id = $session->ID;
2779 my $task = POE::Wheel::Run->new(
2780 Priority => +20,
2781 Program => sub {&create_packages_list_db(undef, $session_id)},
2782 StdoutEvent => "session_run_result",
2783 StderrEvent => "session_run_debug",
2784 CloseEvent => "session_run_done",
2785 );
2786 $heap->{task}->{ $task->ID } = $task;
2787 }
2790 sub create_packages_list_db {
2791 my ($sources_file, $session_id) = @_;
2793 # it should not be possible to trigger a recreation of packages_list_db
2794 # while packages_list_db is under construction, so set flag packages_list_under_construction
2795 # which is tested befor recreation can be started
2796 if (-r $packages_list_under_construction) {
2797 daemon_log("$session_id WARNING: packages_list_db is right now under construction, please wait until this process is finished", 3);
2798 return;
2799 } else {
2800 daemon_log("$session_id INFO: create_packages_list_db: start", 5);
2801 # set packages_list_under_construction to true
2802 system("touch $packages_list_under_construction");
2803 @packages_list_statements=();
2804 }
2806 if (not defined $session_id) { $session_id = 0; }
2808 if (not defined $sources_file) {
2809 &main::daemon_log("$session_id INFO: no sources_file given for creating packages list so trigger creation of it", 5);
2810 $sources_file = &create_sources_list($session_id);
2811 }
2813 if (not defined $sources_file) {
2814 &main::daemon_log("$session_id ERROR: no sources_file given under '$sources_file', skip create_packages_list_db", 1);
2815 unlink($packages_list_under_construction);
2816 return;
2817 }
2819 my $line;
2821 open(CONFIG, "<$sources_file") or do {
2822 daemon_log( "$session_id ERROR: create_packages_list_db: Failed to open '$sources_file'", 1);
2823 unlink($packages_list_under_construction);
2824 return;
2825 };
2827 # Read lines
2828 while ($line = <CONFIG>){
2829 # Unify
2830 chop($line);
2831 $line =~ s/^\s+//;
2832 $line =~ s/^\s+/ /;
2834 # Strip comments
2835 $line =~ s/#.*$//g;
2837 # Skip empty lines
2838 if ($line =~ /^\s*$/){
2839 next;
2840 }
2842 # Interpret deb line
2843 if ($line =~ /^deb [^\s]+\s[^\s]+\s[^\s]+/){
2844 my( $baseurl, $dist, $sections ) = ($line =~ /^deb\s([^\s]+)\s+([^\s]+)\s+(.*)$/);
2845 my $section;
2846 foreach $section (split(' ', $sections)){
2847 &parse_package_info( $baseurl, $dist, $section, $session_id );
2848 }
2849 }
2850 }
2852 close (CONFIG);
2854 if(keys(%repo_dirs)) {
2855 find(\&cleanup_and_extract, keys( %repo_dirs ));
2856 &main::strip_packages_list_statements();
2857 $packages_list_db->exec_statementlist(\@packages_list_statements);
2858 }
2859 unlink($packages_list_under_construction);
2860 daemon_log("$session_id INFO: create_packages_list_db: finished", 5);
2861 return;
2862 }
2864 # This function should do some intensive task to minimize the db-traffic
2865 sub strip_packages_list_statements {
2866 my @existing_entries= @{$packages_list_db->exec_statement("SELECT * FROM $main::packages_list_tn")};
2867 my @new_statement_list=();
2868 my $hash;
2869 my $insert_hash;
2870 my $update_hash;
2871 my $delete_hash;
2872 my $known_packages_hash;
2873 my $local_timestamp=get_time();
2875 foreach my $existing_entry (@existing_entries) {
2876 $hash->{@{$existing_entry}[0]}->{@{$existing_entry}[1]}->{@{$existing_entry}[2]}= $existing_entry;
2877 }
2879 foreach my $statement (@packages_list_statements) {
2880 if($statement =~ /^INSERT/i) {
2881 # Assign the values from the insert statement
2882 my ($distribution,$package,$version,$section,$description,$template,$timestamp) = ($1,$2,$3,$4,$5,$6,$7) if $statement =~
2883 /^INSERT\s+?INTO\s+?$main::packages_list_tn\s+?VALUES\s*?\('(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)'\s*?\)$/si;
2884 if(exists($hash->{$distribution}->{$package}->{$version})) {
2885 # If section or description has changed, update the DB
2886 if(
2887 (! (@{$hash->{$distribution}->{$package}->{$version}}[3] eq $section)) or
2888 (! (@{$hash->{$distribution}->{$package}->{$version}}[4] eq $description))
2889 ) {
2890 @{$update_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,undef);
2891 } else {
2892 # package is already present in database. cache this knowledge for later use
2893 @{$known_packages_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,$template);
2894 }
2895 } else {
2896 # Insert a non-existing entry to db
2897 @{$insert_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,$template);
2898 }
2899 } elsif ($statement =~ /^UPDATE/i) {
2900 my ($template,$package,$version) = ($1,$2,$3) if $statement =~
2901 /^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;
2902 foreach my $distribution (keys %{$hash}) {
2903 if(exists($insert_hash->{$distribution}->{$package}->{$version})) {
2904 # update the insertion hash to execute only one query per package (insert instead insert+update)
2905 @{$insert_hash->{$distribution}->{$package}->{$version}}[5]= $template;
2906 } elsif(exists($hash->{$distribution}->{$package}->{$version})) {
2907 if( ! (@{$hash->{$distribution}->{$package}->{$version}}[5] eq $template)) {
2908 my $section;
2909 my $description;
2910 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[3]) and
2911 length(@{$update_hash->{$distribution}->{$package}->{$version}}[3]) > 0 ) {
2912 $section= @{$update_hash->{$distribution}->{$package}->{$version}}[3];
2913 }
2914 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[4])) {
2915 $description= @{$update_hash->{$distribution}->{$package}->{$version}}[4];
2916 }
2917 @{$update_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,$template);
2918 }
2919 }
2920 }
2921 }
2922 }
2924 # Check for orphaned entries
2925 foreach my $existing_entry (@existing_entries) {
2926 my $distribution= @{$existing_entry}[0];
2927 my $package= @{$existing_entry}[1];
2928 my $version= @{$existing_entry}[2];
2929 my $section= @{$existing_entry}[3];
2931 if(
2932 exists($insert_hash->{$distribution}->{$package}->{$version}) ||
2933 exists($update_hash->{$distribution}->{$package}->{$version}) ||
2934 exists($known_packages_hash->{$distribution}->{$package}->{$version})
2935 ) {
2936 next;
2937 } else {
2938 # Insert entry to delete hash
2939 @{$delete_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section);
2940 }
2941 }
2943 # unroll the insert hash
2944 foreach my $distribution (keys %{$insert_hash}) {
2945 foreach my $package (keys %{$insert_hash->{$distribution}}) {
2946 foreach my $version (keys %{$insert_hash->{$distribution}->{$package}}) {
2947 push @new_statement_list, "INSERT INTO $main::packages_list_tn VALUES ('$distribution','$package','$version',"
2948 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[3]',"
2949 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[4]',"
2950 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[5]',"
2951 ."'$local_timestamp')";
2952 }
2953 }
2954 }
2956 # unroll the update hash
2957 foreach my $distribution (keys %{$update_hash}) {
2958 foreach my $package (keys %{$update_hash->{$distribution}}) {
2959 foreach my $version (keys %{$update_hash->{$distribution}->{$package}}) {
2960 my $set = "";
2961 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[3])) {
2962 $set .= "section = '@{$update_hash->{$distribution}->{$package}->{$version}}[3]', ";
2963 }
2964 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[4])) {
2965 $set .= "description = '@{$update_hash->{$distribution}->{$package}->{$version}}[4]', ";
2966 }
2967 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[5])) {
2968 $set .= "template = '@{$update_hash->{$distribution}->{$package}->{$version}}[5]', ";
2969 }
2970 if(defined($set) and length($set) > 0) {
2971 $set .= "timestamp = '$local_timestamp'";
2972 } else {
2973 next;
2974 }
2975 push @new_statement_list,
2976 "UPDATE $main::packages_list_tn SET $set WHERE"
2977 ." distribution = '$distribution'"
2978 ." AND package = '$package'"
2979 ." AND version = '$version'";
2980 }
2981 }
2982 }
2984 # unroll the delete hash
2985 foreach my $distribution (keys %{$delete_hash}) {
2986 foreach my $package (keys %{$delete_hash->{$distribution}}) {
2987 foreach my $version (keys %{$delete_hash->{$distribution}->{$package}}) {
2988 my $section = @{$delete_hash->{$distribution}->{$package}->{$version}}[3];
2989 push @new_statement_list, "DELETE FROM $main::packages_list_tn WHERE distribution='$distribution' AND package='$package' AND version='$version' AND section='$section'";
2990 }
2991 }
2992 }
2994 unshift(@new_statement_list, "VACUUM");
2996 @packages_list_statements = @new_statement_list;
2997 }
3000 sub parse_package_info {
3001 my ($baseurl, $dist, $section, $session_id)= @_;
3002 my ($package);
3003 if (not defined $session_id) { $session_id = 0; }
3004 my ($path) = ($baseurl =~ m%://[^/]*(.*)$%);
3005 $repo_dirs{ "${repo_path}/pool" } = 1;
3007 foreach $package ("Packages.gz"){
3008 daemon_log("$session_id DEBUG: create_packages_list: fetch $baseurl, $dist, $section", 7);
3009 get_package( "$baseurl/dists/$dist/$section/binary-$arch/$package", "$outdir/$dist/$section", $session_id );
3010 parse_package( "$outdir/$dist/$section", $dist, $path, $session_id );
3011 }
3013 }
3016 sub get_package {
3017 my ($url, $dest, $session_id)= @_;
3018 if (not defined $session_id) { $session_id = 0; }
3020 my $tpath = dirname($dest);
3021 -d "$tpath" || mkpath "$tpath";
3023 # This is ugly, but I've no time to take a look at "how it works in perl"
3024 if(0 == system("wget '$url' -O '$dest' 2>/dev/null") ) {
3025 system("gunzip -cd '$dest' > '$dest.in'");
3026 daemon_log("$session_id DEBUG: run command: gunzip -cd '$dest' > '$dest.in'", 5);
3027 unlink($dest);
3028 daemon_log("$session_id DEBUG: delete file '$dest'", 5);
3029 } else {
3030 daemon_log("$session_id ERROR: create_packages_list_db: get_packages: fetching '$url' into '$dest' failed!", 1);
3031 }
3032 return 0;
3033 }
3036 sub parse_package {
3037 my ($path, $dist, $srv_path, $session_id)= @_;
3038 if (not defined $session_id) { $session_id = 0;}
3039 my ($package, $version, $section, $description);
3040 my $PACKAGES;
3041 my $timestamp = &get_time();
3043 if(not stat("$path.in")) {
3044 daemon_log("$session_id ERROR: create_packages_list: parse_package: file '$path.in' is not readable",1);
3045 return;
3046 }
3048 open($PACKAGES, "<$path.in");
3049 if(not defined($PACKAGES)) {
3050 daemon_log("$session_id ERROR: create_packages_list_db: parse_package: cannot open '$path.in'",1);
3051 return;
3052 }
3054 # Read lines
3055 while (<$PACKAGES>){
3056 my $line = $_;
3057 # Unify
3058 chop($line);
3060 # Use empty lines as a trigger
3061 if ($line =~ /^\s*$/){
3062 my $sql = "INSERT INTO packages_list VALUES ('$dist', '$package', '$version', '$section', '$description', '', '$timestamp')";
3063 push(@packages_list_statements, $sql);
3064 $package = "none";
3065 $version = "none";
3066 $section = "none";
3067 $description = "none";
3068 next;
3069 }
3071 # Trigger for package name
3072 if ($line =~ /^Package:\s/){
3073 ($package)= ($line =~ /^Package: (.*)$/);
3074 next;
3075 }
3077 # Trigger for version
3078 if ($line =~ /^Version:\s/){
3079 ($version)= ($line =~ /^Version: (.*)$/);
3080 next;
3081 }
3083 # Trigger for description
3084 if ($line =~ /^Description:\s/){
3085 ($description)= &encode_base64(($line =~ /^Description: (.*)$/));
3086 next;
3087 }
3089 # Trigger for section
3090 if ($line =~ /^Section:\s/){
3091 ($section)= ($line =~ /^Section: (.*)$/);
3092 next;
3093 }
3095 # Trigger for filename
3096 if ($line =~ /^Filename:\s/){
3097 my ($filename) = ($line =~ /^Filename: (.*)$/);
3098 store_fileinfo( $package, $filename, $dist, $srv_path, $version, $repo_path );
3099 next;
3100 }
3101 }
3103 close( $PACKAGES );
3104 unlink( "$path.in" );
3105 }
3108 sub store_fileinfo {
3109 my( $package, $file, $dist, $path, $vers, $srvdir) = @_;
3111 my %fileinfo = (
3112 'package' => $package,
3113 'dist' => $dist,
3114 'version' => $vers,
3115 );
3117 $repo_files{ "${srvdir}/$file" } = \%fileinfo;
3118 }
3121 sub cleanup_and_extract {
3122 my $fileinfo = $repo_files{ $File::Find::name };
3124 if( defined $fileinfo ) {
3125 my $dir = "$outdir/$fileinfo->{ 'dist' }/debconf.d";
3126 my $sql;
3127 my $package = $fileinfo->{ 'package' };
3128 my $newver = $fileinfo->{ 'version' };
3130 mkpath($dir);
3131 system( "dpkg -e '$File::Find::name' '$dir/DEBIAN'" );
3133 if( -f "$dir/DEBIAN/templates" ) {
3135 daemon_log("0 DEBUG: Found debconf templates in '$package' - $newver", 7);
3137 my $tmpl= ""; {
3138 local $/=undef;
3139 open FILE, "$dir/DEBIAN/templates";
3140 $tmpl = &encode_base64(<FILE>);
3141 close FILE;
3142 }
3143 rmtree("$dir/DEBIAN/templates");
3145 $sql= "update $main::packages_list_tn set template = '$tmpl' where package = '$package' and version = '$newver';";
3146 push @packages_list_statements, $sql;
3147 }
3148 }
3150 return;
3151 }
3154 sub register_at_foreign_servers {
3155 my ($kernel) = $_[KERNEL];
3157 # hole alle bekannten server aus known_server_db
3158 my $server_sql = "SELECT * FROM $known_server_tn";
3159 my $server_res = $known_server_db->exec_statement($server_sql);
3161 # no entries in known_server_db
3162 if (not ref(@$server_res[0]) eq "ARRAY") {
3163 # TODO
3164 }
3166 # detect already connected clients
3167 my $client_sql = "SELECT * FROM $known_clients_tn";
3168 my $client_res = $known_clients_db->exec_statement($client_sql);
3170 # send my server details to all other gosa-si-server within the network
3171 foreach my $hit (@$server_res) {
3172 my $hostname = @$hit[0];
3173 my $hostkey = &create_passwd;
3175 # add already connected clients to registration message
3176 my $myhash = &create_xml_hash('new_server', $server_address, $hostname);
3177 &add_content2xml_hash($myhash, 'key', $hostkey);
3178 map(&add_content2xml_hash($myhash, 'client', @{$_}[0].",".@{$_}[4]), @$client_res);
3180 # add locally loaded gosa-si modules to registration message
3181 my $loaded_modules = {};
3182 while (my ($package, $pck_info) = each %$known_modules) {
3183 next if ((!defined(@$pck_info[2])) || (!(ref (@$pck_info[2]) eq 'HASH')));
3184 foreach my $act_module (keys(%{@$pck_info[2]})) {
3185 $loaded_modules->{$act_module} = "";
3186 }
3187 }
3189 map(&add_content2xml_hash($myhash, "loaded_modules", $_), keys(%$loaded_modules));
3191 # add macaddress to registration message
3192 my ($host_ip, $host_port) = split(/:/, $hostname);
3193 my $local_ip = &get_local_ip_for_remote_ip($host_ip);
3194 my $network_interface= &get_interface_for_ip($local_ip);
3195 my $host_mac = &get_mac_for_interface($network_interface);
3196 &add_content2xml_hash($myhash, 'macaddress', $host_mac);
3198 # build registration message and send it
3199 my $foreign_server_msg = &create_xml_string($myhash);
3200 my $error = &send_msg_to_target($foreign_server_msg, $hostname, $ServerPackages_key, "new_server", 0);
3201 }
3203 $kernel->delay_set("register_at_foreign_servers", $foreign_servers_register_delay);
3204 return;
3205 }
3208 #==== MAIN = main ==============================================================
3209 # parse commandline options
3210 Getopt::Long::Configure( "bundling" );
3211 GetOptions("h|help" => \&usage,
3212 "c|config=s" => \$cfg_file,
3213 "f|foreground" => \$foreground,
3214 "v|verbose+" => \$verbose,
3215 "no-arp+" => \$no_arp,
3216 );
3218 # read and set config parameters
3219 &check_cmdline_param ;
3220 &read_configfile($cfg_file, %cfg_defaults);
3221 &check_pid;
3223 $SIG{CHLD} = 'IGNORE';
3225 # forward error messages to logfile
3226 if( ! $foreground ) {
3227 open( STDIN, '+>/dev/null' );
3228 open( STDOUT, '+>&STDIN' );
3229 open( STDERR, '+>&STDIN' );
3230 }
3232 # Just fork, if we are not in foreground mode
3233 if( ! $foreground ) {
3234 chdir '/' or die "Can't chdir to /: $!";
3235 $pid = fork;
3236 setsid or die "Can't start a new session: $!";
3237 umask 0;
3238 } else {
3239 $pid = $$;
3240 }
3242 # Do something useful - put our PID into the pid_file
3243 if( 0 != $pid ) {
3244 open( LOCK_FILE, ">$pid_file" );
3245 print LOCK_FILE "$pid\n";
3246 close( LOCK_FILE );
3247 if( !$foreground ) {
3248 exit( 0 )
3249 };
3250 }
3252 # parse head url and revision from svn
3253 my $server_status_hash = { 'developmental'=>'revision', 'stable'=>'release'};
3254 $server_version =~ /^\$HeadURL: (\S+) \$:\$Rev: (\d+) \$$/;
3255 $server_headURL = defined $1 ? $1 : 'unknown' ;
3256 $server_revision = defined $2 ? $2 : 'unknown' ;
3257 if ($server_headURL =~ /\/tag\// ||
3258 $server_headURL =~ /\/branches\// ) {
3259 $server_status = "stable";
3260 } else {
3261 $server_status = "developmental" ;
3262 }
3263 # Prepare log file and set permissions
3264 $root_uid = getpwnam('root');
3265 $adm_gid = getgrnam('adm');
3266 open(FH, ">>$log_file");
3267 close FH;
3268 chmod(0440, $log_file);
3269 chown($root_uid, $adm_gid, $log_file);
3270 chown($root_uid, $adm_gid, "/var/lib/gosa-si");
3272 daemon_log(" ", 1);
3273 daemon_log("$0 started!", 1);
3274 daemon_log("status: $server_status", 1);
3275 daemon_log($server_status_hash->{$server_status}.": $server_revision", 1);
3277 # Create a pool of LDAP handles
3278 $ldap_factory = ResourcePool::Factory::Net::LDAP->new($ldap_uri, version => $ldap_version);
3279 $ldap_factory->bind($ldap_admin_dn, password=>$ldap_admin_password);
3280 $ldap_pool = ResourcePool->new($ldap_factory,
3281 Max => $max_ldap_handle,
3282 #MaxTry => 1,
3283 #SleepOnFail => [0, 0, 1, 1],
3284 PreCreate => $precreate_ldap_handle,
3285 );
3288 # Buildup data bases
3289 {
3290 no strict "refs";
3292 if ($db_module eq "DBmysql") {
3293 # connect to incoming_db
3294 $incoming_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3296 # connect to gosa-si job queue
3297 $job_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3299 # connect to known_clients_db
3300 $known_clients_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3302 # connect to foreign_clients_db
3303 $foreign_clients_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3305 # connect to known_server_db
3306 $known_server_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3308 # connect to login_usr_db
3309 $login_users_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3311 # connect to fai_server_db
3312 $fai_server_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3314 # connect to fai_release_db
3315 $fai_release_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3317 # connect to packages_list_db
3318 $packages_list_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3320 # connect to messaging_db
3321 $messaging_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3323 } elsif ($db_module eq "DBsqlite") {
3324 # connect to incoming_db
3325 unlink($incoming_file_name);
3326 $incoming_db = GOSA::DBsqlite->new($incoming_file_name);
3328 # connect to gosa-si job queue
3329 $job_db = GOSA::DBsqlite->new($job_queue_file_name);
3330 chmod(0640, $job_queue_file_name);
3331 chown($root_uid, $adm_gid, $job_queue_file_name);
3333 # connect to known_clients_db
3334 $known_clients_db = GOSA::DBsqlite->new($known_clients_file_name);
3335 chmod(0640, $known_clients_file_name);
3336 chown($root_uid, $adm_gid, $known_clients_file_name);
3338 # connect to foreign_clients_db
3339 unlink($foreign_clients_file_name);
3340 $foreign_clients_db = GOSA::DBsqlite->new($foreign_clients_file_name);
3341 chmod(0640, $foreign_clients_file_name);
3342 chown($root_uid, $adm_gid, $foreign_clients_file_name);
3344 # connect to known_server_db
3345 unlink($known_server_file_name);
3346 $known_server_db = GOSA::DBsqlite->new($known_server_file_name);
3347 chmod(0640, $known_server_file_name);
3348 chown($root_uid, $adm_gid, $known_server_file_name);
3350 # connect to login_usr_db
3351 unlink($login_users_file_name);
3352 $login_users_db = GOSA::DBsqlite->new($login_users_file_name);
3353 chmod(0640, $login_users_file_name);
3354 chown($root_uid, $adm_gid, $login_users_file_name);
3356 # connect to fai_server_db
3357 unlink($fai_server_file_name);
3358 $fai_server_db = GOSA::DBsqlite->new($fai_server_file_name);
3359 chmod(0640, $fai_server_file_name);
3360 chown($root_uid, $adm_gid, $fai_server_file_name);
3362 # connect to fai_release_db
3363 unlink($fai_release_file_name);
3364 $fai_release_db = GOSA::DBsqlite->new($fai_release_file_name);
3365 chmod(0640, $fai_release_file_name);
3366 chown($root_uid, $adm_gid, $fai_release_file_name);
3368 # connect to packages_list_db
3369 #unlink($packages_list_file_name);
3370 unlink($packages_list_under_construction);
3371 $packages_list_db = GOSA::DBsqlite->new($packages_list_file_name);
3372 chmod(0640, $packages_list_file_name);
3373 chown($root_uid, $adm_gid, $packages_list_file_name);
3375 # connect to messaging_db
3376 unlink($messaging_file_name);
3377 $messaging_db = GOSA::DBsqlite->new($messaging_file_name);
3378 chmod(0640, $messaging_file_name);
3379 chown($root_uid, $adm_gid, $messaging_file_name);
3380 }
3381 }
3384 # Creating tables
3385 $messaging_db->create_table($messaging_tn, \@messaging_col_names);
3386 $packages_list_db->create_table($packages_list_tn, \@packages_list_col_names);
3387 $fai_release_db->create_table($fai_release_tn, \@fai_release_col_names);
3388 $fai_server_db->create_table($fai_server_tn, \@fai_server_col_names);
3389 $login_users_db->create_table($login_users_tn, \@login_users_col_names);
3390 $known_server_db->create_table($known_server_tn, \@known_server_col_names);
3391 $foreign_clients_db->create_table($foreign_clients_tn, \@foreign_clients_col_names);
3392 $known_clients_db->create_table($known_clients_tn, \@known_clients_col_names);
3393 $incoming_db->create_table($incoming_tn, \@incoming_col_names);
3394 $job_db->create_table($job_queue_tn, \@job_queue_col_names);
3396 # create xml object used for en/decrypting
3397 $xml = new XML::Simple();
3400 # foreign servers
3401 my @foreign_server_list;
3403 # add foreign server from cfg file
3404 if ($foreign_server_string ne "") {
3405 my @cfg_foreign_server_list = split(",", $foreign_server_string);
3406 foreach my $foreign_server (@cfg_foreign_server_list) {
3407 push(@foreign_server_list, $foreign_server);
3408 }
3410 daemon_log("0 INFO: found foreign server in config file: ".join(", ", @foreign_server_list), 5);
3411 }
3413 # Perform a DNS lookup for server registration if flag is true
3414 if ($dns_lookup eq "true") {
3415 # Add foreign server from dns
3416 my @tmp_servers;
3417 if (not $server_domain) {
3418 # Try our DNS Searchlist
3419 for my $domain(get_dns_domains()) {
3420 chomp($domain);
3421 my ($tmp_domains, $error_string) = &get_server_addresses($domain);
3422 if(@$tmp_domains) {
3423 for my $tmp_server(@$tmp_domains) {
3424 push @tmp_servers, $tmp_server;
3425 }
3426 }
3427 }
3428 if(@tmp_servers && length(@tmp_servers)==0) {
3429 daemon_log("0 WARNING: no foreign gosa-si-server found in DNS for domain '$server_domain'", 3);
3430 }
3431 } else {
3432 @tmp_servers = &get_server_addresses($server_domain);
3433 if( 0 == @tmp_servers ) {
3434 daemon_log("0 WARNING: no foreign gosa-si-server found in DNS for domain '$server_domain'", 3);
3435 }
3436 }
3438 daemon_log("0 INFO: found foreign server via DNS ".join(", ", @tmp_servers), 5);
3440 foreach my $server (@tmp_servers) {
3441 unshift(@foreign_server_list, $server);
3442 }
3443 } else {
3444 daemon_log("0 INFO: DNS lookup for server registration is disabled", 5);
3445 }
3448 # eliminate duplicate entries
3449 @foreign_server_list = &del_doubles(@foreign_server_list);
3450 my $all_foreign_server = join(", ", @foreign_server_list);
3451 daemon_log("0 INFO: found foreign server in config file and DNS: '$all_foreign_server'", 5);
3453 # add all found foreign servers to known_server
3454 my $cur_timestamp = &get_time();
3455 foreach my $foreign_server (@foreign_server_list) {
3457 # do not add myself to known_server_db
3458 if (&is_local($foreign_server)) { next; }
3459 ######################################
3461 my $res = $known_server_db->add_dbentry( {table=>$known_server_tn,
3462 primkey=>['hostname'],
3463 hostname=>$foreign_server,
3464 macaddress=>"",
3465 status=>'not_yet_registered',
3466 hostkey=>"none",
3467 loaded_modules => "none",
3468 timestamp=>$cur_timestamp,
3469 } );
3470 }
3473 # Import all modules
3474 &import_modules;
3476 # Check wether all modules are gosa-si valid passwd check
3477 &password_check;
3479 # Prepare for using Opsi
3480 if ($opsi_enabled eq "true") {
3481 use JSON::RPC::Client;
3482 use XML::Quote qw(:all);
3483 $opsi_url= "https://".$opsi_admin.":".$opsi_password."@".$opsi_server.":4447/rpc";
3484 $opsi_client = new JSON::RPC::Client;
3485 }
3488 POE::Component::Server::TCP->new(
3489 Alias => "TCP_SERVER",
3490 Port => $server_port,
3491 ClientInput => sub {
3492 my ($kernel, $input, $heap, $session) = @_[KERNEL, ARG0, HEAP, SESSION];
3493 my $session_id = $session->ID;
3494 my $remote_ip = $heap->{'remote_ip'};
3495 push(@msgs_to_decrypt, $input);
3496 &daemon_log("$session_id DEBUG: incoming message from '$remote_ip'", 7);
3497 $kernel->yield("msg_to_decrypt");
3498 },
3499 InlineStates => {
3500 msg_to_decrypt => \&msg_to_decrypt,
3501 next_task => \&next_task,
3502 task_result => \&handle_task_result,
3503 task_done => \&handle_task_done,
3504 task_debug => \&handle_task_debug,
3505 child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!" },
3506 }
3507 );
3509 daemon_log("0 INFO: start socket for incoming xml messages at port '$server_port' ", 1);
3511 # create session for repeatedly checking the job queue for jobs
3512 POE::Session->create(
3513 inline_states => {
3514 _start => \&session_start,
3515 register_at_foreign_servers => \®ister_at_foreign_servers,
3516 sig_handler => \&sig_handler,
3517 next_task => \&next_task,
3518 task_result => \&handle_task_result,
3519 task_done => \&handle_task_done,
3520 task_debug => \&handle_task_debug,
3521 watch_for_next_tasks => \&watch_for_next_tasks,
3522 watch_for_new_messages => \&watch_for_new_messages,
3523 watch_for_delivery_messages => \&watch_for_delivery_messages,
3524 watch_for_done_messages => \&watch_for_done_messages,
3525 watch_for_new_jobs => \&watch_for_new_jobs,
3526 watch_for_modified_jobs => \&watch_for_modified_jobs,
3527 watch_for_done_jobs => \&watch_for_done_jobs,
3528 watch_for_opsi_jobs => \&watch_for_opsi_jobs,
3529 watch_for_old_known_clients => \&watch_for_old_known_clients,
3530 create_packages_list_db => \&run_create_packages_list_db,
3531 create_fai_server_db => \&run_create_fai_server_db,
3532 create_fai_release_db => \&run_create_fai_release_db,
3533 recreate_packages_db => \&run_recreate_packages_db,
3534 session_run_result => \&session_run_result,
3535 session_run_debug => \&session_run_debug,
3536 session_run_done => \&session_run_done,
3537 child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!" },
3538 }
3539 );
3542 POE::Kernel->run();
3543 exit;