![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
1 #!/usr/bin/perl
2 #===============================================================================
3 #
4 # FILE: gosa-si-server
5 #
6 # USAGE: ./gosa-si-server
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 clock_gettime );
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);
55 # revision number of server and program name
56 my $server_headURL;
57 my $server_revision;
58 my $server_status;
59 our $prg= basename($0);
60 our $verbose= 0;
62 my $db_module = "DBsqlite";
63 {
64 no strict "refs";
65 require ("GOSA/".$db_module.".pm");
66 ("GOSA/".$db_module)->import;
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 $arch,
99 );
101 # additional variable which should be globaly accessable
102 our $server_address;
103 our $server_mac_address;
104 our $gosa_address;
105 our $no_arp;
106 our $forground;
107 our $cfg_file;
108 our ($ldap_uri, $ldap_base, $ldap_admin_dn, $ldap_admin_password, $ldap_server_dn, $ldap_version, $ldap_retry_sec);
109 our ($mysql_username, $mysql_password, $mysql_database, $mysql_host);
110 our $known_modules;
111 our $known_functions;
112 our $root_uid;
113 our $adm_gid;
115 # if foreground is not null, script will be not forked to background
116 $foreground = 0 ;
118 # specifies the timeout seconds while checking the online status of a registrating client
119 $ping_timeout = 5;
121 $no_arp = 0;
122 my $packages_list_under_construction = "/tmp/packages_list_creation_in_progress";
123 my @packages_list_statements;
124 my $watch_for_new_jobs_in_progress = 0;
126 # holds all incoming decrypted messages
127 our $incoming_db;
128 our $incoming_tn = 'incoming';
129 my $incoming_file_name;
130 my @incoming_col_names = ("id INTEGER PRIMARY KEY",
131 "timestamp VARCHAR(14) DEFAULT 'none'",
132 "headertag VARCHAR(255) DEFAULT 'none'",
133 "targettag VARCHAR(255) DEFAULT 'none'",
134 "xmlmessage TEXT",
135 "module VARCHAR(255) DEFAULT 'none'",
136 "sessionid VARCHAR(255) DEFAULT '0'",
137 );
139 # holds all gosa jobs
140 our $job_db;
141 our $job_queue_tn = 'jobs';
142 my $job_queue_file_name;
143 my @job_queue_col_names = ("id INTEGER PRIMARY KEY",
144 "timestamp VARCHAR(14) DEFAULT 'none'",
145 "status VARCHAR(255) DEFAULT 'none'",
146 "result TEXT",
147 "progress VARCHAR(255) DEFAULT 'none'",
148 "headertag VARCHAR(255) DEFAULT 'none'",
149 "targettag VARCHAR(255) DEFAULT 'none'",
150 "xmlmessage TEXT",
151 "macaddress VARCHAR(17) DEFAULT 'none'",
152 "plainname VARCHAR(255) DEFAULT 'none'",
153 "siserver VARCHAR(255) DEFAULT 'none'",
154 "modified INTEGER DEFAULT '0'",
155 "periodic VARCHAR(6) DEFAULT 'none'",
156 );
158 # holds all other gosa-si-server
159 our $known_server_db;
160 our $known_server_tn = "known_server";
161 my $known_server_file_name;
162 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)");
164 # holds all registrated clients
165 our $known_clients_db;
166 our $known_clients_tn = "known_clients";
167 my $known_clients_file_name;
168 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)");
170 # holds all registered clients at a foreign server
171 our $foreign_clients_db;
172 our $foreign_clients_tn = "foreign_clients";
173 my $foreign_clients_file_name;
174 my @foreign_clients_col_names = ("hostname VARCHAR(255)", "macaddress VARCHAR(17)", "regserver VARCHAR(255)", "timestamp VARCHAR(14)");
176 # holds all logged in user at each client
177 our $login_users_db;
178 our $login_users_tn = "login_users";
179 my $login_users_file_name;
180 my @login_users_col_names = ("client VARCHAR(255)", "user VARCHAR(255)", "timestamp VARCHAR(14)", "regserver VARCHAR(255) DEFAULT 'localhost'");
182 # holds all fai server, the debian release and tag
183 our $fai_server_db;
184 our $fai_server_tn = "fai_server";
185 my $fai_server_file_name;
186 our @fai_server_col_names = ("timestamp VARCHAR(14)", "server VARCHAR(255)", "fai_release VARCHAR(255)", "sections VARCHAR(255)", "tag VARCHAR(255)");
188 our $fai_release_db;
189 our $fai_release_tn = "fai_release";
190 my $fai_release_file_name;
191 our @fai_release_col_names = ("timestamp VARCHAR(14)", "fai_release VARCHAR(255)", "class VARCHAR(255)", "type VARCHAR(255)", "state VARCHAR(255)");
193 # holds all packages available from different repositories
194 our $packages_list_db;
195 our $packages_list_tn = "packages_list";
196 my $packages_list_file_name;
197 our @packages_list_col_names = ("distribution VARCHAR(255)", "package VARCHAR(255)", "version VARCHAR(255)", "section VARCHAR(255)", "description TEXT", "template LONGBLOB", "timestamp VARCHAR(14)");
198 my $outdir = "/tmp/packages_list_db";
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 "debian-arch" => [\$arch, 'i386'],
253 "ldap-uri" => [\$ldap_uri, ""],
254 "ldap-base" => [\$ldap_base, ""],
255 "ldap-admin-dn" => [\$ldap_admin_dn, ""],
256 "ldap-admin-password" => [\$ldap_admin_password, ""],
257 "ldap-version" => [\$ldap_version, 3],
258 "ldap-retry-sec" => [\$ldap_retry_sec, 10],
259 "gosa-unit-tag" => [\$gosa_unit_tag, ""],
260 "max-clients" => [\$max_clients, 10],
261 "wol-password" => [\$wake_on_lan_passwd, ""],
262 "mysql-username" => [\$mysql_username, "gosa_si"],
263 "mysql-password" => [\$mysql_password, ""],
264 "mysql-database" => [\$mysql_database, "gosa_si"],
265 "mysql-host" => [\$mysql_host, "127.0.0.1"],
266 },
267 "GOsaPackages" => {
268 "job-queue" => [\$job_queue_file_name, '/var/lib/gosa-si/jobs.db'],
269 "job-queue-loop-delay" => [\$job_queue_loop_delay, 3],
270 "messaging-db-loop-delay" => [\$messaging_db_loop_delay, 3],
271 "key" => [\$GosaPackages_key, "none"],
272 "new-systems-ou" => [\$new_systems_ou, 'ou=workstations,ou=systems'],
273 },
274 "ClientPackages" => {
275 "key" => [\$ClientPackages_key, "none"],
276 "user-date-of-expiry" => [\$logged_in_user_date_of_expiry, 600],
277 },
278 "ServerPackages"=> {
279 "enabled" => [\$serverPackages_enabled, "true"],
280 "address" => [\$foreign_server_string, ""],
281 "dns-lookup" => [\$dns_lookup, "true"],
282 "domain" => [\$server_domain, ""],
283 "key" => [\$ServerPackages_key, "none"],
284 "key-lifetime" => [\$foreign_servers_register_delay, 120],
285 "job-synchronization-enabled" => [\$job_synchronization, "true"],
286 "synchronization-loop" => [\$modified_jobs_loop_delay, 5],
287 },
288 "ArpHandler" => {
289 "enabled" => [\$arp_enabled, "false"],
290 "interface" => [\$arp_interface, "all"],
291 },
292 "Opsi" => {
293 "enabled" => [\$opsi_enabled, "false"],
294 "server" => [\$opsi_server, "localhost"],
295 "admin" => [\$opsi_admin, "opsi-admin"],
296 "password" => [\$opsi_password, "secret"],
297 },
299 );
302 #=== FUNCTION ================================================================
303 # NAME: usage
304 # PARAMETERS: nothing
305 # RETURNS: nothing
306 # DESCRIPTION: print out usage text to STDERR
307 #===============================================================================
308 sub usage {
309 print STDERR << "EOF" ;
310 usage: $prg [-hvf] [-c config] [-d number]
312 -h : this (help) message
313 -c <file> : config file
314 -f : foreground, process will not be forked to background
315 -v : be verbose (multiple to increase verbosity)
316 'v': error logs
317 'vvv': warning plus error logs
318 'vvvvv': info plus warning logs
319 'vvvvvvv': debug plus info logs
320 -no-arp : starts $prg without connection to arp module
321 -d <int> : if verbose level is higher than 7x 'v' specified parts can be debugged
322 1 : report incoming messages
323 2 : report unencrypted outgoing messages
324 4 : report encrypting key for messages
325 8 : report decrypted incoming message and verification if the message complies gosa-si requirements
326 16 : message processing
327 32 : ldap connectivity
328 64 : database status and connectivity
329 128 : main process
330 256 : creation of packages_list_db
331 512 : ARP debug information
332 EOF
333 exit(0);
334 }
337 #=== FUNCTION ================================================================
338 # NAME: logging
339 # PARAMETERS: level - string - default 'info'
340 # msg - string -
341 # facility - string - default 'LOG_DAEMON'
342 # RETURNS: nothing
343 # DESCRIPTION: function for logging
344 #===============================================================================
345 sub daemon_log {
346 my( $msg, $level ) = @_;
347 if (not defined $msg) { return }
348 if (not defined $level) { $level = 1 }
349 my $to_be_logged = 0;
351 # Write log line if line level is lower than verbosity given in commandline
352 if ($level <= $verbose)
353 {
354 $to_be_logged = 1 ;
355 }
357 # Write if debug flag is set and bitstring matches
358 if ($debug_parts > 0)
359 {
360 my $tmp_level = ($level - 10 >= 0) ? $level - 10 : 0 ;
361 my $tmp_level_bitstring = unpack("B32", pack("N", $tmp_level));
362 if (int($debug_parts_bitstring & $tmp_level_bitstring))
363 {
364 $to_be_logged = 1;
365 }
366 }
368 if ($to_be_logged)
369 {
370 if(defined $log_file){
371 my $open_log_fh = sysopen(LOG_HANDLE, $log_file, O_WRONLY | O_CREAT | O_APPEND , 0440);
372 if(not $open_log_fh) {
373 print STDERR "cannot open $log_file: $!";
374 return;
375 }
376 # Check owner and group of log_file and update settings if necessary
377 my ($dev, $ino, $mode, $nlink, $uid, $gid, $rdev, $size, $atime, $mtime, $ctime, $blksize, $blocks) = stat($log_file);
378 if((not $uid eq $root_uid) || (not $gid eq $adm_gid)) {
379 chown($root_uid, $adm_gid, $log_file);
380 }
382 # Prepare time string for log message
383 my ($seconds,$minutes,$hours,$monthday,$month,$year,$weekday,$yearday,$sommertime) = localtime(time);
384 $hours = $hours < 10 ? $hours = "0".$hours : $hours;
385 $minutes = $minutes < 10 ? $minutes = "0".$minutes : $minutes;
386 $seconds = $seconds < 10 ? $seconds = "0".$seconds : $seconds;
387 $month = $monthnames[$month];
388 $monthday = $monthday < 10 ? $monthday = "0".$monthday : $monthday;
389 $year+=1900;
391 # Microseconds since epoch
392 my $microSeconds = sprintf("%.2f", &Time::HiRes::clock_gettime());
393 $microSeconds =~ s/^\d*(.\d\d)$/$1/;
395 # Build log message and write it to log file and commandline
396 chomp($msg);
397 my $log_msg = "$month $monthday $hours:$minutes:$seconds$microSeconds $prg $msg\n";
398 flock(LOG_HANDLE, LOCK_EX);
399 seek(LOG_HANDLE, 0, 2);
400 print LOG_HANDLE $log_msg;
401 flock(LOG_HANDLE, LOCK_UN);
402 if( $foreground )
403 {
404 print STDERR $log_msg;
405 }
406 close( LOG_HANDLE );
407 }
408 }
409 }
412 #=== FUNCTION ================================================================
413 # NAME: check_cmdline_param
414 # PARAMETERS: nothing
415 # RETURNS: nothing
416 # DESCRIPTION: validates commandline parameter
417 #===============================================================================
418 sub check_cmdline_param () {
419 my $err_counter = 0;
421 # Check configuration file
422 if(not defined($cfg_file)) {
423 $cfg_file = "/etc/gosa-si/server.conf";
424 if(! -r $cfg_file) {
425 print STDERR "Please specify a config file.\n";
426 $err_counter++;
427 }
428 }
430 # Prepare identification which gosa-si parts should be debugged and which not
431 if (defined $debug_parts)
432 {
433 if ($debug_parts =~ /^\d+$/)
434 {
435 $debug_parts_bitstring = unpack("B32", pack("N", $debug_parts));
436 }
437 else
438 {
439 print STDERR "Value '$debug_parts' invalid for option d (number expected)\n";
440 $err_counter++;
441 }
442 }
444 # Exit if an error occour
445 if( $err_counter > 0 ) { &usage( "", 1 ); }
446 }
449 #=== FUNCTION ================================================================
450 # NAME: check_pid
451 # PARAMETERS: nothing
452 # RETURNS: nothing
453 # DESCRIPTION: handels pid processing
454 #===============================================================================
455 sub check_pid {
456 $pid = -1;
457 # Check, if we are already running
458 if( open(LOCK_FILE, "<$pid_file") ) {
459 $pid = <LOCK_FILE>;
460 if( defined $pid ) {
461 chomp( $pid );
462 if( -f "/proc/$pid/stat" ) {
463 my($stat) = `cat /proc/$pid/stat` =~ m/$pid \((.+)\).*/;
464 if( $stat ) {
465 print STDERR "\nERROR: Already running!\n";
466 close( LOCK_FILE );
467 exit -1;
468 }
469 }
470 }
471 close( LOCK_FILE );
472 unlink( $pid_file );
473 }
475 # create a syslog msg if it is not to possible to open PID file
476 if (not sysopen(LOCK_FILE, $pid_file, O_WRONLY|O_CREAT|O_EXCL, 0644)) {
477 my($msg) = "Couldn't obtain lockfile '$pid_file' ";
478 if (open(LOCK_FILE, '<', $pid_file)
479 && ($pid = <LOCK_FILE>))
480 {
481 chomp($pid);
482 $msg .= "(PID $pid)\n";
483 } else {
484 $msg .= "(unable to read PID)\n";
485 }
486 if( ! ($foreground) ) {
487 openlog( $0, "cons,pid", "daemon" );
488 syslog( "warning", $msg );
489 closelog();
490 }
491 else {
492 print( STDERR " $msg " );
493 }
494 exit( -1 );
495 }
496 }
498 #=== FUNCTION ================================================================
499 # NAME: import_modules
500 # PARAMETERS: module_path - string - abs. path to the directory the modules
501 # are stored
502 # RETURNS: nothing
503 # DESCRIPTION: each file in module_path which ends with '.pm' and activation
504 # state is on is imported by "require 'file';"
505 #===============================================================================
506 sub import_modules {
507 if (not -e $modules_path) {
508 daemon_log("0 ERROR: cannot find directory or directory is not readable: $modules_path", 1);
509 }
511 opendir (DIR, $modules_path) or die "ERROR while loading modules from directory $modules_path : $!\n";
513 while (defined (my $file = readdir (DIR))) {
514 if (not $file =~ /(\S*?).pm$/) {
515 next;
516 }
517 my $mod_name = $1;
519 # ArpHandler switch
520 if( $file =~ /ArpHandler.pm/ ) {
521 if( $arp_enabled eq "false" ) { next; }
522 }
524 # ServerPackages switch
525 if ($file eq "ServerPackages.pm" && $serverPackages_enabled eq "false")
526 {
527 $dns_lookup = "false";
528 next;
529 }
531 eval { require $file; };
532 if ($@) {
533 daemon_log("0 ERROR: gosa-si-server could not load module $file", 1);
534 daemon_log("$@", 1);
535 exit;
536 } else {
537 my $info = eval($mod_name.'::get_module_info()');
538 # Only load module if get_module_info() returns a non-null object
539 if( $info ) {
540 my ($input_address, $input_key, $event_hash) = @{$info};
541 $known_modules->{$mod_name} = $info;
542 daemon_log("0 INFO: module $mod_name loaded", 5);
543 }
544 }
545 }
546 close (DIR);
547 }
549 #=== FUNCTION ================================================================
550 # NAME: password_check
551 # PARAMETERS: nothing
552 # RETURNS: nothing
553 # DESCRIPTION: escalates an critical error if two modules exist which are avaialable by
554 # the same password
555 #===============================================================================
556 sub password_check {
557 my $passwd_hash = {};
558 while (my ($mod_name, $mod_info) = each %$known_modules) {
559 my $mod_passwd = @$mod_info[1];
560 if (not defined $mod_passwd) { next; }
561 if (not exists $passwd_hash->{$mod_passwd}) {
562 $passwd_hash->{$mod_passwd} = $mod_name;
564 # escalates critical error
565 } else {
566 &daemon_log("0 ERROR: two loaded modules do have the same password. Please modify the 'key'-parameter in config file");
567 &daemon_log("0 ERROR: module='$mod_name' and module='".$passwd_hash->{$mod_passwd}."'");
568 exit( -1 );
569 }
570 }
572 }
575 #=== FUNCTION ================================================================
576 # NAME: sig_int_handler
577 # PARAMETERS: signal - string - signal arose from system
578 # RETURNS: nothing
579 # DESCRIPTION: handels tasks to be done befor signal becomes active
580 #===============================================================================
581 sub sig_int_handler {
582 my ($signal) = @_;
584 # if (defined($ldap_handle)) {
585 # $ldap_handle->disconnect;
586 # }
587 # TODO alle verbliebenden ldap verbindungen aus allen heaps beenden
590 daemon_log("shutting down gosa-si-server", 1);
591 system("kill `ps -C gosa-si-server -o pid=`");
592 }
593 $SIG{INT} = \&sig_int_handler;
596 sub check_key_and_xml_validity {
597 my ($crypted_msg, $module_key, $session_id) = @_;
598 my $msg;
599 my $msg_hash;
600 my $error_string;
601 eval{
602 $msg = &decrypt_msg($crypted_msg, $module_key);
604 if ($msg =~ /<xml>/i){
605 $msg =~ s/\s+/ /g; # just for better daemon_log
606 daemon_log("$session_id DEBUG: decrypted_msg: \n$msg", 18);
607 $msg_hash = $xml->XMLin($msg, ForceArray=>1);
609 ##############
610 # check header
611 if( not exists $msg_hash->{'header'} ) { die "no header specified"; }
612 my $header_l = $msg_hash->{'header'};
613 if( (1 > @{$header_l}) || ( ( 'HASH' eq ref @{$header_l}[0]) && (1 > keys %{@{$header_l}[0]}) ) ) { die 'empty header tag'; }
614 if( 1 < @{$header_l} ) { die 'more than one header specified'; }
615 my $header = @{$header_l}[0];
616 if( 0 == length $header) { die 'empty string in header tag'; }
618 ##############
619 # check source
620 if( not exists $msg_hash->{'source'} ) { die "no source specified"; }
621 my $source_l = $msg_hash->{'source'};
622 if( (1 > @{$source_l}) || ( ( 'HASH' eq ref @{$source_l}[0]) && (1 > keys %{@{$source_l}[0]}) ) ) { die 'empty source tag'; }
623 if( 1 < @{$source_l} ) { die 'more than one source specified'; }
624 my $source = @{$source_l}[0];
625 if( 0 == length $source) { die 'source error'; }
627 ##############
628 # check target
629 if( not exists $msg_hash->{'target'} ) { die "no target specified"; }
630 my $target_l = $msg_hash->{'target'};
631 if( (1 > @{$target_l}) || ( ('HASH' eq ref @{$target_l}[0]) && (1 > keys %{@{$target_l}[0]}) ) ) { die 'empty target tag'; }
632 }
633 };
634 if($@) {
635 daemon_log("$session_id ERROR: do not understand the message: $@", 1);
636 $msg = undef;
637 $msg_hash = undef;
638 }
640 return ($msg, $msg_hash);
641 }
644 sub check_outgoing_xml_validity {
645 my ($msg, $session_id) = @_;
647 my $msg_hash;
648 eval{
649 $msg_hash = $xml->XMLin($msg, ForceArray=>1);
651 ##############
652 # check header
653 my $header_l = $msg_hash->{'header'};
654 if( 1 != @{$header_l} ) {
655 die 'no or more than one headers specified';
656 }
657 my $header = @{$header_l}[0];
658 if( 0 == length $header) {
659 die 'header has length 0';
660 }
662 ##############
663 # check source
664 my $source_l = $msg_hash->{'source'};
665 if( 1 != @{$source_l} ) {
666 die 'no or more than 1 sources specified';
667 }
668 my $source = @{$source_l}[0];
669 if( 0 == length $source) {
670 die 'source has length 0';
671 }
673 # Check if source contains hostname instead of ip address
674 if($source =~ /^[a-z][\w\-\.]+:\d+$/i) {
675 my ($hostname,$port) = split(/:/, $source);
676 my $ip_address = inet_ntoa(scalar gethostbyname($hostname));
677 if(defined($ip_address) && $ip_address =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/ && $port =~ /^\d+$/) {
678 # Write ip address to $source variable
679 $source = "$ip_address:$port";
680 $msg_hash->{source}[0] = $source ;
681 $msg =~ s/<source>.*<\/source>/<source>$source<\/source>/;
682 }
683 }
684 unless( $source =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+$/ ||
685 $source =~ /^GOSA$/i) {
686 die "source '$source' is neither a complete ip-address with port nor 'GOSA'";
687 }
689 ##############
690 # check target
691 my $target_l = $msg_hash->{'target'};
692 if( 0 == @{$target_l} ) {
693 die "no targets specified";
694 }
695 foreach my $target (@$target_l) {
696 if( 0 == length $target) {
697 die "target has length 0";
698 }
699 unless( $target =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+$/ ||
700 $target =~ /^GOSA$/i ||
701 $target =~ /^\*$/ ||
702 $target =~ /KNOWN_SERVER/i ||
703 $target =~ /JOBDB/i ||
704 $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 ){
705 die "target '$target' is not a complete ip-address with port or a valid target name or a mac-address";
706 }
707 }
708 };
709 if($@) {
710 daemon_log("$session_id ERROR: outgoing msg is not gosa-si envelope conform: $@", 1);
711 daemon_log("$@ ".(defined($msg) && length($msg)>0)?$msg:"Empty Message", 1);
712 $msg_hash = undef;
713 }
715 return ($msg, $msg_hash);
716 }
719 sub input_from_known_server {
720 my ($input, $remote_ip, $session_id) = @_ ;
721 my ($msg, $msg_hash, $module);
723 my $sql_statement= "SELECT * FROM known_server";
724 my $query_res = $known_server_db->select_dbentry( $sql_statement );
726 while( my ($hit_num, $hit) = each %{ $query_res } ) {
727 my $host_name = $hit->{hostname};
728 if( not $host_name =~ "^$remote_ip") {
729 next;
730 }
731 my $host_key = $hit->{hostkey};
732 daemon_log("$session_id DEBUG: input_from_known_server: host_name: $host_name", 14);
733 daemon_log("$session_id DEBUG: input_from_known_server: host_key: $host_key", 14);
735 # check if module can open msg envelope with module key
736 my ($tmp_msg, $tmp_msg_hash) = &check_key_and_xml_validity($input, $host_key, $session_id);
737 if( (!$tmp_msg) || (!$tmp_msg_hash) ) {
738 daemon_log("$session_id DEBUG: input_from_known_server: deciphering raise error", 14);
739 daemon_log("$@", 14);
740 next;
741 }
742 else {
743 $msg = $tmp_msg;
744 $msg_hash = $tmp_msg_hash;
745 $module = "ServerPackages";
746 daemon_log("$session_id DEBUG: check_key_and_xml_validity... ok", 14);
747 last;
748 }
749 }
751 if( (!$msg) || (!$msg_hash) || (!$module) ) {
752 daemon_log("$session_id DEBUG: Incoming message is not from a known server", 14);
753 }
755 return ($msg, $msg_hash, $module);
756 }
759 sub input_from_known_client {
760 my ($input, $remote_ip, $session_id) = @_ ;
761 my ($msg, $msg_hash, $module);
763 my $sql_statement= "SELECT * FROM known_clients";
764 my $query_res = $known_clients_db->select_dbentry( $sql_statement );
765 while( my ($hit_num, $hit) = each %{ $query_res } ) {
766 my $host_name = $hit->{hostname};
767 if( not $host_name =~ /^$remote_ip/) {
768 next;
769 }
770 my $host_key = $hit->{hostkey};
771 &daemon_log("$session_id DEBUG: input_from_known_client: host_name: $host_name", 14);
772 &daemon_log("$session_id DEBUG: input_from_known_client: host_key: $host_key", 14);
774 # check if module can open msg envelope with module key
775 ($msg, $msg_hash) = &check_key_and_xml_validity($input, $host_key, $session_id);
777 if( (!$msg) || (!$msg_hash) ) {
778 &daemon_log("$session_id DEGUG: input_from_known_client: deciphering raise error", 14);
779 next;
780 }
781 else {
782 $module = "ClientPackages";
783 daemon_log("$session_id DEBUG: check_key_and_xml_validity... ok", 14);
784 last;
785 }
786 }
788 if( (!$msg) || (!$msg_hash) || (!$module) ) {
789 &daemon_log("$session_id DEBUG: Incoming message is not from a known client", 14);
790 }
792 return ($msg, $msg_hash, $module);
793 }
796 sub input_from_unknown_host {
797 no strict "refs";
798 my ($input, $session_id) = @_ ;
799 my ($msg, $msg_hash, $module);
800 my $error_string;
802 my %act_modules = %$known_modules;
804 while( my ($mod, $info) = each(%act_modules)) {
806 # check a key exists for this module
807 my $module_key = ${$mod."_key"};
808 if( not defined $module_key ) {
809 if( $mod eq 'ArpHandler' ) {
810 next;
811 }
812 daemon_log("$session_id ERROR: no key specified in config file for $mod", 1);
813 next;
814 }
815 daemon_log("$session_id DEBUG: $mod: $module_key", 14);
817 # check if module can open msg envelope with module key
818 ($msg, $msg_hash) = &check_key_and_xml_validity($input, $module_key, $session_id);
819 if( (not defined $msg) || (not defined $msg_hash) ) {
820 next;
821 } else {
822 $module = $mod;
823 daemon_log("$session_id DEBUG: check_key_and_xml_validity... ok", 18);
824 last;
825 }
826 }
828 if( (!$msg) || (!$msg_hash) || (!$module)) {
829 daemon_log("$session_id DEBUG: Incoming message is not from an unknown host", 14);
830 }
832 return ($msg, $msg_hash, $module);
833 }
836 sub create_ciphering {
837 my ($passwd) = @_;
838 if((!defined($passwd)) || length($passwd)==0) {
839 $passwd = "";
840 }
841 $passwd = substr(md5_hex("$passwd") x 32, 0, 32);
842 my $iv = substr(md5_hex('GONICUS GmbH'),0, 16);
843 my $my_cipher = Crypt::Rijndael->new($passwd , Crypt::Rijndael::MODE_CBC());
844 $my_cipher->set_iv($iv);
845 return $my_cipher;
846 }
849 sub encrypt_msg {
850 my ($msg, $key) = @_;
851 my $my_cipher = &create_ciphering($key);
852 my $len;
853 {
854 use bytes;
855 $len= 16-length($msg)%16;
856 }
857 $msg = "\0"x($len).$msg;
858 $msg = $my_cipher->encrypt($msg);
859 chomp($msg = &encode_base64($msg));
860 # there are no newlines allowed inside msg
861 $msg=~ s/\n//g;
862 return $msg;
863 }
866 sub decrypt_msg {
868 my ($msg, $key) = @_ ;
869 $msg = &decode_base64($msg);
870 my $my_cipher = &create_ciphering($key);
871 $msg = $my_cipher->decrypt($msg);
872 $msg =~ s/\0*//g;
873 return $msg;
874 }
877 sub get_encrypt_key {
878 my ($target) = @_ ;
879 my $encrypt_key;
880 my $error = 0;
882 # target can be in known_server
883 if( not defined $encrypt_key ) {
884 my $sql_statement= "SELECT * FROM known_server WHERE hostname='$target'";
885 my $query_res = $known_server_db->select_dbentry( $sql_statement );
886 while( my ($hit_num, $hit) = each %{ $query_res } ) {
887 my $host_name = $hit->{hostname};
888 if( $host_name ne $target ) {
889 next;
890 }
891 $encrypt_key = $hit->{hostkey};
892 last;
893 }
894 }
896 # target can be in known_client
897 if( not defined $encrypt_key ) {
898 my $sql_statement= "SELECT * FROM known_clients WHERE hostname='$target'";
899 my $query_res = $known_clients_db->select_dbentry( $sql_statement );
900 while( my ($hit_num, $hit) = each %{ $query_res } ) {
901 my $host_name = $hit->{hostname};
902 if( $host_name ne $target ) {
903 next;
904 }
905 $encrypt_key = $hit->{hostkey};
906 last;
907 }
908 }
910 return $encrypt_key;
911 }
914 #=== FUNCTION ================================================================
915 # NAME: open_socket
916 # PARAMETERS: PeerAddr string something like 192.168.1.1 or 192.168.1.1:10000
917 # [PeerPort] string necessary if port not appended by PeerAddr
918 # RETURNS: socket IO::Socket::INET
919 # DESCRIPTION: open a socket to PeerAddr
920 #===============================================================================
921 sub open_socket {
922 my ($PeerAddr, $PeerPort) = @_ ;
923 if(defined($PeerPort)){
924 $PeerAddr = $PeerAddr.":".$PeerPort;
925 }
926 my $socket;
927 $socket = new IO::Socket::INET(PeerAddr => $PeerAddr,
928 Porto => "tcp",
929 Type => SOCK_STREAM,
930 Timeout => 5,
931 );
932 if(not defined $socket) {
933 return;
934 }
935 # &daemon_log("DEBUG: open_socket: $PeerAddr", 7);
936 return $socket;
937 }
940 sub send_msg_to_target {
941 my ($msg, $address, $encrypt_key, $msg_header, $session_id) = @_ ;
942 my $error = 0;
943 my $header;
944 my $timestamp = &get_time();
945 my $new_status;
946 my $act_status;
947 my ($sql_statement, $res);
949 if( $msg_header ) {
950 $header = "'$msg_header'-";
951 } else {
952 $header = "";
953 }
955 # Memorize own source address
956 my $own_source_address = &get_local_ip_for_remote_ip(sprintf("%s", $address =~ /^([0-9\.]*?):.*$/));
957 $own_source_address .= ":".$server_port;
959 # Patch 0.0.0.0 source to real address
960 $msg =~ s/<source>(0\.0\.0\.0):(\d*?)<\/source>/<source>$own_source_address<\/source>/s;
961 # Patch GOSA source to real address and add forward_to_gosa tag
962 $msg =~ s/<source>GOSA<\/source>/<source>$own_source_address<\/source> <forward_to_gosa>$own_source_address,$session_id<\/forward_to_gosa>/ ;
964 # encrypt xml msg
965 my $crypted_msg = &encrypt_msg($msg, $encrypt_key);
967 # opensocket
968 my $socket = &open_socket($address);
969 if( !$socket ) {
970 daemon_log("$session_id ERROR: Cannot open socket to host '$address'. Message processing aborted!", 1);
971 $error++;
972 }
974 if( $error == 0 ) {
975 # send xml msg
976 print $socket $crypted_msg.";$own_source_address\n";
977 daemon_log("$session_id INFO: send ".$header."msg to $address", 5);
978 daemon_log("$session_id DEBUG: message:\n$msg", 12);
980 }
982 # close socket in any case
983 if( $socket ) {
984 close $socket;
985 }
987 if( $error > 0 ) { $new_status = "down"; }
988 else { $new_status = $msg_header; }
991 # known_clients
992 $sql_statement = "SELECT * FROM $known_clients_tn WHERE hostname='$address'";
993 $res = $known_clients_db->select_dbentry($sql_statement);
994 if( keys(%$res) == 1) {
995 $act_status = exists $res->{1}->{'status'} ? $res->{1}->{'status'} : "";
996 if ($act_status eq "down" && $new_status eq "down") {
997 $sql_statement = "DELETE FROM known_clients WHERE hostname='$address'";
998 $res = $known_clients_db->del_dbentry($sql_statement);
999 daemon_log("$session_id WARNING: failed 2x to send msg to host '$address', delete host from known_clients", 3);
1000 } else {
1001 $sql_statement = "UPDATE known_clients SET status='$new_status', timestamp='$timestamp' WHERE hostname='$address'";
1002 $res = $known_clients_db->update_dbentry($sql_statement);
1003 if($new_status eq "down"){
1004 daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
1005 } else {
1006 daemon_log("$session_id DEBUG: set '$address' from status '$act_status' to '$new_status'", 138);
1007 }
1008 }
1009 }
1011 # known_server
1012 $sql_statement = "SELECT * FROM $known_server_tn WHERE hostname='$address'";
1013 $res = $known_server_db->select_dbentry($sql_statement);
1014 if( keys(%$res) == 1) {
1015 $act_status = exists $res->{1}->{'status'} ? $res->{1}->{'status'} : "";
1016 if ($act_status eq "down" && $new_status eq "down") {
1017 $sql_statement = "DELETE FROM known_server WHERE hostname='$address'";
1018 $res = $known_server_db->del_dbentry($sql_statement);
1019 daemon_log("$session_id WARNING: failed 2x to send a message to host '$address', delete host from known_server", 3);
1020 }
1021 else {
1022 $sql_statement = "UPDATE known_server SET status='$new_status', timestamp='$timestamp' WHERE hostname='$address'";
1023 $res = $known_server_db->update_dbentry($sql_statement);
1024 if($new_status eq "down"){
1025 daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
1026 } else {
1027 daemon_log("$session_id DEBUG: set '$address' from status '$act_status' to '$new_status'", 138);
1028 }
1029 }
1030 }
1031 return $error;
1032 }
1035 sub update_jobdb_status_for_send_msgs {
1036 my ($session_id, $answer, $error) = @_;
1037 if( $answer =~ /<jobdb_id>(\d+)<\/jobdb_id>/ ) {
1038 &daemon_log("$session_id DEBUG: try to update job status", 138);
1039 my $jobdb_id = $1;
1041 $answer =~ /<header>(.*)<\/header>/;
1042 my $job_header = $1;
1044 $answer =~ /<target>(.*)<\/target>/;
1045 my $job_target = $1;
1047 # Sending msg failed
1048 if( $error ) {
1050 # Set jobs to done, jobs do not need to deliver their message in any case
1051 if (($job_header eq "trigger_action_localboot")
1052 ||($job_header eq "trigger_action_lock")
1053 ||($job_header eq "trigger_action_halt")
1054 ) {
1055 my $sql_statement = "UPDATE $job_queue_tn SET status='done' WHERE id=$jobdb_id";
1056 my $res = $job_db->update_dbentry($sql_statement);
1058 # Reactivate jobs, jobs need to deliver their message
1059 } elsif (($job_header eq "trigger_action_activate")
1060 ||($job_header eq "trigger_action_update")
1061 ||($job_header eq "trigger_action_reinstall")
1062 ||($job_header eq "trigger_activate_new")
1063 ) {
1064 if ($job_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) {
1065 &reactivate_job_with_delay($session_id, $job_target, $job_header, 30 );
1066 } else {
1067 # If we don't have the mac adress at this time, we use the plainname
1068 my $plainname_result = $job_db->select_dbentry("SELECT plainname from jobs where id=$jobdb_id");
1069 my $plainname = $job_target;
1070 if ((keys(%$plainname_result) > 0) ) {
1071 $plainname = $plainname_result->{1}->{$job_target};
1072 }
1073 &reactivate_job_with_delay($session_id, $plainname, $job_header, 30 );
1074 }
1075 # For all other messages
1076 } else {
1077 my $sql_statement = "UPDATE $job_queue_tn ".
1078 "SET status='error', result='can not deliver msg, please consult log file' ".
1079 "WHERE id=$jobdb_id";
1080 my $res = $job_db->update_dbentry($sql_statement);
1081 }
1083 # Sending msg was successful
1084 } else {
1085 # Set jobs localboot, lock, activate, halt, reboot and wake to done
1086 # jobs reinstall, update, inst_update do themself setting to done
1087 if (($job_header eq "trigger_action_localboot")
1088 ||($job_header eq "trigger_action_lock")
1089 ||($job_header eq "trigger_action_activate")
1090 ||($job_header eq "trigger_action_halt")
1091 ||($job_header eq "trigger_action_reboot")
1092 ||($job_header eq "trigger_action_wake")
1093 ||($job_header eq "trigger_wake")
1094 ) {
1096 my $sql_statement = "UPDATE $job_queue_tn ".
1097 "SET status='done' ".
1098 "WHERE id=$jobdb_id AND status='processed'";
1099 my $res = $job_db->update_dbentry($sql_statement);
1100 } else {
1101 &daemon_log("$session_id DEBUG: sending message succeed but cannot update job status.", 138);
1102 }
1103 }
1104 } else {
1105 &daemon_log("$session_id DEBUG: cannot update job status, msg has no jobdb_id-tag.", 138);
1106 }
1107 }
1109 sub reactivate_job_with_delay {
1110 my ($session_id, $target, $header, $delay) = @_ ;
1111 # 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
1113 if (not defined $delay) { $delay = 30 } ;
1114 my $delay_timestamp = &calc_timestamp(&get_time(), "plus", $delay);
1116 my $sql = "UPDATE $job_queue_tn Set timestamp='$delay_timestamp', status='waiting' WHERE (macaddress LIKE '$target' OR plainname LIKE '$target') AND headertag='$header'";
1117 my $res = $job_db->update_dbentry($sql);
1118 daemon_log("$session_id INFO: '$header'-job will be reactivated at '$delay_timestamp' ".
1119 "cause client '$target' is currently not available", 5);
1120 return;
1121 }
1124 sub sig_handler {
1125 my ($kernel, $signal) = @_[KERNEL, ARG0] ;
1126 daemon_log("0 INFO got signal '$signal'", 1);
1127 $kernel->sig_handled();
1128 return;
1129 }
1132 sub msg_to_decrypt {
1133 my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];
1134 my $session_id = $session->ID;
1135 my ($msg, $msg_hash, $module);
1136 my $error = 0;
1138 # fetch new msg out of @msgs_to_decrypt
1139 my $tmp_next_msg = shift @msgs_to_decrypt;
1140 my ($next_msg, $msg_source) = split(/;/, $tmp_next_msg);
1142 # msg is from a new client or gosa
1143 ($msg, $msg_hash, $module) = &input_from_unknown_host($next_msg, $session_id);
1145 # msg is from a gosa-si-server
1146 if(((!$msg) || (!$msg_hash) || (!$module)) && ($serverPackages_enabled eq "true")){
1147 if (not defined $msg_source)
1148 {
1149 # Only needed, to be compatible with older gosa-si-server versions
1150 ($msg, $msg_hash, $module) = &input_from_known_server($next_msg, $heap->{'remote_ip'}, $session_id);
1151 }
1152 else
1153 {
1154 ($msg, $msg_hash, $module) = &input_from_known_server($next_msg, $msg_source, $session_id);
1155 }
1156 }
1157 # msg is from a gosa-si-client
1158 if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1159 if (not defined $msg_source)
1160 {
1161 # Only needed, to be compatible with older gosa-si-server versions
1162 ($msg, $msg_hash, $module) = &input_from_known_client($next_msg, $heap->{'remote_ip'}, $session_id);
1163 }
1164 else
1165 {
1166 ($msg, $msg_hash, $module) = &input_from_known_client($next_msg, $msg_source, $session_id);
1167 }
1168 }
1169 # an error occurred
1170 if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1171 # If an incoming msg could not be decrypted (maybe a wrong key), decide if msg comes from a client
1172 # or a server. In case of a client, send a ping. If the client could not understand a msg from its
1173 # server the client cause a re-registering process. In case of a server, decrease update_time in kown_server_db
1174 # and trigger a re-registering process for servers
1175 if (defined $msg_source && $msg_source =~ /:$server_port$/ && $serverPackages_enabled eq "true")
1176 {
1177 daemon_log("$session_id WARNING: Cannot understand incoming msg from server '$msg_source'. Cause re-registration process for servers.", 3);
1178 my $update_statement = "UPDATE $known_server_tn SET update_time='19700101000000' WHERE hostname='$msg_source'";
1179 daemon_log("$session_id DEBUG: $update_statement", 7);
1180 my $upadte_res = $known_server_db->exec_statement($update_statement);
1181 $kernel->yield("register_at_foreign_servers");
1182 }
1183 elsif ((defined $msg_source) && (not $msg_source =~ /:$server_port$/))
1184 {
1185 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);
1186 #my $remote_ip = $heap->{'remote_ip'};
1187 #my $remote_port = $heap->{'remote_port'};
1188 my $ping_msg = "<xml> <header>gosa_ping</header> <source>$server_address</source><target>$msg_source</target></xml>";
1189 my ($test_error, $test_error_string) = &send_msg_to_target($ping_msg, "$msg_source", "dummy-key", "gosa_ping", $session_id);
1190 daemon_log("$session_id WARNING: Sending msg to cause re-registering: $ping_msg", 3);
1191 }
1192 else
1193 {
1194 my $foreign_host = defined $msg_source ? $msg_source : $heap->{'remote_ip'};
1195 daemon_log("$session_id ERROR: Incoming message from host '$foreign_host' cannot be understood. Processing aborted!", 1);
1196 daemon_log("$session_id DEBUG: Aborted message: $tmp_next_msg", 11);
1197 }
1199 $error++
1200 }
1203 my $header;
1204 my $target;
1205 my $source;
1206 my $done = 0;
1207 my $sql;
1208 my $res;
1210 # check whether this message should be processed here
1211 if ($error == 0) {
1212 $header = @{$msg_hash->{'header'}}[0];
1213 $target = @{$msg_hash->{'target'}}[0];
1214 $source = @{$msg_hash->{'source'}}[0];
1215 my $not_found_in_known_clients_db = 0;
1216 my $not_found_in_known_server_db = 0;
1217 my $not_found_in_foreign_clients_db = 0;
1218 my $local_address;
1219 my $local_mac;
1220 my ($target_ip, $target_port) = split(':', $target);
1222 # Determine the local ip address if target is an ip address
1223 if ($target =~ /^\d+\.\d+\.\d+\.\d+:\d+$/) {
1224 $local_address = &get_local_ip_for_remote_ip($target_ip).":$server_port";
1225 } else {
1226 $local_address = $server_address;
1227 }
1229 # Determine the local mac address if target is a mac address
1230 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) {
1231 my $loc_ip = &get_local_ip_for_remote_ip($heap->{'remote_ip'});
1232 my $network_interface= &get_interface_for_ip($loc_ip);
1233 $local_mac = &get_mac_for_interface($network_interface);
1234 } else {
1235 $local_mac = $server_mac_address;
1236 }
1238 # target and source is equal to GOSA -> process here
1239 if (not $done) {
1240 if ($target eq "GOSA" && $source eq "GOSA") {
1241 $done = 1;
1242 &daemon_log("$session_id DEBUG: target and source is 'GOSA' -> process '$header' here", 11);
1243 }
1244 }
1246 # target is own address without forward_to_gosa-tag -> process here
1247 if (not $done) {
1248 #if ((($target eq $local_address) || ($target eq $local_mac) ) && (not exists $msg_hash->{'forward_to_gosa'})) {
1249 if (($target eq $local_address) && (not exists $msg_hash->{'forward_to_gosa'})) {
1250 $done = 1;
1251 if ($source eq "GOSA") {
1252 $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1253 }
1254 &daemon_log("$session_id DEBUG: target is own address without forward_to_gosa-tag -> process '$header' here", 11);
1255 }
1256 }
1258 # target is own address with forward_to_gosa-tag not pointing to myself -> process here
1259 if (not $done) {
1260 my $forward_to_gosa = @{$msg_hash->{'forward_to_gosa'}}[0];
1261 my $gosa_at;
1262 my $gosa_session_id;
1263 if (($target eq $local_address) && (defined $forward_to_gosa)){
1264 my ($gosa_at, $gosa_session_id) = split(/,/, $forward_to_gosa);
1265 if ($gosa_at ne $local_address) {
1266 $done = 1;
1267 &daemon_log("$session_id DEBUG: target is own address with forward_to_gosa-tag not pointing to myself -> process '$header' here", 11);
1268 }
1269 }
1270 }
1272 # Target is a client address and there is a processing function within a plugin -> process loaclly
1273 if (not $done)
1274 {
1275 # Check if target is a client address
1276 $sql = "SELECT * FROM $known_clients_tn WHERE (hostname='$target' OR macaddress LIKE '$target')";
1277 $res = $known_clients_db->select_dbentry($sql);
1278 if ((keys(%$res) > 0) )
1279 {
1280 my $hostname = $res->{1}->{'hostname'};
1281 my $reduced_header = $header;
1282 $reduced_header =~ s/gosa_//;
1283 # Check if there is a processing function within a plugin
1284 if (exists $known_functions->{$reduced_header})
1285 {
1286 $msg =~ s/<target>\S*<\/target>/<target>$hostname<\/target>/;
1287 $done = 1;
1288 &daemon_log("$session_id DEBUG: Target is client address with processing function within a plugin -> process '$header' here", 11);
1289 }
1290 }
1291 }
1293 # If header has a 'job_' prefix, do always process message locally
1294 # which means put it into job queue
1295 if ((not $done) && ($header =~ /job_/))
1296 {
1297 $done = 1;
1298 &daemon_log("$session_id DEBUG: Header has a 'job_' prefix. Put it into job queue. -> process '$header' here", 11);
1299 }
1301 # if message should be processed here -> add message to incoming_db
1302 if ($done) {
1303 # if a 'job_' or a 'gosa_' message comes from a foreign server, fake module from
1304 # ServerPackages to GosaPackages so gosa-si-server knows how to process this kind of messages
1305 if ($header =~ /^gosa_/ || $header =~ /^job_/) {
1306 $module = "GosaPackages";
1307 }
1309 my $res = $incoming_db->add_dbentry( {table=>$incoming_tn,
1310 primkey=>[],
1311 headertag=>$header,
1312 targettag=>$target,
1313 xmlmessage=>&encode_base64($msg),
1314 timestamp=>&get_time,
1315 module=>$module,
1316 sessionid=>$session_id,
1317 } );
1318 $kernel->yield('watch_for_next_tasks');
1319 }
1321 # target is own address with forward_to_gosa-tag pointing at myself -> forward to gosa
1322 if (not $done) {
1323 my $forward_to_gosa = @{$msg_hash->{'forward_to_gosa'}}[0];
1324 my $gosa_at;
1325 my $gosa_session_id;
1326 if (($target eq $local_address) && (defined $forward_to_gosa)){
1327 my ($gosa_at, $gosa_session_id) = split(/,/, $forward_to_gosa);
1328 if ($gosa_at eq $local_address) {
1329 my $session_reference = $kernel->ID_id_to_session($gosa_session_id);
1330 if( defined $session_reference ) {
1331 $heap = $session_reference->get_heap();
1332 }
1333 if(exists $heap->{'client'}) {
1334 $msg = &encrypt_msg($msg, $GosaPackages_key);
1335 $heap->{'client'}->put($msg);
1336 &daemon_log("$session_id DEBUG: incoming '$header' message forwarded to GOsa", 11);
1337 }
1338 $done = 1;
1339 &daemon_log("$session_id DEBUG: target is own address with forward_to_gosa-tag pointing at myself -> forward '$header' to gosa", 11);
1340 }
1341 }
1343 }
1345 # target is a client address in known_clients -> forward to client
1346 if (not $done) {
1347 $sql = "SELECT * FROM $known_clients_tn WHERE (hostname='$target' OR macaddress LIKE '$target')";
1348 $res = $known_clients_db->select_dbentry($sql);
1349 if (keys(%$res) > 0)
1350 {
1351 $done = 1;
1352 &daemon_log("$session_id DEBUG: target is a client address in known_clients -> forward '$header' to client", 11);
1353 my $hostkey = $res->{1}->{'hostkey'};
1354 my $hostname = $res->{1}->{'hostname'};
1355 $msg =~ s/<target>\S*<\/target>/<target>$hostname<\/target>/;
1356 $msg =~ s/<header>gosa_/<header>/;
1357 my $error= &send_msg_to_target($msg, $hostname, $hostkey, $header, $session_id);
1358 if ($error) {
1359 &daemon_log("$session_id ERROR: Some problems occurred while trying to send msg to client '$hostname': $msg", 1);
1360 }
1361 }
1362 else
1363 {
1364 $not_found_in_known_clients_db = 1;
1365 }
1366 }
1368 # target is a client address in foreign_clients -> forward to registration server
1369 if (not $done) {
1370 $sql = "SELECT * FROM $foreign_clients_tn WHERE (hostname='$target' OR macaddress LIKE '$target')";
1371 $res = $foreign_clients_db->select_dbentry($sql);
1372 if (keys(%$res) > 0) {
1373 my $hostname = $res->{1}->{'hostname'};
1374 my ($host_ip, $host_port) = split(/:/, $hostname);
1375 my $local_address = &get_local_ip_for_remote_ip($host_ip).":$server_port";
1376 my $regserver = $res->{1}->{'regserver'};
1377 my $sql = "SELECT * FROM $known_server_tn WHERE hostname='$regserver'";
1378 my $res = $known_server_db->select_dbentry($sql);
1379 if (keys(%$res) > 0) {
1380 my $regserver_key = $res->{1}->{'hostkey'};
1381 $msg =~ s/<source>GOSA<\/source>/<source>$local_address<\/source>/;
1382 $msg =~ s/<target>$target<\/target>/<target>$hostname<\/target>/;
1383 if ($source eq "GOSA") {
1384 $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1385 }
1386 my $error= &send_msg_to_target($msg, $regserver, $regserver_key, $header, $session_id);
1387 if ($error) {
1388 &daemon_log("$session_id ERROR: some problems occurred while trying to send msg to registration server: $msg", 1);
1389 }
1390 }
1391 $done = 1;
1392 &daemon_log("$session_id DEBUG: target is a client address in foreign_clients -> forward '$header' to registration server", 11);
1393 } else {
1394 $not_found_in_foreign_clients_db = 1;
1395 }
1396 }
1398 # target is a server address -> forward to server
1399 if (not $done) {
1400 $sql = "SELECT * FROM $known_server_tn WHERE (hostname='$target' OR macaddress LIKE '$target')";
1401 $res = $known_server_db->select_dbentry($sql);
1402 if (keys(%$res) > 0) {
1403 my $hostkey = $res->{1}->{'hostkey'};
1405 if ($source eq "GOSA") {
1406 $msg =~ s/<source>GOSA<\/source>/<source>$local_address<\/source>/;
1407 $msg =~ s/<\/xml>/<forward_to_gosa>$local_address,$session_id<\/forward_to_gosa><\/xml>/;
1409 }
1411 &send_msg_to_target($msg, $target, $hostkey, $header, $session_id);
1412 $done = 1;
1413 &daemon_log("$session_id DEBUG: target is a server address -> forward '$header' to server", 11);
1414 } else {
1415 $not_found_in_known_server_db = 1;
1416 }
1417 }
1420 # target is not in foreign_clients_db, known_server_db or known_clients_db, maybe it is a complete new one -> process here
1421 if ( $not_found_in_foreign_clients_db
1422 && $not_found_in_known_server_db
1423 && $not_found_in_known_clients_db) {
1424 &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);
1425 if ($header =~ /^gosa_/ || $header =~ /^job_/) {
1426 $module = "GosaPackages";
1427 }
1428 my $res = $incoming_db->add_dbentry( {table=>$incoming_tn,
1429 primkey=>[],
1430 headertag=>$header,
1431 targettag=>$target,
1432 xmlmessage=>&encode_base64($msg),
1433 timestamp=>&get_time,
1434 module=>$module,
1435 sessionid=>$session_id,
1436 } );
1437 $done = 1;
1438 $kernel->yield('watch_for_next_tasks');
1439 }
1442 if (not $done) {
1443 daemon_log("$session_id ERROR: do not know what to do with this message: $msg", 1);
1444 if ($source eq "GOSA") {
1445 my %data = ('error_msg' => &encode_base64($msg), 'error_string' => "Do not know what to do with this message!");
1446 my $error_msg = &build_msg("error", $local_address, "GOSA", \%data );
1448 my $session_reference = $kernel->ID_id_to_session($session_id);
1449 if( defined $session_reference ) {
1450 $heap = $session_reference->get_heap();
1451 }
1452 if(exists $heap->{'client'}) {
1453 $error_msg = &encrypt_msg($error_msg, $GosaPackages_key);
1454 $heap->{'client'}->put($error_msg);
1455 }
1456 }
1457 }
1459 }
1461 return;
1462 }
1465 sub next_task {
1466 my ($session, $heap, $task) = @_[SESSION, HEAP, ARG0, ARG1];
1467 my $running_task = POE::Wheel::Run->new(
1468 Program => sub { process_task($session, $heap, $task) },
1469 StdioFilter => POE::Filter::Reference->new(),
1470 StdoutEvent => "task_result",
1471 StderrEvent => "task_debug",
1472 CloseEvent => "task_done",
1473 );
1474 $heap->{task}->{ $running_task->ID } = $running_task;
1475 }
1477 sub handle_task_result {
1478 my ($kernel, $heap, $result) = @_[KERNEL, HEAP, ARG0];
1479 my $client_answer = $result->{'answer'};
1480 if( $client_answer =~ s/session_id=(\d+)$// ) {
1481 my $session_id = $1;
1482 if( defined $session_id ) {
1483 my $session_reference = $kernel->ID_id_to_session($session_id);
1484 if( defined $session_reference ) {
1485 $heap = $session_reference->get_heap();
1486 }
1487 }
1489 if(exists $heap->{'client'}) {
1490 $heap->{'client'}->put($client_answer);
1491 }
1492 }
1493 $kernel->sig(CHLD => "child_reap");
1494 }
1496 sub handle_task_debug {
1497 my $result = $_[ARG0];
1498 print STDERR "$result\n";
1499 }
1501 sub handle_task_done {
1502 my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
1503 delete $heap->{task}->{$task_id};
1504 if (exists $heap->{ldap_handle}->{$task_id}) {
1505 &release_ldap_handle($heap->{ldap_handle}->{$task_id});
1506 }
1507 }
1509 sub process_task {
1510 no strict "refs";
1511 #CHECK: Not @_[...]?
1512 my ($session, $heap, $task) = @_;
1513 my $error = 0;
1514 my $answer_l;
1515 my ($answer_header, @answer_target_l, $answer_source);
1516 my $client_answer = "";
1518 # prepare all variables needed to process message
1519 #my $msg = $task->{'xmlmessage'};
1520 my $msg = &decode_base64($task->{'xmlmessage'});
1521 my $incoming_id = $task->{'id'};
1522 my $module = $task->{'module'};
1523 my $header = $task->{'headertag'};
1524 my $session_id = $task->{'sessionid'};
1525 my $msg_hash;
1526 eval {
1527 $msg_hash = $xml->XMLin($msg, ForceArray=>1);
1528 };
1529 daemon_log("ERROR: XML failure '$@'") if ($@);
1530 my $source = @{$msg_hash->{'source'}}[0];
1532 # set timestamp of incoming client uptodate, so client will not
1533 # be deleted from known_clients because of expiration
1534 my $cur_time = &get_time();
1535 my $sql = "UPDATE $known_clients_tn SET timestamp='$cur_time' WHERE hostname='$source'";
1536 my $res = $known_clients_db->exec_statement($sql);
1538 ######################
1539 # process incoming msg
1540 if( $error == 0) {
1541 daemon_log("$session_id INFO: Incoming msg (session_id=$session_id) with header '".@{$msg_hash->{'header'}}[0]."'", 5);
1542 daemon_log("$session_id DEBUG: Processing module ".$module, 26);
1543 $answer_l = &{ $module."::process_incoming_msg" }($msg, $msg_hash, $session_id);
1545 if ( 0 < @{$answer_l} ) {
1546 my $answer_str = join("\n", @{$answer_l});
1547 my @headers;
1548 while ($answer_str =~ /<header>(\w+)<\/header>/g) {
1549 push(@headers, $1);
1550 }
1551 daemon_log("$session_id DEBUG: got answer message(s) with header: '".join("', '", @headers)."'", 26);
1552 } else {
1553 daemon_log("$session_id DEBUG: $module: got no answer from module!" ,26);
1554 }
1556 }
1557 if( !$answer_l ) { $error++ };
1559 ########
1560 # answer
1561 if( $error == 0 ) {
1563 foreach my $answer ( @{$answer_l} ) {
1564 # check outgoing msg to xml validity
1565 my ($answer, $answer_hash) = &check_outgoing_xml_validity($answer, $session_id);
1566 if( not defined $answer_hash ) { next; }
1568 $answer_header = @{$answer_hash->{'header'}}[0];
1569 @answer_target_l = @{$answer_hash->{'target'}};
1570 $answer_source = @{$answer_hash->{'source'}}[0];
1572 # deliver msg to all targets
1573 foreach my $answer_target ( @answer_target_l ) {
1575 # targets of msg are all gosa-si-clients in known_clients_db
1576 if( $answer_target eq "*" ) {
1577 # answer is for all clients
1578 my $sql_statement= "SELECT * FROM known_clients";
1579 my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1580 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1581 my $host_name = $hit->{hostname};
1582 my $host_key = $hit->{hostkey};
1583 my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1584 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1585 }
1586 }
1588 # targets of msg are all gosa-si-server in known_server_db
1589 elsif( $answer_target eq "KNOWN_SERVER" ) {
1590 # answer is for all server in known_server
1591 my $sql_statement= "SELECT * FROM $known_server_tn";
1592 my $query_res = $known_server_db->select_dbentry( $sql_statement );
1593 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1594 my $host_name = $hit->{hostname};
1595 my $host_key = $hit->{hostkey};
1596 $answer =~ s/<target>\S+<\/target>/<target>$host_name<\/target>/g;
1597 my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1598 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1599 }
1600 }
1602 # target of msg is GOsa
1603 elsif( $answer_target eq "GOSA" ) {
1604 my $session_id = ($1) if $answer =~ /<session_id>(\d+?)<\/session_id>/;
1605 my $add_on = "";
1606 if( defined $session_id ) {
1607 $add_on = ".session_id=$session_id";
1608 }
1609 my $header = ($1) if $answer =~ /<header>(\S*)<\/header>/;
1610 daemon_log("$session_id INFO: send ".$header." message to GOsa", 5);
1611 daemon_log("$session_id DEBUG: message:\n$answer", 12);
1612 # answer is for GOSA and has to returned to connected client
1613 my $gosa_answer = &encrypt_msg($answer, $GosaPackages_key);
1614 $client_answer = $gosa_answer.$add_on;
1615 }
1617 # target of msg is job queue at this host
1618 elsif( $answer_target eq "JOBDB") {
1619 $answer =~ /<header>(\S+)<\/header>/;
1620 my $header;
1621 if( defined $1 ) { $header = $1; }
1622 my $error = &send_msg_to_target($answer, $server_address, $GosaPackages_key, $header, $session_id);
1623 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1624 }
1626 # Target of msg is a mac address
1627 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 ) {
1628 daemon_log("$session_id DEBUG: target is mac address '$answer_target', looking for host in known_clients and foreign_clients", 138);
1630 # Looking for macaddress in known_clients
1631 my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$answer_target'";
1632 my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1633 my $found_ip_flag = 0;
1634 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1635 my $host_name = $hit->{hostname};
1636 my $host_key = $hit->{hostkey};
1637 $answer =~ s/$answer_target/$host_name/g;
1638 daemon_log("$session_id INFO: found host '$host_name', associated to '$answer_target'", 5);
1639 my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1640 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1641 $found_ip_flag++ ;
1642 }
1644 # Looking for macaddress in foreign_clients
1645 if ($found_ip_flag == 0) {
1646 my $sql = "SELECT * FROM $foreign_clients_tn WHERE macaddress LIKE '$answer_target'";
1647 my $res = $foreign_clients_db->select_dbentry($sql);
1648 while( my ($hit_num, $hit) = each %{ $res } ) {
1649 my $host_name = $hit->{hostname};
1650 my $reg_server = $hit->{regserver};
1651 daemon_log("$session_id INFO: found host '$host_name' with mac '$answer_target', registered at '$reg_server'", 5);
1653 # Fetch key for reg_server
1654 my $reg_server_key;
1655 my $sql = "SELECT * FROM $known_server_tn WHERE hostname='$reg_server'";
1656 my $res = $known_server_db->select_dbentry($sql);
1657 if (exists $res->{1}) {
1658 $reg_server_key = $res->{1}->{'hostkey'};
1659 } else {
1660 daemon_log("$session_id ERROR: cannot find hostkey for '$host_name' in '$known_server_tn'", 1);
1661 daemon_log("$session_id ERROR: unable to forward answer to correct registration server, processing is aborted!", 1);
1662 $reg_server_key = undef;
1663 }
1665 # Send answer to server where client is registered
1666 if (defined $reg_server_key) {
1667 $answer =~ s/$answer_target/$host_name/g;
1668 my $error = &send_msg_to_target($answer, $reg_server, $reg_server_key, $answer_header, $session_id);
1669 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1670 $found_ip_flag++ ;
1671 }
1672 }
1673 }
1675 # No mac to ip matching found
1676 if( $found_ip_flag == 0) {
1677 daemon_log("$session_id WARNING: no host found in known_clients or foreign_clients with mac address '$answer_target'", 3);
1678 &reactivate_job_with_delay($session_id, $answer_target, $answer_header, 30);
1679 }
1681 # Answer is for one specific host
1682 } else {
1683 # get encrypt_key
1684 my $encrypt_key = &get_encrypt_key($answer_target);
1685 if( not defined $encrypt_key ) {
1686 # unknown target
1687 daemon_log("$session_id WARNING: unknown target '$answer_target'", 3);
1688 next;
1689 }
1690 my $error = &send_msg_to_target($answer, $answer_target, $encrypt_key, $answer_header,$session_id);
1691 &update_jobdb_status_for_send_msgs($session_id, $answer, $error);
1692 }
1693 }
1694 }
1695 }
1697 my $filter = POE::Filter::Reference->new();
1698 my %result = (
1699 status => "seems ok to me",
1700 answer => $client_answer,
1701 );
1703 my $output = $filter->put( [ \%result ] );
1704 print @$output;
1707 }
1709 sub session_start {
1710 my ($kernel) = $_[KERNEL];
1711 $global_kernel = $kernel;
1712 $kernel->yield('register_at_foreign_servers');
1713 $kernel->yield('create_fai_server_db', $fai_server_tn );
1714 $kernel->yield('create_fai_release_db', $fai_release_tn );
1715 $kernel->sig(USR1 => "sig_handler");
1716 $kernel->sig(USR2 => "recreate_packages_db");
1717 $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
1718 $kernel->delay_set('watch_for_done_jobs', $job_queue_loop_delay);
1719 $kernel->delay_set('watch_for_modified_jobs', $modified_jobs_loop_delay);
1720 $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
1721 $kernel->delay_set('watch_for_delivery_messages', $messaging_db_loop_delay);
1722 $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
1723 $kernel->delay_set('watch_for_old_known_clients', $job_queue_loop_delay);
1725 # Start opsi check
1726 if ($opsi_enabled eq "true") {
1727 $kernel->delay_set('watch_for_opsi_jobs', $job_queue_opsi_delay);
1728 }
1730 }
1733 sub watch_for_done_jobs {
1734 my $kernel = $_[KERNEL];
1736 my $sql_statement = "SELECT * FROM ".$job_queue_tn." WHERE ((status='done') AND (modified='0'))";
1737 my $res = $job_db->select_dbentry( $sql_statement );
1739 while( my ($number, $hit) = each %{$res} )
1740 {
1741 # Non periodical jobs can be deleted.
1742 if ($hit->{periodic} eq "none")
1743 {
1744 my $jobdb_id = $hit->{id};
1745 my $sql_statement = "DELETE FROM $job_queue_tn WHERE id=$jobdb_id";
1746 my $res = $job_db->del_dbentry($sql_statement);
1747 }
1749 # Periodical jobs should not be deleted but reactivated with new timestamp instead.
1750 else
1751 {
1752 my ($p_time, $periodic) = split("_", $hit->{periodic});
1753 my $reactivated_ts = $hit->{timestamp};
1754 my $act_ts = int(&get_time());
1755 while ($act_ts > int($reactivated_ts)) # Redo calculation to avoid multiple jobs in the past
1756 {
1757 $reactivated_ts = &calc_timestamp($reactivated_ts, "plus", $p_time, $periodic);
1758 }
1759 my $sql = "UPDATE $job_queue_tn SET status='waiting', timestamp='$reactivated_ts' WHERE id='".$hit->{id}."'";
1760 my $res = $job_db->exec_statement($sql);
1761 &daemon_log("J INFO: Update periodical job '".$hit->{headertag}."' for client '".$hit->{targettag}."'. New execution time '$reactivated_ts'.", 5);
1762 }
1763 }
1765 $kernel->delay_set('watch_for_done_jobs',$job_queue_loop_delay);
1766 }
1769 sub watch_for_opsi_jobs {
1770 my ($kernel) = $_[KERNEL];
1771 # 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
1772 # opsi install job is to parse the xml message. There is still the correct header.
1773 my $sql_statement = "SELECT * FROM ".$job_queue_tn." WHERE ((xmlmessage LIKE '%opsi_install_client</header>%') AND (status='processing') AND (siserver='localhost'))";
1774 my $res = $job_db->select_dbentry( $sql_statement );
1776 # Ask OPSI for an update of the running jobs
1777 while (my ($id, $hit) = each %$res ) {
1778 # Determine current parameters of the job
1779 my $hostId = $hit->{'plainname'};
1780 my $macaddress = $hit->{'macaddress'};
1781 my $progress = $hit->{'progress'};
1783 my $result= {};
1785 # For hosts, only return the products that are or get installed
1786 my $callobj;
1787 $callobj = {
1788 method => 'getProductStates_hash',
1789 params => [ $hostId ],
1790 id => 1,
1791 };
1793 my $hres = $opsi_client->call($opsi_url, $callobj);
1794 # TODO : move all opsi relevant statments to opsi plugin
1795 # The following 3 lines must be tested befor they can replace the rubbish above and below !!!
1796 #my ($res, $err) = &opsi_com::_getProductStates_hash(hostId=>$hostId)
1797 #if (not $err) {
1798 # my $htmp = $res->{$hostId};
1799 #
1800 if (not &check_opsi_res($hres)) {
1801 my $htmp= $hres->result->{$hostId};
1802 # Check state != not_installed or action == setup -> load and add
1803 my $products= 0;
1804 my $installed= 0;
1805 my $installing = 0;
1806 my $error= 0;
1807 my @installed_list;
1808 my @error_list;
1809 my $act_status = "none";
1810 foreach my $product (@{$htmp}){
1812 if ($product->{'installationStatus'} ne "not_installed" or
1813 $product->{'actionRequest'} eq "setup"){
1815 # Increase number of products for this host
1816 $products++;
1818 if ($product->{'installationStatus'} eq "failed"){
1819 $result->{$product->{'productId'}}= "error";
1820 unshift(@error_list, $product->{'productId'});
1821 $error++;
1822 }
1823 if ($product->{'installationStatus'} eq "installed" && $product->{'actionRequest'} eq "none"){
1824 $result->{$product->{'productId'}}= "installed";
1825 unshift(@installed_list, $product->{'productId'});
1826 $installed++;
1827 }
1828 if ($product->{'installationStatus'} eq "installing"){
1829 $result->{$product->{'productId'}}= "installing";
1830 $installing++;
1831 $act_status = "installing - ".$product->{'productId'};
1832 }
1833 }
1834 }
1836 # Estimate "rough" progress, avoid division by zero
1837 if ($products == 0) {
1838 $result->{'progress'}= 0;
1839 } else {
1840 $result->{'progress'}= int($installed * 100 / $products);
1841 }
1843 # Set updates in job queue
1844 if ((not $error) && (not $installing) && ($installed)) {
1845 $act_status = "installed - ".join(", ", @installed_list);
1846 }
1847 if ($error) {
1848 $act_status = "error - ".join(", ", @error_list);
1849 }
1850 if ($progress ne $result->{'progress'} ) {
1851 # Updating progress and result
1852 my $update_statement = "UPDATE $job_queue_tn SET modified='1', progress='".$result->{'progress'}."', result='$act_status' WHERE macaddress LIKE '$macaddress' AND siserver='localhost'";
1853 my $update_res = $job_db->update_dbentry($update_statement);
1854 }
1855 if ($progress eq 100) {
1856 # Updateing status
1857 my $done_statement = "UPDATE $job_queue_tn SET modified='1', ";
1858 if ($error) {
1859 $done_statement .= "status='error'";
1860 } else {
1861 $done_statement .= "status='done'";
1862 }
1863 $done_statement .= " WHERE macaddress LIKE '$macaddress' AND siserver='localhost'";
1864 my $done_res = $job_db->update_dbentry($done_statement);
1865 }
1868 }
1869 }
1871 $kernel->delay_set('watch_for_opsi_jobs', $job_queue_opsi_delay);
1872 }
1875 # If a job got an update or was modified anyway, send to all other si-server an update message of this jobs.
1876 sub watch_for_modified_jobs {
1877 my ($kernel,$heap) = @_[KERNEL, HEAP];
1879 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE (modified='1')";
1880 my $res = $job_db->select_dbentry( $sql_statement );
1882 # if db contains no jobs which should be update, do nothing
1883 if (keys %$res != 0) {
1885 if ($job_synchronization eq "true") {
1886 # make out of the db result a gosa-si message
1887 my $update_msg = &db_res2si_msg ($res, "foreign_job_updates", "KNOWN_SERVER", "MY_LOCAL_ADDRESS");
1889 # update all other SI-server
1890 &inform_all_other_si_server($update_msg);
1891 }
1893 # set jobs all jobs to modified = 0, wait until the next modification for updates of other si-server
1894 $sql_statement = "UPDATE $job_queue_tn SET modified='0' ";
1895 $res = $job_db->update_dbentry($sql_statement);
1896 }
1898 $kernel->delay_set('watch_for_modified_jobs', $modified_jobs_loop_delay);
1899 }
1902 sub watch_for_new_jobs {
1903 if($watch_for_new_jobs_in_progress == 0) {
1904 $watch_for_new_jobs_in_progress = 1;
1905 my ($kernel,$heap) = @_[KERNEL, HEAP];
1907 # check gosa job queue for jobs with executable timestamp
1908 my $timestamp = &get_time();
1909 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE siserver='localhost' AND status='waiting' AND (CAST(timestamp AS UNSIGNED)) < $timestamp ORDER BY timestamp";
1910 my $res = $job_db->exec_statement( $sql_statement );
1912 # Merge all new jobs that would do the same actions
1913 my @drops;
1914 my $hits;
1915 foreach my $hit (reverse @{$res} ) {
1916 my $macaddress= lc @{$hit}[8];
1917 my $headertag= @{$hit}[5];
1918 if(
1919 defined($hits->{$macaddress}) &&
1920 defined($hits->{$macaddress}->{$headertag}) &&
1921 defined($hits->{$macaddress}->{$headertag}[0])
1922 ) {
1923 push @drops, "DELETE FROM $job_queue_tn WHERE id = $hits->{$macaddress}->{$headertag}[0]";
1924 }
1925 $hits->{$macaddress}->{$headertag}= $hit;
1926 }
1928 # Delete new jobs with a matching job in state 'processing'
1929 foreach my $macaddress (keys %{$hits}) {
1930 foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
1931 my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
1932 if(defined($jobdb_id)) {
1933 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND headertag='$jobdb_headertag' AND status='processing'";
1934 my $res = $job_db->exec_statement( $sql_statement );
1935 foreach my $hit (@{$res}) {
1936 push @drops, "DELETE FROM $job_queue_tn WHERE id=$jobdb_id";
1937 }
1938 } else {
1939 daemon_log("J ERROR: Job without id exists for macaddress $macaddress!", 1);
1940 }
1941 }
1942 }
1944 # Commit deletion
1945 $job_db->exec_statementlist(\@drops);
1947 # Look for new jobs that could be executed
1948 foreach my $macaddress (keys %{$hits}) {
1950 # Look if there is an executing job
1951 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND status='processing'";
1952 my $res = $job_db->exec_statement( $sql_statement );
1954 # Skip new jobs for host if there is a processing job
1955 if(defined($res) and defined @{$res}[0]) {
1956 # Prevent race condition if there is a trigger_activate job waiting and a goto-activation job processing
1957 my $row = @{$res}[0] if (ref $res eq 'ARRAY');
1958 if(@{$row}[5] eq 'trigger_action_reinstall') {
1959 my $sql_statement_2 = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND status='waiting' AND headertag = 'trigger_activate_new'";
1960 my $res_2 = $job_db->exec_statement( $sql_statement_2 );
1961 if(defined($res_2) and defined @{$res_2}[0]) {
1962 # Set status from goto-activation to 'waiting' and update timestamp
1963 $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'");
1964 }
1965 }
1966 next;
1967 }
1969 foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
1970 my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
1971 if(defined($jobdb_id)) {
1972 my $job_msg = @{$hits->{$macaddress}->{$jobdb_headertag}}[7];
1974 daemon_log("J DEBUG: its time to execute $job_msg", 7);
1975 my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$macaddress'";
1976 my $res_hash = $known_clients_db->select_dbentry( $sql_statement );
1978 # expect macaddress is unique!!!!!!
1979 my $target = $res_hash->{1}->{hostname};
1981 # change header
1982 $job_msg =~ s/<header>job_/<header>gosa_/;
1984 # add sqlite_id
1985 $job_msg =~ s/<\/xml>$/<jobdb_id>$jobdb_id<\/jobdb_id><\/xml>/;
1987 $job_msg =~ /<header>(\S+)<\/header>/;
1988 my $header = $1 ;
1989 my $func_error = &send_msg_to_target($job_msg, $server_address, $GosaPackages_key, $header, "J");
1991 # update status in job queue to ...
1992 # ... 'processing', for jobs: 'reinstall', 'update', activate_new
1993 if (($header =~ /gosa_trigger_action_reinstall/)
1994 || ($header =~ /gosa_trigger_activate_new/)
1995 || ($header =~ /gosa_trigger_action_update/)) {
1996 my $sql_statement = "UPDATE $job_queue_tn SET status='processing' WHERE id=$jobdb_id";
1997 my $dbres = $job_db->update_dbentry($sql_statement);
1998 }
2000 # ... 'done', for all other jobs, they are no longer needed in the jobqueue
2001 else {
2002 my $sql_statement = "UPDATE $job_queue_tn SET status='done' WHERE id=$jobdb_id";
2003 my $dbres = $job_db->exec_statement($sql_statement);
2004 }
2007 # We don't want parallel processing
2008 last;
2009 }
2010 }
2011 }
2013 $watch_for_new_jobs_in_progress = 0;
2014 $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
2015 }
2016 }
2019 sub watch_for_new_messages {
2020 my ($kernel,$heap) = @_[KERNEL, HEAP];
2021 my @coll_user_msg; # collection list of outgoing messages
2023 # check messaging_db for new incoming messages with executable timestamp
2024 my $timestamp = &get_time();
2025 my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( (CAST(timestamp AS UNSIGNED))<$timestamp AND flag='n' AND direction='in' )";
2026 my $res = $messaging_db->exec_statement( $sql_statement );
2027 foreach my $hit (@{$res}) {
2029 # create outgoing messages
2030 my $message_to = @{$hit}[3];
2031 # translate message_to to plain login name
2032 my @message_to_l = split(/,/, $message_to);
2033 my %receiver_h;
2034 foreach my $receiver (@message_to_l) {
2035 if ($receiver =~ /^u_([\s\S]*)$/) {
2036 $receiver_h{$1} = 0;
2037 } elsif ($receiver =~ /^g_([\s\S]*)$/) {
2038 my $group_name = $1;
2039 # fetch all group members from ldap and add them to receiver hash
2040 my $ldap_handle = &get_ldap_handle();
2041 if (defined $ldap_handle) {
2042 my $mesg = $ldap_handle->search(
2043 base => $ldap_base,
2044 scope => 'sub',
2045 attrs => ['memberUid'],
2046 filter => "cn=$group_name",
2047 );
2048 if ($mesg->count) {
2049 my @entries = $mesg->entries;
2050 foreach my $entry (@entries) {
2051 my @receivers= $entry->get_value("memberUid");
2052 foreach my $receiver (@receivers) {
2053 $receiver_h{$receiver} = 0;
2054 }
2055 }
2056 }
2057 # translating errors ?
2058 if ($mesg->code) {
2059 daemon_log("M ERROR: unable to translate group '$group_name' to user list for message delivery: $mesg->error", 1);
2060 }
2061 &release_ldap_handle($ldap_handle);
2062 # ldap handle error ?
2063 } else {
2064 daemon_log("M ERROR: unable to translate group '$group_name' to user list for message delivery: no ldap handle available", 1);
2065 }
2066 } else {
2067 my $sbjct = &encode_base64(@{$hit}[1]);
2068 my $msg = &encode_base64(@{$hit}[7]);
2069 &daemon_log("M WARNING: unknown receiver '$receiver' for a user-message '$sbjct - $msg'", 3);
2070 }
2071 }
2072 my @receiver_l = keys(%receiver_h);
2074 my $message_id = @{$hit}[0];
2076 #add each outgoing msg to messaging_db
2077 my $receiver;
2078 foreach $receiver (@receiver_l) {
2079 my $sql_statement = "INSERT INTO $messaging_tn (id, subject, message_from, message_to, flag, direction, delivery_time, message, timestamp) ".
2080 "VALUES ('".
2081 $message_id."', '". # id
2082 @{$hit}[1]."', '". # subject
2083 @{$hit}[2]."', '". # message_from
2084 $receiver."', '". # message_to
2085 "none"."', '". # flag
2086 "out"."', '". # direction
2087 @{$hit}[6]."', '". # delivery_time
2088 @{$hit}[7]."', '". # message
2089 $timestamp."'". # timestamp
2090 ")";
2091 &daemon_log("M DEBUG: $sql_statement", 1);
2092 my $res = $messaging_db->exec_statement($sql_statement);
2093 &daemon_log("M INFO: message '".@{$hit}[0]."' is prepared for delivery to receiver '$receiver'", 5);
2094 }
2096 # set incoming message to flag d=deliverd
2097 $sql_statement = "UPDATE $messaging_tn SET flag='p' WHERE id='$message_id'";
2098 &daemon_log("M DEBUG: $sql_statement", 7);
2099 $res = $messaging_db->update_dbentry($sql_statement);
2100 &daemon_log("M INFO: message '$message_id' is set to flag 'p' (processed)", 5);
2101 }
2103 $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
2104 return;
2105 }
2107 sub watch_for_delivery_messages {
2108 my ($kernel, $heap) = @_[KERNEL, HEAP];
2110 # select outgoing messages
2111 my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( flag='p' AND direction='out' )";
2112 my $res = $messaging_db->exec_statement( $sql_statement );
2114 # build out msg for each usr
2115 foreach my $hit (@{$res}) {
2116 my $receiver = @{$hit}[3];
2117 my $msg_id = @{$hit}[0];
2118 my $subject = @{$hit}[1];
2119 my $message = @{$hit}[7];
2121 # resolve usr -> host where usr is logged in
2122 my $sql = "SELECT * FROM $login_users_tn WHERE (user='$receiver')";
2123 my $res = $login_users_db->exec_statement($sql);
2125 # receiver is logged in nowhere
2126 if (not ref(@$res[0]) eq "ARRAY") { next; }
2128 # receiver ist logged in at a client registered at local server
2129 my $send_succeed = 0;
2130 foreach my $hit (@$res) {
2131 my $receiver_host = @$hit[0];
2132 my $delivered2host = 0;
2133 &daemon_log("M DEBUG: user '$receiver' is logged in at host '$receiver_host'", 7);
2135 # Looking for host in know_clients_db
2136 my $sql = "SELECT * FROM $known_clients_tn WHERE (hostname='$receiver_host')";
2137 my $res = $known_clients_db->exec_statement($sql);
2139 # Host is known in known_clients_db
2140 if (ref(@$res[0]) eq "ARRAY") {
2141 my $receiver_key = @{@{$res}[0]}[2];
2142 my %data = ('subject' => $subject, 'message' => $message, 'usr' => $receiver);
2143 my $out_msg = &build_msg("usr_msg", $server_address, $receiver_host, \%data );
2144 my $error = &send_msg_to_target($out_msg, $receiver_host, $receiver_key, "usr_msg", 0);
2145 if ($error == 0 ) {
2146 $send_succeed++ ;
2147 $delivered2host++ ;
2148 &daemon_log("M DEBUG: send message for user '$receiver' to host '$receiver_host'", 7);
2149 } else {
2150 &daemon_log("M DEBUG: cannot send message for user '$receiver' to host '$receiver_host'", 7);
2151 }
2152 }
2154 # Message already send, do not need to do anything more, otherwise ...
2155 if ($delivered2host) { next;}
2157 # ...looking for host in foreign_clients_db
2158 $sql = "SELECT * FROM $foreign_clients_tn WHERE (hostname='$receiver_host')";
2159 $res = $foreign_clients_db->exec_statement($sql);
2161 # Host is known in foreign_clients_db
2162 if (ref(@$res[0]) eq "ARRAY") {
2163 my $registration_server = @{@{$res}[0]}[2];
2165 # Fetch encryption key for registration server
2166 my $sql = "SELECT * FROM $known_server_tn WHERE (hostname='$registration_server')";
2167 my $res = $known_server_db->exec_statement($sql);
2168 if (ref(@$res[0]) eq "ARRAY") {
2169 my $registration_server_key = @{@{$res}[0]}[3];
2170 my %data = ('subject' => $subject, 'message' => $message, 'usr' => $receiver);
2171 my $out_msg = &build_msg("usr_msg", $server_address, $receiver_host, \%data );
2172 my $error = &send_msg_to_target($out_msg, $registration_server, $registration_server_key, "usr_msg", 0);
2173 if ($error == 0 ) {
2174 $send_succeed++ ;
2175 $delivered2host++ ;
2176 &daemon_log("M DEBUG: send message for user '$receiver' to server '$registration_server'", 7);
2177 } else {
2178 &daemon_log("M ERROR: cannot send message for user '$receiver' to server '$registration_server'", 1);
2179 }
2181 } else {
2182 &daemon_log("M ERROR: host '$receiver_host' is reported to be ".
2183 "registrated at server '$registration_server', ".
2184 "but no data available in known_server_db ", 1);
2185 }
2186 }
2188 if (not $delivered2host) {
2189 &daemon_log("M ERROR: unable to send user message to host '$receiver_host'", 1);
2190 }
2191 }
2193 if ($send_succeed) {
2194 # set outgoing msg at db to deliverd
2195 my $sql = "UPDATE $messaging_tn SET flag='d' WHERE (id='$msg_id' AND direction='out' AND message_to='$receiver')";
2196 my $res = $messaging_db->exec_statement($sql);
2197 &daemon_log("M INFO: send message for user '$receiver' to logged in hosts", 5);
2198 } else {
2199 &daemon_log("M WARNING: failed to deliver message for user '$receiver'", 3);
2200 }
2201 }
2203 $kernel->delay_set('watch_for_delivery_messages', $messaging_db_loop_delay);
2204 return;
2205 }
2208 sub watch_for_done_messages {
2209 my ($kernel,$heap) = @_[KERNEL, HEAP];
2211 my $sql = "SELECT * FROM $messaging_tn WHERE (flag='p' AND direction='in')";
2212 my $res = $messaging_db->exec_statement($sql);
2214 foreach my $hit (@{$res}) {
2215 my $msg_id = @{$hit}[0];
2217 my $sql = "SELECT * FROM $messaging_tn WHERE (id='$msg_id' AND direction='out' AND (NOT flag='s'))";
2218 my $res = $messaging_db->exec_statement($sql);
2220 # not all usr msgs have been seen till now
2221 if ( ref(@$res[0]) eq "ARRAY") { next; }
2223 $sql = "DELETE FROM $messaging_tn WHERE (id='$msg_id')";
2224 $res = $messaging_db->exec_statement($sql);
2226 }
2228 $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
2229 return;
2230 }
2233 sub watch_for_old_known_clients {
2234 my ($kernel,$heap) = @_[KERNEL, HEAP];
2236 my $sql_statement = "SELECT * FROM $known_clients_tn";
2237 my $res = $known_clients_db->select_dbentry( $sql_statement );
2239 my $cur_time = int(&get_time());
2241 while ( my ($hit_num, $hit) = each %$res) {
2242 my $expired_timestamp = int($hit->{'timestamp'});
2243 $expired_timestamp =~ /(\d{4})(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)/;
2244 my $dt = DateTime->new( year => $1,
2245 month => $2,
2246 day => $3,
2247 hour => $4,
2248 minute => $5,
2249 second => $6,
2250 );
2252 $dt->add( seconds => 2 * int($hit->{'keylifetime'}) );
2253 $expired_timestamp = $dt->ymd('').$dt->hms('');
2254 if ($cur_time > $expired_timestamp) {
2255 my $hostname = $hit->{'hostname'};
2256 my $del_sql = "DELETE FROM $known_clients_tn WHERE hostname='$hostname'";
2257 my $del_res = $known_clients_db->exec_statement($del_sql);
2259 &main::daemon_log("0 INFO: timestamp '".$hit->{'timestamp'}."' of client '$hostname' is expired('$expired_timestamp'), client will be deleted from known_clients_db", 5);
2260 }
2262 }
2264 $kernel->delay_set('watch_for_old_known_clients', $job_queue_loop_delay);
2265 }
2268 sub watch_for_next_tasks {
2269 my ($kernel,$heap) = @_[KERNEL, HEAP];
2271 my $sql = "SELECT * FROM $incoming_tn";
2272 my $res = $incoming_db->select_dbentry($sql);
2274 while ( my ($hit_num, $hit) = each %$res) {
2275 my $headertag = $hit->{'headertag'};
2276 if ($headertag =~ /^answer_(\d+)/) {
2277 # do not start processing, this message is for a still running POE::Wheel
2278 next;
2279 }
2280 my $message_id = $hit->{'id'};
2281 my $session_id = $hit->{'sessionid'};
2282 &daemon_log("$session_id DEBUG: start processing for message with incoming id: '$message_id'", 11);
2284 $kernel->yield('next_task', $hit);
2286 my $sql = "DELETE FROM $incoming_tn WHERE id=$message_id";
2287 my $res = $incoming_db->exec_statement($sql);
2288 }
2289 }
2292 sub get_ldap_handle {
2293 my ($session_id) = @_;
2294 my $heap;
2296 if (not defined $session_id ) { $session_id = 0 };
2297 if ($session_id =~ /[^0-9]*/) { $session_id = 0 };
2299 my ($package, $file, $row, $subroutine, $hasArgs, $wantArray, $evalText, $isRequire) = caller(1);
2300 my $caller_text = "subroutine $subroutine";
2301 if ($subroutine eq "(eval)") {
2302 $caller_text = "eval block within file '$file' for '$evalText'";
2303 }
2304 daemon_log("$session_id DEBUG: new ldap handle for '$caller_text' required!", 42);
2306 get_handle:
2307 my $ldap_handle = Net::LDAP->new( $ldap_uri );
2308 if (not ref $ldap_handle) {
2309 daemon_log("$session_id ERROR: Connection to LDAP URI '$ldap_uri' failed! Retrying in $ldap_retry_sec seconds.", 1);
2310 sleep($ldap_retry_sec);
2311 goto get_handle;
2312 } else {
2313 daemon_log("$session_id DEBUG: Connection to LDAP URI '$ldap_uri' established.", 42);
2314 }
2316 $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);
2317 return $ldap_handle;
2318 }
2321 sub release_ldap_handle {
2322 my ($ldap_handle, $session_id) = @_ ;
2323 if (not defined $session_id ) { $session_id = 0 };
2325 if(ref $ldap_handle) {
2326 $ldap_handle->disconnect();
2327 }
2328 &main::daemon_log("$session_id DEBUG: Released a ldap handle!", 42);
2329 return;
2330 }
2333 sub change_fai_state {
2334 my ($st, $targets, $session_id) = @_;
2335 $session_id = 0 if not defined $session_id;
2336 # Set FAI state to localboot
2337 my %mapActions= (
2338 reboot => '',
2339 update => 'softupdate',
2340 localboot => 'localboot',
2341 reinstall => 'install',
2342 rescan => '',
2343 wake => '',
2344 memcheck => 'memcheck',
2345 sysinfo => 'sysinfo',
2346 install => 'install',
2347 );
2349 # Return if this is unknown
2350 if (!exists $mapActions{ $st }){
2351 daemon_log("$session_id ERROR: unknown action '$st', can not translate ot FAIstate", 1);
2352 return;
2353 }
2355 my $state= $mapActions{ $st };
2357 # Build search filter for hosts
2358 my $search= "(&(objectClass=GOhard)";
2359 foreach (@{$targets}){
2360 $search.= "(macAddress=$_)";
2361 }
2362 $search.= ")";
2364 # If there's any host inside of the search string, procress them
2365 if (!($search =~ /macAddress/)){
2366 daemon_log("$session_id ERROR: no macAddress found in filter statement for LDAP search: '$search'", 1);
2367 return;
2368 }
2370 my $ldap_handle = &get_ldap_handle($session_id);
2371 # Perform search for Unit Tag
2372 my $mesg = $ldap_handle->search(
2373 base => $ldap_base,
2374 scope => 'sub',
2375 attrs => ['dn', 'FAIstate', 'objectClass'],
2376 filter => "$search"
2377 );
2379 if ($mesg->count) {
2380 my @entries = $mesg->entries;
2381 if (0 == @entries) {
2382 daemon_log("$session_id ERROR: ldap search failed: ldap_base=$ldap_base, filter=$search", 1);
2383 }
2385 foreach my $entry (@entries) {
2386 # Only modify entry if it is not set to '$state'
2387 if ($entry->get_value("FAIstate") ne "$state"){
2388 daemon_log("$session_id INFO: Setting FAIstate to '$state' for ".$entry->dn, 5);
2389 my $result;
2390 my %tmp = map { $_ => 1 } $entry->get_value("objectClass");
2391 if (exists $tmp{'FAIobject'}){
2392 if ($state eq ''){
2393 $result= $ldap_handle->modify($entry->dn, changes => [ delete => [ FAIstate => [] ] ]);
2394 } else {
2395 $result= $ldap_handle->modify($entry->dn, changes => [ replace => [ FAIstate => $state ] ]);
2396 }
2397 } elsif ($state ne ''){
2398 $result= $ldap_handle->modify($entry->dn, changes => [ add => [ objectClass => 'FAIobject' ], add => [ FAIstate => $state ] ]);
2399 }
2401 # Errors?
2402 if ($result->code){
2403 daemon_log("$session_id Error: Setting FAIstate to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
2404 }
2405 } else {
2406 daemon_log("$session_id DEBUG FAIstate at host '".$entry->dn."' already at state '$st'", 42);
2407 }
2408 }
2409 } else {
2410 daemon_log("$session_id ERROR: LDAP search failed: ldap_base=$ldap_base, filter=$search", 1);
2411 }
2412 &release_ldap_handle($ldap_handle, $session_id);
2414 return;
2415 }
2418 sub change_goto_state {
2419 my ($st, $targets, $session_id) = @_;
2420 $session_id = 0 if not defined $session_id;
2422 # Switch on or off?
2423 my $state= $st eq 'active' ? 'active': 'locked';
2425 my $ldap_handle = &get_ldap_handle($session_id);
2426 if( defined($ldap_handle) ) {
2428 # Build search filter for hosts
2429 my $search= "(&(objectClass=GOhard)";
2430 foreach (@{$targets}){
2431 $search.= "(macAddress=$_)";
2432 }
2433 $search.= ")";
2435 # If there's any host inside of the search string, procress them
2436 if (!($search =~ /macAddress/)){
2437 &release_ldap_handle($ldap_handle);
2438 return;
2439 }
2441 # Perform search for Unit Tag
2442 my $mesg = $ldap_handle->search(
2443 base => $ldap_base,
2444 scope => 'sub',
2445 attrs => ['dn', 'gotoMode'],
2446 filter => "$search"
2447 );
2449 if ($mesg->count) {
2450 my @entries = $mesg->entries;
2451 foreach my $entry (@entries) {
2453 # Only modify entry if it is not set to '$state'
2454 if ($entry->get_value("gotoMode") ne $state){
2456 daemon_log("$session_id INFO: Setting gotoMode to '$state' for ".$entry->dn, 5);
2457 my $result;
2458 $result= $ldap_handle->modify($entry->dn, changes => [replace => [ gotoMode => $state ] ]);
2460 # Errors?
2461 if ($result->code){
2462 &daemon_log("$session_id Error: Setting gotoMode to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
2463 }
2465 }
2466 }
2467 } else {
2468 daemon_log("$session_id ERROR: LDAP search failed in function change_goto_state: ldap_base=$ldap_base, filter=$search", 1);
2469 }
2471 }
2472 &release_ldap_handle($ldap_handle, $session_id);
2473 return;
2474 }
2477 sub run_recreate_packages_db {
2478 my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];
2479 my $session_id = $session->ID;
2480 &main::daemon_log("$session_id INFO: Recreating FAI Packages DB ('$fai_release_tn', '$fai_server_tn', '$packages_list_tn')", 5);
2481 $kernel->yield('create_fai_release_db', $fai_release_tn);
2482 $kernel->yield('create_fai_server_db', $fai_server_tn);
2483 return;
2484 }
2487 sub run_create_fai_server_db {
2488 my ($kernel, $session, $heap, $table_name) = @_[KERNEL, SESSION, HEAP, ARG0];
2489 my $session_id = $session->ID;
2490 my $task = POE::Wheel::Run->new(
2491 Program => sub { &create_fai_server_db($table_name,$kernel, undef, $session_id) },
2492 StdoutEvent => "session_run_result",
2493 StderrEvent => "session_run_debug",
2494 CloseEvent => "session_run_done",
2495 );
2497 $heap->{task}->{ $task->ID } = $task;
2498 return;
2499 }
2502 sub create_fai_server_db {
2503 my ($table_name, $kernel, $dont_create_packages_list, $session_id) = @_;
2504 my $result;
2506 if (not defined $session_id) { $session_id = 0; }
2507 my $ldap_handle = &get_ldap_handle($session_id);
2508 if(defined($ldap_handle)) {
2509 daemon_log("$session_id INFO: create_fai_server_db: start", 5);
2510 my $mesg= $ldap_handle->search(
2511 base => $ldap_base,
2512 scope => 'sub',
2513 attrs => ['FAIrepository', 'gosaUnitTag'],
2514 filter => "(&(FAIrepository=*)(objectClass=FAIrepositoryServer))",
2515 );
2516 if($mesg->{'resultCode'} == 0 &&
2517 $mesg->count != 0) {
2518 foreach my $entry (@{$mesg->{entries}}) {
2519 if($entry->exists('FAIrepository')) {
2520 # Add an entry for each Repository configured for server
2521 foreach my $repo(@{$entry->get_value('FAIrepository', asref => 1)}) {
2522 my($tmp_url,$tmp_server,$tmp_release,$tmp_sections) = split(/\|/, $repo);
2523 my $tmp_tag= $entry->get_value('gosaUnitTag') || "";
2524 $result= $fai_server_db->add_dbentry( {
2525 table => $table_name,
2526 primkey => ['server', 'fai_release', 'tag'],
2527 server => $tmp_url,
2528 fai_release => $tmp_release,
2529 sections => $tmp_sections,
2530 tag => (length($tmp_tag)>0)?$tmp_tag:"",
2531 } );
2532 }
2533 }
2534 }
2535 }
2536 daemon_log("$session_id INFO: create_fai_server_db: finished", 5);
2537 &release_ldap_handle($ldap_handle);
2539 # TODO: Find a way to post the 'create_packages_list_db' event
2540 if(not defined($dont_create_packages_list)) {
2541 &create_packages_list_db(undef, $session_id);
2542 }
2543 }
2545 return $result;
2546 }
2549 sub run_create_fai_release_db {
2550 my ($kernel, $session, $heap, $table_name) = @_[KERNEL, SESSION, HEAP, ARG0];
2551 my $session_id = $session->ID;
2552 my $task = POE::Wheel::Run->new(
2553 Program => sub { &create_fai_release_db($table_name, $session_id) },
2554 StdoutEvent => "session_run_result",
2555 StderrEvent => "session_run_debug",
2556 CloseEvent => "session_run_done",
2557 );
2559 $heap->{task}->{ $task->ID } = $task;
2560 return;
2561 }
2564 sub create_fai_release_db {
2565 my ($table_name, $session_id) = @_;
2566 my $result;
2568 # used for logging
2569 if (not defined $session_id) { $session_id = 0; }
2571 my $ldap_handle = &get_ldap_handle($session_id);
2572 if(defined($ldap_handle)) {
2573 daemon_log("$session_id INFO: create_fai_release_db: start",5);
2574 my $mesg= $ldap_handle->search(
2575 base => $ldap_base,
2576 scope => 'sub',
2577 attrs => [],
2578 filter => "(&(objectClass=organizationalUnit)(ou=fai))",
2579 );
2580 if(($mesg->code == 0) && ($mesg->count != 0))
2581 {
2582 daemon_log("$session_id DEBUG: create_fai_release_db: count " . $mesg->count,138);
2584 # Walk through all possible FAI container ou's
2585 my @sql_list;
2586 my $timestamp= &get_time();
2587 foreach my $ou (@{$mesg->{entries}}) {
2588 my $tmp_classes= resolve_fai_classes($ou->dn, $ldap_handle, $session_id);
2589 if(defined($tmp_classes) && ref($tmp_classes) eq 'HASH') {
2590 my @tmp_array=get_fai_release_entries($tmp_classes);
2591 if(@tmp_array) {
2592 foreach my $entry (@tmp_array) {
2593 if(defined($entry) && ref($entry) eq 'HASH') {
2594 my $sql=
2595 "INSERT INTO $table_name "
2596 ."(timestamp, fai_release, class, type, state) VALUES ("
2597 .$timestamp.","
2598 ."'".$entry->{'release'}."',"
2599 ."'".$entry->{'class'}."',"
2600 ."'".$entry->{'type'}."',"
2601 ."'".$entry->{'state'}."')";
2602 push @sql_list, $sql;
2603 }
2604 }
2605 }
2606 }
2607 }
2609 daemon_log("$session_id DEBUG: create_fai_release_db: Inserting ".scalar @sql_list." entries to DB",138);
2610 &release_ldap_handle($ldap_handle);
2611 if(@sql_list) {
2612 unshift @sql_list, "VACUUM";
2613 unshift @sql_list, "DELETE FROM $table_name";
2614 $fai_release_db->exec_statementlist(\@sql_list);
2615 }
2616 daemon_log("$session_id DEBUG: create_fai_release_db: Done with inserting",138);
2617 } else {
2618 daemon_log("$session_id INFO: create_fai_release_db: error: " . $mesg->code, 5);
2619 }
2620 daemon_log("$session_id INFO: create_fai_release_db: finished",5);
2621 }
2622 return $result;
2623 }
2625 sub get_fai_types {
2626 my $tmp_classes = shift || return undef;
2627 my @result;
2629 foreach my $type(keys %{$tmp_classes}) {
2630 if(defined($tmp_classes->{$type}[0]) && (!($tmp_classes->{$type}[0] =~ /^.*?removed.*?$/))) {
2631 my $entry = {
2632 type => $type,
2633 state => $tmp_classes->{$type}[0],
2634 };
2635 push @result, $entry;
2636 }
2637 }
2639 return @result;
2640 }
2642 sub get_fai_state {
2643 my $result = "";
2644 my $tmp_classes = shift || return $result;
2646 foreach my $type(keys %{$tmp_classes}) {
2647 if(defined($tmp_classes->{$type}[0])) {
2648 $result = $tmp_classes->{$type}[0];
2650 # State is equal for all types in class
2651 last;
2652 }
2653 }
2655 return $result;
2656 }
2658 sub resolve_fai_classes {
2659 my ($fai_base, $ldap_handle, $session_id) = @_;
2660 if (not defined $session_id) { $session_id = 0; }
2661 my $result;
2662 my @possible_fai_classes= ("FAIscript", "FAIhook", "FAIpartitionTable", "FAItemplate", "FAIvariable", "FAIprofile", "FAIpackageList");
2663 my $fai_filter= "(|(&(objectClass=FAIclass)(|(objectClass=".join(")(objectClass=", @possible_fai_classes).")))(objectClass=FAIbranch))";
2664 my $fai_classes;
2666 daemon_log("$session_id DEBUG: Searching for FAI entries in base $fai_base", 138);
2667 my $mesg= $ldap_handle->search(
2668 base => $fai_base,
2669 scope => 'sub',
2670 attrs => ['cn','objectClass','FAIstate'],
2671 filter => $fai_filter,
2672 );
2673 daemon_log("$session_id DEBUG: Found ".$mesg->count()." FAI entries", 138);
2675 if($mesg->{'resultCode'} == 0 &&
2676 $mesg->count != 0) {
2677 foreach my $entry (@{$mesg->{entries}}) {
2678 if($entry->exists('cn')) {
2679 my $tmp_dn= $entry->dn();
2680 $tmp_dn= substr( $tmp_dn, 0, length($tmp_dn)
2681 - length($fai_base) - 1 );
2683 # Skip classname and ou dn parts for class
2684 my $tmp_release = ($1) if $tmp_dn =~ /^[^,]+,[^,]+,(.*?)$/;
2686 # Skip classes without releases
2687 if((!defined($tmp_release)) || length($tmp_release)==0) {
2688 next;
2689 }
2691 my $tmp_cn= $entry->get_value('cn');
2692 my $tmp_state= $entry->get_value('FAIstate');
2694 my $tmp_type;
2695 # Get FAI type
2696 for my $oclass(@{$entry->get_value('objectClass', asref => 1)}) {
2697 if(grep $_ eq $oclass, @possible_fai_classes) {
2698 $tmp_type= $oclass;
2699 last;
2700 }
2701 }
2703 if($tmp_release =~ /^.*?,.*?$/ && (!($tmp_release =~ /^.*?\\,.*?$/))) {
2704 # A Subrelease
2705 my @sub_releases = split(/,/, $tmp_release);
2707 # Walk through subreleases and build hash tree
2708 my $hash;
2709 while(my $tmp_sub_release = pop @sub_releases) {
2710 $hash .= "\{'$tmp_sub_release'\}->";
2711 }
2712 eval('push @{$fai_classes->'.$hash.'{$tmp_cn}->{$tmp_type}}, (defined($tmp_state) && length($tmp_state)>0)?$tmp_state:"";');
2713 } else {
2714 # A branch, no subrelease
2715 push @{$fai_classes->{$tmp_release}->{$tmp_cn}->{$tmp_type}}, (defined($tmp_state) && length($tmp_state)>0)?$tmp_state:"";
2716 }
2717 } elsif (!$entry->exists('cn')) {
2718 my $tmp_dn= $entry->dn();
2719 $tmp_dn= substr( $tmp_dn, 0, length($tmp_dn)
2720 - length($fai_base) - 1 );
2721 my $tmp_release = ($1) if $tmp_dn =~ /^(.*?)$/;
2723 # Skip classes without releases
2724 if((!defined($tmp_release)) || length($tmp_release)==0) {
2725 next;
2726 }
2728 if($tmp_release =~ /^.*?,.*?$/ && (!($tmp_release =~ /^.*?\\,.*?$/))) {
2729 # A Subrelease
2730 my @sub_releases= split(/,/, $tmp_release);
2732 # Walk through subreleases and build hash tree
2733 my $hash;
2734 while(my $tmp_sub_release = pop @sub_releases) {
2735 $hash .= "\{'$tmp_sub_release'\}->";
2736 }
2737 # Remove the last two characters
2738 chop($hash);
2739 chop($hash);
2741 eval('$fai_classes->'.$hash.'= {}');
2742 } else {
2743 # A branch, no subrelease
2744 if(!exists($fai_classes->{$tmp_release})) {
2745 $fai_classes->{$tmp_release} = {};
2746 }
2747 }
2748 }
2749 }
2751 # The hash is complete, now we can honor the copy-on-write based missing entries
2752 foreach my $release (keys %$fai_classes) {
2753 $result->{$release}= deep_copy(apply_fai_inheritance($fai_classes->{$release}));
2754 }
2755 }
2756 return $result;
2757 }
2759 sub apply_fai_inheritance {
2760 my $fai_classes = shift || return {};
2761 my $tmp_classes;
2763 # Get the classes from the branch
2764 foreach my $class (keys %{$fai_classes}) {
2765 # Skip subreleases
2766 if($class =~ /^ou=.*$/) {
2767 next;
2768 } else {
2769 $tmp_classes->{$class}= deep_copy($fai_classes->{$class});
2770 }
2771 }
2773 # Apply to each subrelease
2774 foreach my $subrelease (keys %{$fai_classes}) {
2775 if($subrelease =~ /ou=/) {
2776 foreach my $tmp_class (keys %{$tmp_classes}) {
2777 if(!exists($fai_classes->{$subrelease}->{$tmp_class})) {
2778 $fai_classes->{$subrelease}->{$tmp_class} =
2779 deep_copy($tmp_classes->{$tmp_class});
2780 } else {
2781 foreach my $type (keys %{$tmp_classes->{$tmp_class}}) {
2782 if(!exists($fai_classes->{$subrelease}->{$tmp_class}->{$type})) {
2783 $fai_classes->{$subrelease}->{$tmp_class}->{$type}=
2784 deep_copy($tmp_classes->{$tmp_class}->{$type});
2785 }
2786 }
2787 }
2788 }
2789 }
2790 }
2792 # Find subreleases in deeper levels
2793 foreach my $subrelease (keys %{$fai_classes}) {
2794 if($subrelease =~ /ou=/) {
2795 foreach my $subsubrelease (keys %{$fai_classes->{$subrelease}}) {
2796 if($subsubrelease =~ /ou=/) {
2797 apply_fai_inheritance($fai_classes->{$subrelease});
2798 }
2799 }
2800 }
2801 }
2803 return $fai_classes;
2804 }
2806 sub get_fai_release_entries {
2807 my $tmp_classes = shift || return;
2808 my $parent = shift || "";
2809 my @result = shift || ();
2811 foreach my $entry (keys %{$tmp_classes}) {
2812 if(defined($entry)) {
2813 if($entry =~ /^ou=.*$/) {
2814 my $release_name = $entry;
2815 $release_name =~ s/ou=//g;
2816 if(length($parent)>0) {
2817 $release_name = $parent."/".$release_name;
2818 }
2819 my @bufentries = get_fai_release_entries($tmp_classes->{$entry}, $release_name, @result);
2820 foreach my $bufentry(@bufentries) {
2821 push @result, $bufentry;
2822 }
2823 } else {
2824 my @types = get_fai_types($tmp_classes->{$entry});
2825 foreach my $type (@types) {
2826 push @result,
2827 {
2828 'class' => $entry,
2829 'type' => $type->{'type'},
2830 'release' => $parent,
2831 'state' => $type->{'state'},
2832 };
2833 }
2834 }
2835 }
2836 }
2838 return @result;
2839 }
2841 sub deep_copy {
2842 my $this = shift;
2843 if (not ref $this) {
2844 $this;
2845 } elsif (ref $this eq "ARRAY") {
2846 [map deep_copy($_), @$this];
2847 } elsif (ref $this eq "HASH") {
2848 +{map { $_ => deep_copy($this->{$_}) } keys %$this};
2849 } else { die "what type is $_?" }
2850 }
2853 sub session_run_result {
2854 my ($kernel, $heap, $client_answer) = @_[KERNEL, HEAP, ARG0];
2855 $kernel->sig(CHLD => "child_reap");
2856 }
2858 sub session_run_debug {
2859 my $result = $_[ARG0];
2860 print STDERR "$result\n";
2861 }
2863 sub session_run_done {
2864 my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
2865 delete $heap->{task}->{$task_id};
2866 if (exists $heap->{ldap_handle}->{$task_id}) {
2867 &release_ldap_handle($heap->{ldap_handle}->{$task_id});
2868 }
2869 delete $heap->{ldap_handle}->{$task_id};
2870 }
2873 sub create_sources_list {
2874 my $session_id = shift || 0;
2875 my $result="/tmp/gosa_si_tmp_sources_list";
2877 # Remove old file
2878 if(stat($result)) {
2879 unlink($result);
2880 &main::daemon_log("$session_id DEBUG: remove an old version of '$result'", 7);
2881 }
2883 my $fh;
2884 open($fh, ">$result");
2885 if (not defined $fh) {
2886 &main::daemon_log("$session_id DEBUG: cannot open '$result' for writing", 7);
2887 return undef;
2888 }
2889 if(defined($main::ldap_server_dn) and length($main::ldap_server_dn) > 0) {
2890 my $ldap_handle = &get_ldap_handle($session_id);
2891 my $mesg=$ldap_handle->search(
2892 base => $main::ldap_server_dn,
2893 scope => 'base',
2894 attrs => 'FAIrepository',
2895 filter => 'objectClass=FAIrepositoryServer'
2896 );
2897 if($mesg->count) {
2898 foreach my $entry(@{$mesg->{'entries'}}) {
2899 foreach my $value(@{$entry->get_value('FAIrepository', asref => 1)}) {
2900 my ($server, $tag, $release, $sections)= split /\|/, $value;
2901 my $line = "deb $server $release";
2902 $sections =~ s/,/ /g;
2903 $line.= " $sections";
2904 print $fh $line."\n";
2905 }
2906 }
2907 }
2908 &release_ldap_handle($ldap_handle);
2909 } else {
2910 if (defined $main::ldap_server_dn){
2911 &main::daemon_log("$session_id ERROR: something wrong with ldap_server_dn '$main::ldap_server_dn', abort create_sources_list", 1);
2912 } else {
2913 &main::daemon_log("$session_id ERROR: no ldap_server_dn found, abort create_sources_list", 1);
2914 }
2915 }
2916 close($fh);
2918 return $result;
2919 }
2922 sub run_create_packages_list_db {
2923 my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];
2924 my $session_id = $session->ID;
2925 my $task = POE::Wheel::Run->new(
2926 Priority => +20,
2927 Program => sub {&create_packages_list_db(undef, $session_id)},
2928 StdoutEvent => "session_run_result",
2929 StderrEvent => "session_run_debug",
2930 CloseEvent => "session_run_done",
2931 );
2932 $heap->{task}->{ $task->ID } = $task;
2933 }
2936 sub create_packages_list_db {
2937 my ($sources_file, $session_id) = @_;
2939 # it should not be possible to trigger a recreation of packages_list_db
2940 # while packages_list_db is under construction, so set flag packages_list_under_construction
2941 # which is tested befor recreation can be started
2942 if (-r $packages_list_under_construction) {
2943 daemon_log("$session_id WARNING: packages_list_db is right now under construction, please wait until this process is finished", 3);
2944 return;
2945 } else {
2946 daemon_log("$session_id INFO: create_packages_list_db: start", 5);
2947 # set packages_list_under_construction to true
2948 system("touch $packages_list_under_construction");
2949 @packages_list_statements=();
2950 }
2952 if (not defined $session_id) { $session_id = 0; }
2954 if (not defined $sources_file) {
2955 &main::daemon_log("$session_id INFO: no sources_file given for creating packages list so trigger creation of it", 5);
2956 $sources_file = &create_sources_list($session_id);
2957 }
2959 if (not defined $sources_file) {
2960 &main::daemon_log("$session_id ERROR: no sources_file given under '$sources_file', skip create_packages_list_db", 1);
2961 unlink($packages_list_under_construction);
2962 return;
2963 }
2965 my $line;
2967 open(CONFIG, "<$sources_file") or do {
2968 daemon_log( "$session_id ERROR: create_packages_list_db: Failed to open '$sources_file'", 1);
2969 unlink($packages_list_under_construction);
2970 return;
2971 };
2973 # Read lines
2974 while ($line = <CONFIG>){
2975 # Unify
2976 chop($line);
2977 $line =~ s/^\s+//;
2978 $line =~ s/^\s+/ /;
2980 # Strip comments
2981 $line =~ s/#.*$//g;
2983 # Skip empty lines
2984 if ($line =~ /^\s*$/){
2985 next;
2986 }
2988 # Interpret deb line
2989 if ($line =~ /^deb [^\s]+\s[^\s]+\s[^\s]+/){
2990 my( $baseurl, $dist, $sections ) = ($line =~ /^deb\s([^\s]+)\s+([^\s]+)\s+(.*)$/);
2991 my $section;
2992 foreach $section (split(' ', $sections)){
2993 &parse_package_info( $baseurl, $dist, $section, $session_id );
2994 }
2995 }
2996 }
2998 close (CONFIG);
3000 if(keys(%repo_dirs)) {
3001 find(\&cleanup_and_extract, keys( %repo_dirs ));
3002 &main::strip_packages_list_statements();
3003 $packages_list_db->exec_statementlist(\@packages_list_statements);
3004 }
3005 unlink($packages_list_under_construction);
3006 daemon_log("$session_id INFO: create_packages_list_db: finished", 5);
3007 return;
3008 }
3010 # This function should do some intensive task to minimize the db-traffic
3011 sub strip_packages_list_statements {
3012 my @existing_entries= @{$packages_list_db->exec_statement("SELECT * FROM $main::packages_list_tn")};
3013 my @new_statement_list=();
3014 my $hash;
3015 my $insert_hash;
3016 my $update_hash;
3017 my $delete_hash;
3018 my $known_packages_hash;
3019 my $local_timestamp=get_time();
3021 foreach my $existing_entry (@existing_entries) {
3022 $hash->{@{$existing_entry}[0]}->{@{$existing_entry}[1]}->{@{$existing_entry}[2]}= $existing_entry;
3023 }
3025 foreach my $statement (@packages_list_statements) {
3026 if($statement =~ /^INSERT/i) {
3027 # Assign the values from the insert statement
3028 my ($distribution,$package,$version,$section,$description,$template,$timestamp) = ($1,$2,$3,$4,$5,$6,$7) if $statement =~
3029 /^INSERT\s+?INTO\s+?$main::packages_list_tn\s+?VALUES\s*?\('(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)'\s*?\)$/si;
3030 if(exists($hash->{$distribution}->{$package}->{$version})) {
3031 # If section or description has changed, update the DB
3032 if(
3033 (! (@{$hash->{$distribution}->{$package}->{$version}}[3] eq $section)) or
3034 (! (@{$hash->{$distribution}->{$package}->{$version}}[4] eq $description))
3035 ) {
3036 @{$update_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,undef);
3037 } else {
3038 # package is already present in database. cache this knowledge for later use
3039 @{$known_packages_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,$template);
3040 }
3041 } else {
3042 # Insert a non-existing entry to db
3043 @{$insert_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,$template);
3044 }
3045 } elsif ($statement =~ /^UPDATE/i) {
3046 my ($template,$package,$version) = ($1,$2,$3) if $statement =~
3047 /^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;
3048 foreach my $distribution (keys %{$hash}) {
3049 if(exists($insert_hash->{$distribution}->{$package}->{$version})) {
3050 # update the insertion hash to execute only one query per package (insert instead insert+update)
3051 @{$insert_hash->{$distribution}->{$package}->{$version}}[5]= $template;
3052 } elsif(exists($hash->{$distribution}->{$package}->{$version})) {
3053 if( ! (@{$hash->{$distribution}->{$package}->{$version}}[5] eq $template)) {
3054 my $section;
3055 my $description;
3056 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[3]) and
3057 length(@{$update_hash->{$distribution}->{$package}->{$version}}[3]) > 0 ) {
3058 $section= @{$update_hash->{$distribution}->{$package}->{$version}}[3];
3059 }
3060 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[4])) {
3061 $description= @{$update_hash->{$distribution}->{$package}->{$version}}[4];
3062 }
3063 @{$update_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,$template);
3064 }
3065 }
3066 }
3067 }
3068 }
3070 # Check for orphaned entries
3071 foreach my $existing_entry (@existing_entries) {
3072 my $distribution= @{$existing_entry}[0];
3073 my $package= @{$existing_entry}[1];
3074 my $version= @{$existing_entry}[2];
3075 my $section= @{$existing_entry}[3];
3077 if(
3078 exists($insert_hash->{$distribution}->{$package}->{$version}) ||
3079 exists($update_hash->{$distribution}->{$package}->{$version}) ||
3080 exists($known_packages_hash->{$distribution}->{$package}->{$version})
3081 ) {
3082 next;
3083 } else {
3084 # Insert entry to delete hash
3085 @{$delete_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section);
3086 }
3087 }
3089 # unroll the insert hash
3090 foreach my $distribution (keys %{$insert_hash}) {
3091 foreach my $package (keys %{$insert_hash->{$distribution}}) {
3092 foreach my $version (keys %{$insert_hash->{$distribution}->{$package}}) {
3093 push @new_statement_list, "INSERT INTO $main::packages_list_tn VALUES ('$distribution','$package','$version',"
3094 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[3]',"
3095 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[4]',"
3096 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[5]',"
3097 ."'$local_timestamp')";
3098 }
3099 }
3100 }
3102 # unroll the update hash
3103 foreach my $distribution (keys %{$update_hash}) {
3104 foreach my $package (keys %{$update_hash->{$distribution}}) {
3105 foreach my $version (keys %{$update_hash->{$distribution}->{$package}}) {
3106 my $set = "";
3107 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[3])) {
3108 $set .= "section = '@{$update_hash->{$distribution}->{$package}->{$version}}[3]', ";
3109 }
3110 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[4])) {
3111 $set .= "description = '@{$update_hash->{$distribution}->{$package}->{$version}}[4]', ";
3112 }
3113 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[5])) {
3114 $set .= "template = '@{$update_hash->{$distribution}->{$package}->{$version}}[5]', ";
3115 }
3116 if(defined($set) and length($set) > 0) {
3117 $set .= "timestamp = '$local_timestamp'";
3118 } else {
3119 next;
3120 }
3121 push @new_statement_list,
3122 "UPDATE $main::packages_list_tn SET $set WHERE"
3123 ." distribution = '$distribution'"
3124 ." AND package = '$package'"
3125 ." AND version = '$version'";
3126 }
3127 }
3128 }
3130 # unroll the delete hash
3131 foreach my $distribution (keys %{$delete_hash}) {
3132 foreach my $package (keys %{$delete_hash->{$distribution}}) {
3133 foreach my $version (keys %{$delete_hash->{$distribution}->{$package}}) {
3134 my $section = @{$delete_hash->{$distribution}->{$package}->{$version}}[3];
3135 push @new_statement_list, "DELETE FROM $main::packages_list_tn WHERE distribution='$distribution' AND package='$package' AND version='$version' AND section='$section'";
3136 }
3137 }
3138 }
3140 unshift(@new_statement_list, "VACUUM");
3142 @packages_list_statements = @new_statement_list;
3143 }
3146 sub parse_package_info {
3147 my ($baseurl, $dist, $section, $session_id)= @_;
3148 my ($package);
3149 if (not defined $session_id) { $session_id = 0; }
3150 my ($path) = ($baseurl =~ m%://[^/]*(.*)$%);
3151 $repo_dirs{ "${repo_path}/pool" } = 1;
3153 foreach $package ("Packages.gz"){
3154 daemon_log("$session_id DEBUG: create_packages_list: fetch $baseurl, $dist, $section", 266);
3155 get_package( "$baseurl/dists/$dist/$section/binary-$arch/$package", "$outdir/$dist/$section", $session_id );
3156 parse_package( "$outdir/$dist/$section", $dist, $path, $session_id );
3157 }
3159 }
3162 sub get_package {
3163 my ($url, $dest, $session_id)= @_;
3164 if (not defined $session_id) { $session_id = 0; }
3166 my $tpath = dirname($dest);
3167 -d "$tpath" || mkpath "$tpath";
3169 # This is ugly, but I've no time to take a look at "how it works in perl"
3170 if(0 == system("wget '$url' -O '$dest' 2>/dev/null") ) {
3171 system("gunzip -cd '$dest' > '$dest.in'");
3172 daemon_log("$session_id DEBUG: run command: gunzip -cd '$dest' > '$dest.in'", 266);
3173 unlink($dest);
3174 daemon_log("$session_id DEBUG: delete file '$dest'", 266);
3175 } else {
3176 daemon_log("$session_id ERROR: create_packages_list_db: get_packages: fetching '$url' into '$dest' failed!", 1);
3177 }
3178 return 0;
3179 }
3182 sub parse_package {
3183 my ($path, $dist, $srv_path, $session_id)= @_;
3184 if (not defined $session_id) { $session_id = 0;}
3185 my ($package, $version, $section, $description);
3186 my $PACKAGES;
3187 my $timestamp = &get_time();
3189 if(not stat("$path.in")) {
3190 daemon_log("$session_id ERROR: create_packages_list: parse_package: file '$path.in' is not readable",1);
3191 return;
3192 }
3194 open($PACKAGES, "<$path.in");
3195 if(not defined($PACKAGES)) {
3196 daemon_log("$session_id ERROR: create_packages_list_db: parse_package: cannot open '$path.in'",1);
3197 return;
3198 }
3200 # Read lines
3201 while (<$PACKAGES>){
3202 my $line = $_;
3203 # Unify
3204 chop($line);
3206 # Use empty lines as a trigger
3207 if ($line =~ /^\s*$/){
3208 my $sql = "INSERT INTO packages_list VALUES ('$dist', '$package', '$version', '$section', '$description', '', '$timestamp')";
3209 push(@packages_list_statements, $sql);
3210 $package = "none";
3211 $version = "none";
3212 $section = "none";
3213 $description = "none";
3214 next;
3215 }
3217 # Trigger for package name
3218 if ($line =~ /^Package:\s/){
3219 ($package)= ($line =~ /^Package: (.*)$/);
3220 next;
3221 }
3223 # Trigger for version
3224 if ($line =~ /^Version:\s/){
3225 ($version)= ($line =~ /^Version: (.*)$/);
3226 next;
3227 }
3229 # Trigger for description
3230 if ($line =~ /^Description:\s/){
3231 ($description)= &encode_base64(($line =~ /^Description: (.*)$/));
3232 next;
3233 }
3235 # Trigger for section
3236 if ($line =~ /^Section:\s/){
3237 ($section)= ($line =~ /^Section: (.*)$/);
3238 next;
3239 }
3241 # Trigger for filename
3242 if ($line =~ /^Filename:\s/){
3243 my ($filename) = ($line =~ /^Filename: (.*)$/);
3244 store_fileinfo( $package, $filename, $dist, $srv_path, $version, $repo_path );
3245 next;
3246 }
3247 }
3249 close( $PACKAGES );
3250 unlink( "$path.in" );
3251 }
3254 sub store_fileinfo {
3255 my( $package, $file, $dist, $path, $vers, $srvdir) = @_;
3257 my %fileinfo = (
3258 'package' => $package,
3259 'dist' => $dist,
3260 'version' => $vers,
3261 );
3263 $repo_files{ "${srvdir}/$file" } = \%fileinfo;
3264 }
3267 sub cleanup_and_extract {
3268 my $fileinfo = $repo_files{ $File::Find::name };
3270 if( defined $fileinfo ) {
3271 my $dir = "$outdir/$fileinfo->{ 'dist' }/debconf.d";
3272 my $sql;
3273 my $package = $fileinfo->{ 'package' };
3274 my $newver = $fileinfo->{ 'version' };
3276 mkpath($dir);
3277 system( "dpkg -e '$File::Find::name' '$dir/DEBIAN'" );
3279 if( -f "$dir/DEBIAN/templates" ) {
3281 daemon_log("0 DEBUG: Found debconf templates in '$package' - $newver", 266);
3283 my $tmpl= ""; {
3284 local $/=undef;
3285 open FILE, "$dir/DEBIAN/templates";
3286 $tmpl = &encode_base64(<FILE>);
3287 close FILE;
3288 }
3289 rmtree("$dir/DEBIAN/templates");
3291 $sql= "update $main::packages_list_tn set template = '$tmpl' where package = '$package' and version = '$newver';";
3292 push @packages_list_statements, $sql;
3293 }
3294 }
3296 return;
3297 }
3300 sub prepare_server_registration
3301 {
3302 # Add foreign server from cfg file
3303 my @foreign_server_list;
3304 if ($foreign_server_string ne "") {
3305 my @cfg_foreign_server_list = split(",", $foreign_server_string);
3306 foreach my $foreign_server (@cfg_foreign_server_list) {
3307 push(@foreign_server_list, $foreign_server);
3308 }
3310 daemon_log("0 INFO: found foreign server in config file: ".join(", ", @foreign_server_list), 5);
3311 }
3313 # Perform a DNS lookup for server registration if flag is true
3314 if ($dns_lookup eq "true") {
3315 # Add foreign server from dns
3316 my @tmp_servers;
3317 if (not $server_domain) {
3318 # Try our DNS Searchlist
3319 for my $domain(get_dns_domains()) {
3320 chomp($domain);
3321 my ($tmp_domains, $error_string) = &get_server_addresses($domain);
3322 if(@$tmp_domains) {
3323 for my $tmp_server(@$tmp_domains) {
3324 push @tmp_servers, $tmp_server;
3325 }
3326 }
3327 }
3328 if(@tmp_servers && length(@tmp_servers)==0) {
3329 daemon_log("0 WARNING: no foreign gosa-si-server found in DNS for domain '$server_domain'", 3);
3330 }
3331 } else {
3332 @tmp_servers = &get_server_addresses($server_domain);
3333 if( 0 == @tmp_servers ) {
3334 daemon_log("0 WARNING: no foreign gosa-si-server found in DNS for domain '$server_domain'", 3);
3335 }
3336 }
3338 daemon_log("0 INFO: found foreign server via DNS ".join(", ", @tmp_servers), 5);
3340 foreach my $server (@tmp_servers) {
3341 unshift(@foreign_server_list, $server);
3342 }
3343 } else {
3344 daemon_log("0 INFO: DNS lookup for server registration is disabled", 5);
3345 }
3347 # eliminate duplicate entries
3348 @foreign_server_list = &del_doubles(@foreign_server_list);
3349 my $all_foreign_server = join(", ", @foreign_server_list);
3350 daemon_log("0 INFO: found foreign server in config file and DNS: '$all_foreign_server'", 5);
3352 # add all found foreign servers to known_server
3353 my $cur_timestamp = &get_time();
3354 foreach my $foreign_server (@foreign_server_list) {
3356 # do not add myself to known_server_db
3357 if (&is_local($foreign_server)) { next; }
3358 ######################################
3360 my $res = $known_server_db->add_dbentry( {table=>$known_server_tn,
3361 primkey=>['hostname'],
3362 hostname=>$foreign_server,
3363 macaddress=>"",
3364 status=>'not_yet_registered',
3365 hostkey=>"none",
3366 loaded_modules => "none",
3367 timestamp=>$cur_timestamp,
3368 update_time=>'19700101000000',
3369 } );
3370 }
3371 }
3373 sub register_at_foreign_servers {
3374 my ($kernel) = $_[KERNEL];
3376 # Update status and update-time of all si-server with expired update_time and
3377 # block them for race conditional registration processes of other si-servers.
3378 my $act_time = &get_time();
3379 my $block_statement = "UPDATE $known_server_tn SET status='new_server',update_time='19700101000000' WHERE (CAST(update_time AS UNSIGNED))<$act_time ";
3380 my $block_res = $known_server_db->exec_statement($block_statement);
3382 # Fetch all si-server from db where update_time is younger than act_time
3383 my $fetch_statement = "SELECT * FROM $known_server_tn WHERE update_time='19700101000000'";
3384 my $fetch_res = $known_server_db->exec_statement($fetch_statement);
3386 # Detect already connected clients. Will be added to registration msg later.
3387 my $client_sql = "SELECT * FROM $known_clients_tn";
3388 my $client_res = $known_clients_db->exec_statement($client_sql);
3390 # Send registration messag to all fetched si-server
3391 foreach my $hit (@$fetch_res) {
3392 my $hostname = @$hit[0];
3393 my $hostkey = &create_passwd;
3395 # Add already connected clients to registration message
3396 my $myhash = &create_xml_hash('new_server', $server_address, $hostname);
3397 &add_content2xml_hash($myhash, 'key', $hostkey);
3398 map(&add_content2xml_hash($myhash, 'client', @{$_}[0].",".@{$_}[4]), @$client_res);
3400 # Add locally loaded gosa-si modules to registration message
3401 my $loaded_modules = {};
3402 while (my ($package, $pck_info) = each %$known_modules) {
3403 next if ((!defined(@$pck_info[2])) || (!(ref (@$pck_info[2]) eq 'HASH')));
3404 foreach my $act_module (keys(%{@$pck_info[2]})) {
3405 $loaded_modules->{$act_module} = "";
3406 }
3407 }
3408 map(&add_content2xml_hash($myhash, "loaded_modules", $_), keys(%$loaded_modules));
3410 # Add macaddress to registration message
3411 my ($host_ip, $host_port) = split(/:/, $hostname);
3412 my $local_ip = &get_local_ip_for_remote_ip($host_ip);
3413 my $network_interface= &get_interface_for_ip($local_ip);
3414 my $host_mac = &get_mac_for_interface($network_interface);
3415 &add_content2xml_hash($myhash, 'macaddress', $host_mac);
3417 # Build registration message and send it
3418 my $foreign_server_msg = &create_xml_string($myhash);
3419 my $error = &send_msg_to_target($foreign_server_msg, $hostname, $ServerPackages_key, "new_server", 0);
3420 }
3423 # After n sec perform a check of all server registration processes
3424 $kernel->delay_set("control_server_registration", 2);
3426 return;
3427 }
3430 sub control_server_registration {
3431 my ($kernel) = $_[KERNEL];
3433 # Check if all registration processes succeed or not
3434 my $select_statement = "SELECT * FROM $known_server_tn WHERE status='new_server'";
3435 my $select_res = $known_server_db->exec_statement($select_statement);
3437 # If at least one registration process failed, maybe in case of a race condition
3438 # with a foreign registration process
3439 if (@$select_res > 0)
3440 {
3441 # Release block statement 'new_server' to make the server accessible
3442 # for foreign registration processes
3443 my $update_statement = "UPDATE $known_server_tn SET status='waiting' WHERE status='new_server'";
3444 my $update_res = $known_server_db->exec_statement($update_statement);
3446 # Set a random delay to avoid the registration race condition
3447 my $new_foreign_servers_register_delay = int(rand(4))+1;
3448 $kernel->delay_set("register_at_foreign_servers", $new_foreign_servers_register_delay);
3449 }
3450 # If all registration processes succeed
3451 else
3452 {
3453 $kernel->delay_set("register_at_foreign_servers", $foreign_servers_register_delay);
3454 }
3456 return;
3457 }
3460 #==== MAIN = main ==============================================================
3461 # parse commandline options
3462 Getopt::Long::Configure( "bundling" );
3463 GetOptions("h|help" => \&usage,
3464 "c|config=s" => \$cfg_file,
3465 "f|foreground" => \$foreground,
3466 "v|verbose+" => \$verbose,
3467 "no-arp+" => \$no_arp,
3468 "d=s" => \$debug_parts,
3469 ) or &usage("", 1);
3471 # read and set config parameters
3472 &check_cmdline_param ;
3473 &read_configfile($cfg_file, %cfg_defaults);
3474 &check_pid;
3476 $SIG{CHLD} = 'IGNORE';
3478 # forward error messages to logfile
3479 if( ! $foreground ) {
3480 open( STDIN, '+>/dev/null' );
3481 open( STDOUT, '+>&STDIN' );
3482 open( STDERR, '+>&STDIN' );
3483 }
3485 # Just fork, if we are not in foreground mode
3486 if( ! $foreground ) {
3487 chdir '/' or die "Can't chdir to /: $!";
3488 $pid = fork;
3489 setsid or die "Can't start a new session: $!";
3490 umask 0;
3491 } else {
3492 $pid = $$;
3493 }
3495 # Do something useful - put our PID into the pid_file
3496 if( 0 != $pid ) {
3497 open( LOCK_FILE, ">$pid_file" );
3498 print LOCK_FILE "$pid\n";
3499 close( LOCK_FILE );
3500 if( !$foreground ) {
3501 exit( 0 )
3502 };
3503 }
3505 # parse head url and revision from svn
3506 my $server_status_hash = { 'developmental'=>'revision', 'stable'=>'release'};
3507 $server_version =~ /^\$HeadURL: (\S+) \$:\$Rev: (\d+) \$$/;
3508 $server_headURL = defined $1 ? $1 : 'unknown' ;
3509 $server_revision = defined $2 ? $2 : 'unknown' ;
3510 if ($server_headURL =~ /\/tag\// ||
3511 $server_headURL =~ /\/branches\// ) {
3512 $server_status = "stable";
3513 } else {
3514 $server_status = "developmental" ;
3515 }
3516 # Prepare log file and set permissions
3517 $root_uid = getpwnam('root');
3518 $adm_gid = getgrnam('adm');
3519 open(FH, ">>$log_file");
3520 close FH;
3521 chmod(0440, $log_file);
3522 chown($root_uid, $adm_gid, $log_file);
3523 chown($root_uid, $adm_gid, "/var/lib/gosa-si");
3525 daemon_log(" ", 1);
3526 daemon_log("$0 started!", 1);
3527 daemon_log("status: $server_status", 1);
3528 daemon_log($server_status_hash->{$server_status}.": $server_revision", 1);
3530 # Buildup data bases
3531 {
3532 no strict "refs";
3534 if ($db_module eq "DBmysql") {
3536 daemon_log("0 INFO: importing database module '$db_module'", 1);
3538 # connect to incoming_db
3539 $incoming_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3541 # connect to gosa-si job queue
3542 $job_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3544 # connect to known_clients_db
3545 $known_clients_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3547 # connect to foreign_clients_db
3548 $foreign_clients_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3550 # connect to known_server_db
3551 $known_server_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3553 # connect to login_usr_db
3554 $login_users_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3556 # connect to fai_server_db
3557 $fai_server_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3559 # connect to fai_release_db
3560 $fai_release_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3562 # connect to packages_list_db
3563 $packages_list_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3565 # connect to messaging_db
3566 $messaging_db = ("GOSA::".$db_module)->new($main::mysql_database, $main::mysql_host, $main::mysql_username, $main::mysql_password);
3568 } elsif ($db_module eq "DBsqlite") {
3570 daemon_log("0 INFO: importing database module '$db_module'", 1);
3572 # connect to incoming_db
3573 unlink($incoming_file_name);
3574 $incoming_db = GOSA::DBsqlite->new($incoming_file_name);
3575 chmod(0640, $incoming_file_name);
3576 chown($root_uid, $adm_gid, $incoming_file_name);
3578 # connect to gosa-si job queue
3579 $job_db = GOSA::DBsqlite->new($job_queue_file_name);
3580 chmod(0640, $job_queue_file_name);
3581 chown($root_uid, $adm_gid, $job_queue_file_name);
3583 # connect to known_clients_db
3584 #unlink($known_clients_file_name);
3585 $known_clients_db = GOSA::DBsqlite->new($known_clients_file_name);
3586 chmod(0640, $known_clients_file_name);
3587 chown($root_uid, $adm_gid, $known_clients_file_name);
3589 # connect to foreign_clients_db
3590 #unlink($foreign_clients_file_name);
3591 $foreign_clients_db = GOSA::DBsqlite->new($foreign_clients_file_name);
3592 chmod(0640, $foreign_clients_file_name);
3593 chown($root_uid, $adm_gid, $foreign_clients_file_name);
3595 # connect to known_server_db
3596 unlink($known_server_file_name); # do not delete, gosa-si-server should be forced to check config file and dns at each start
3597 $known_server_db = GOSA::DBsqlite->new($known_server_file_name);
3598 chmod(0640, $known_server_file_name);
3599 chown($root_uid, $adm_gid, $known_server_file_name);
3601 # connect to login_usr_db
3602 #unlink($login_users_file_name);
3603 $login_users_db = GOSA::DBsqlite->new($login_users_file_name);
3604 chmod(0640, $login_users_file_name);
3605 chown($root_uid, $adm_gid, $login_users_file_name);
3607 # connect to fai_server_db
3608 unlink($fai_server_file_name);
3609 $fai_server_db = GOSA::DBsqlite->new($fai_server_file_name);
3610 chmod(0640, $fai_server_file_name);
3611 chown($root_uid, $adm_gid, $fai_server_file_name);
3613 # connect to fai_release_db
3614 unlink($fai_release_file_name);
3615 $fai_release_db = GOSA::DBsqlite->new($fai_release_file_name);
3616 chmod(0640, $fai_release_file_name);
3617 chown($root_uid, $adm_gid, $fai_release_file_name);
3619 # connect to packages_list_db
3620 unlink($packages_list_under_construction);
3621 $packages_list_db = GOSA::DBsqlite->new($packages_list_file_name);
3622 chmod(0640, $packages_list_file_name);
3623 chown($root_uid, $adm_gid, $packages_list_file_name);
3625 # connect to messaging_db
3626 #unlink($messaging_file_name);
3627 $messaging_db = GOSA::DBsqlite->new($messaging_file_name);
3628 chmod(0640, $messaging_file_name);
3629 chown($root_uid, $adm_gid, $messaging_file_name);
3630 }
3631 }
3633 # Creating tables
3635 daemon_log("0 INFO: creating tables in database with '$db_module'", 1);
3637 $messaging_db->create_table($messaging_tn, \@messaging_col_names);
3638 $packages_list_db->create_table($packages_list_tn, \@packages_list_col_names);
3639 $fai_release_db->create_table($fai_release_tn, \@fai_release_col_names);
3640 $fai_server_db->create_table($fai_server_tn, \@fai_server_col_names);
3641 $login_users_db->create_table($login_users_tn, \@login_users_col_names);
3642 $known_server_db->create_table($known_server_tn, \@known_server_col_names);
3643 $foreign_clients_db->create_table($foreign_clients_tn, \@foreign_clients_col_names);
3644 $known_clients_db->create_table($known_clients_tn, \@known_clients_col_names);
3645 $incoming_db->create_table($incoming_tn, \@incoming_col_names);
3646 $job_db->create_table($job_queue_tn, \@job_queue_col_names);
3648 # create xml object used for en/decrypting
3649 $xml = new XML::Simple();
3651 # Import all modules
3652 &import_modules;
3654 # Check wether all modules are gosa-si valid passwd check
3655 &password_check;
3657 # Check DNS and config file for server registration
3658 if ($serverPackages_enabled eq "true") { &prepare_server_registration; }
3660 # Create functions hash
3661 while (my ($module, @mod_info) = each %$known_modules)
3662 {
3663 while (my ($plugin, $functions) = each %{$mod_info[0][2]})
3664 {
3665 while (my ($function, $nothing) = each %$functions )
3666 {
3667 $known_functions->{$function} = $nothing;
3668 }
3669 }
3670 }
3672 # Prepare for using Opsi
3673 if ($opsi_enabled eq "true") {
3674 use JSON::RPC::Client;
3675 use XML::Quote qw(:all);
3676 $opsi_url= "https://".$opsi_admin.":".$opsi_password."@".$opsi_server.":4447/rpc";
3677 $opsi_client = new JSON::RPC::Client;
3678 }
3681 POE::Component::Server::TCP->new(
3682 Alias => "TCP_SERVER",
3683 Port => $server_port,
3684 ClientInput => sub {
3685 my ($kernel, $input, $heap, $session) = @_[KERNEL, ARG0, HEAP, SESSION];
3686 my $session_id = $session->ID;
3687 if ($input =~ /;([\d\.]+):([\d]+)$/)
3688 {
3689 # Messages from other servers should be blocked if config option is set
3690 if (($2 eq $server_port) && ($serverPackages_enabled eq "false"))
3691 {
3692 return;
3693 }
3694 &daemon_log("$session_id DEBUG: incoming message from '$1:$2'", 11);
3695 }
3696 else
3697 {
3698 my $remote_ip = $heap->{'remote_ip'};
3699 &daemon_log("$session_id DEBUG: incoming message from '$remote_ip'", 11);
3700 }
3701 push(@msgs_to_decrypt, $input);
3702 $kernel->yield("msg_to_decrypt");
3703 },
3704 InlineStates => {
3705 msg_to_decrypt => \&msg_to_decrypt,
3706 watch_for_next_tasks => \&watch_for_next_tasks,
3707 next_task => \&next_task,
3708 task_result => \&handle_task_result,
3709 task_done => \&handle_task_done,
3710 task_debug => \&handle_task_debug,
3711 child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!" },
3712 }
3713 );
3715 daemon_log("0 INFO: start socket for incoming xml messages at port '$server_port' ", 1);
3717 # create session for repeatedly checking the job queue for jobs
3718 POE::Session->create(
3719 inline_states => {
3720 _start => \&session_start,
3721 register_at_foreign_servers => \®ister_at_foreign_servers,
3722 control_server_registration => \&control_server_registration,
3723 sig_handler => \&sig_handler,
3724 next_task => \&next_task,
3725 task_result => \&handle_task_result,
3726 task_done => \&handle_task_done,
3727 task_debug => \&handle_task_debug,
3728 watch_for_new_messages => \&watch_for_new_messages,
3729 watch_for_delivery_messages => \&watch_for_delivery_messages,
3730 watch_for_done_messages => \&watch_for_done_messages,
3731 watch_for_new_jobs => \&watch_for_new_jobs,
3732 watch_for_modified_jobs => \&watch_for_modified_jobs,
3733 watch_for_done_jobs => \&watch_for_done_jobs,
3734 watch_for_opsi_jobs => \&watch_for_opsi_jobs,
3735 watch_for_old_known_clients => \&watch_for_old_known_clients,
3736 create_packages_list_db => \&run_create_packages_list_db,
3737 create_fai_server_db => \&run_create_fai_server_db,
3738 create_fai_release_db => \&run_create_fai_release_db,
3739 recreate_packages_db => \&run_recreate_packages_db,
3740 session_run_result => \&session_run_result,
3741 session_run_debug => \&session_run_debug,
3742 session_run_done => \&session_run_done,
3743 child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!" },
3744 }
3745 );
3748 POE::Kernel->run();
3749 exit;