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