45d0b2c1e49ef601d1469f8880ea5cd7f48a7712
1 #!/usr/bin/perl
2 #===============================================================================
3 #
4 # FILE: gosa-sd
5 #
6 # USAGE: ./gosa-sd
7 #
8 # DESCRIPTION:
9 #
10 # OPTIONS: ---
11 # REQUIREMENTS: libconfig-inifiles-perl libcrypt-rijndael-perl libxml-simple-perl
12 # libdata-dumper-simple-perl libdbd-sqlite3-perl libnet-ldap-perl
13 # libpoe-perl
14 # BUGS: ---
15 # NOTES:
16 # AUTHOR: (Andreas Rettenberger), <rettenberger@gonicus.de>
17 # COMPANY:
18 # VERSION: 1.0
19 # CREATED: 12.09.2007 08:54:41 CEST
20 # REVISION: ---
21 #===============================================================================
24 use strict;
25 use warnings;
26 use Getopt::Long;
27 use Config::IniFiles;
28 use POSIX;
30 use Fcntl;
31 use IO::Socket::INET;
32 use IO::Handle;
33 use IO::Select;
34 use Symbol qw(qualify_to_ref);
35 use Crypt::Rijndael;
36 use MIME::Base64;
37 use Digest::MD5 qw(md5 md5_hex md5_base64);
38 use XML::Simple;
39 use Data::Dumper;
40 use Sys::Syslog qw( :DEFAULT setlogsock);
41 use Cwd;
42 use File::Spec;
43 use File::Basename;
44 use File::Find;
45 use File::Copy;
46 use File::Path;
47 use GOSA::DBsqlite;
48 use GOSA::GosaSupportDaemon;
49 use POE qw(Component::Server::TCP Wheel::Run Filter::Reference);
50 use Net::LDAP;
51 use Net::LDAP::Util qw(:escape);
53 my $modules_path = "/usr/lib/gosa-si/modules";
54 use lib "/usr/lib/gosa-si/modules";
56 # TODO es gibt eine globale funktion get_ldap_handle
57 # - ist in einer session dieses ldap handle schon vorhanden, wird es zurückgegeben
58 # - ist es nicht vorhanden, wird es erzeugt, im heap für spätere ldap anfragen gespeichert und zurückgegeben
59 # - sessions die kein ldap handle brauchen, sollen auch keins haben
60 # - wird eine session geschlossen, muss das ldap verbindung vorher beendet werden
61 our $global_kernel;
63 my (%cfg_defaults, $foreground, $verbose, $ping_timeout);
64 my ($bus_activ, $bus, $msg_to_bus, $bus_cipher);
65 my ($server);
66 my ($gosa_server, $job_queue_timeout, $job_queue_loop_delay);
67 my ($messaging_db_loop_delay);
68 my ($known_modules);
69 my ($pid_file, $procid, $pid, $log_file);
70 my ($arp_activ, $arp_fifo);
71 my ($xml);
72 my $sources_list;
73 my $max_clients;
74 my %repo_files=();
75 my $repo_path;
76 my %repo_dirs=();
77 # variables declared in config file are always set to 'our'
78 our (%cfg_defaults, $log_file, $pid_file,
79 $server_ip, $server_port, $SIPackages_key,
80 $arp_activ, $gosa_unit_tag,
81 $GosaPackages_key, $gosa_ip, $gosa_port, $gosa_timeout,
82 );
84 # additional variable which should be globaly accessable
85 our $server_address;
86 our $server_mac_address;
87 our $bus_address;
88 our $gosa_address;
89 our $no_bus;
90 our $no_arp;
91 our $verbose;
92 our $forground;
93 our $cfg_file;
94 #our ($ldap_handle, $ldap_uri, $ldap_base, $ldap_admin_dn, $ldap_admin_password, $ldap_server_dn);
95 our ($ldap_uri, $ldap_base, $ldap_admin_dn, $ldap_admin_password, $ldap_server_dn);
98 # specifies the verbosity of the daemon_log
99 $verbose = 0 ;
101 # if foreground is not null, script will be not forked to background
102 $foreground = 0 ;
104 # specifies the timeout seconds while checking the online status of a registrating client
105 $ping_timeout = 5;
107 $no_bus = 0;
108 $bus_activ = "true";
109 $no_arp = 0;
110 my $packages_list_under_construction = "/tmp/packages_list_creation_in_progress";
111 my @packages_list_statements;
112 my $watch_for_new_jobs_in_progress = 0;
114 our $prg= basename($0);
116 # holds all gosa jobs
117 our $job_db;
118 our $job_queue_tn = 'jobs';
119 my $job_queue_file_name;
120 my @job_queue_col_names = ("id INTEGER PRIMARY KEY",
121 "timestamp DEFAULT 'none'",
122 "status DEFAULT 'none'",
123 "result DEFAULT 'none'",
124 "progress DEFAULT 'none'",
125 "headertag DEFAULT 'none'",
126 "targettag DEFAULT 'none'",
127 "xmlmessage DEFAULT 'none'",
128 "macaddress DEFAULT 'none'",
129 "plainname DEFAULT 'none'",
130 );
132 # holds all other gosa-sd as well as the gosa-sd-bus
133 our $known_server_db;
134 our $known_server_tn = "known_server";
135 my $known_server_file_name;
136 my @known_server_col_names = ("hostname", "status", "hostkey", "timestamp");
138 # holds all registrated clients
139 our $known_clients_db;
140 our $known_clients_tn = "known_clients";
141 my $known_clients_file_name;
142 my @known_clients_col_names = ("hostname", "status", "hostkey", "timestamp", "macaddress", "events");
144 # holds all logged in user at each client
145 our $login_users_db;
146 our $login_users_tn = "login_users";
147 my $login_users_file_name;
148 my @login_users_col_names = ("client", "user", "timestamp");
150 # holds all fai server, the debian release and tag
151 our $fai_server_db;
152 our $fai_server_tn = "fai_server";
153 my $fai_server_file_name;
154 our @fai_server_col_names = ("timestamp", "server", "release", "sections", "tag");
156 our $fai_release_db;
157 our $fai_release_tn = "fai_release";
158 my $fai_release_file_name;
159 our @fai_release_col_names = ("timestamp", "release", "class", "type", "state");
161 # holds all packages available from different repositories
162 our $packages_list_db;
163 our $packages_list_tn = "packages_list";
164 my $packages_list_file_name;
165 our @packages_list_col_names = ("distribution", "package", "version", "section", "description", "template", "timestamp");
166 my $outdir = "/tmp/packages_list_db";
167 my $arch = "i386";
169 # holds all messages which should be delivered to a user
170 our $messaging_db;
171 our $messaging_tn = "messaging";
172 our @messaging_col_names = ("id INTEGER", "subject", "message_from", "message_to",
173 "flag", "direction", "delivery_time", "message", "timestamp" );
174 my $messaging_file_name;
176 # path to directory to store client install log files
177 our $client_fai_log_dir = "/var/log/fai";
179 # queue which stores taskes until one of the $max_children children are ready to process the task
180 my @tasks = qw();
181 my $max_children = 2;
184 %cfg_defaults = (
185 "general" => {
186 "log-file" => [\$log_file, "/var/run/".$prg.".log"],
187 "pid-file" => [\$pid_file, "/var/run/".$prg.".pid"],
188 },
189 "bus" => {
190 "activ" => [\$bus_activ, "true"],
191 },
192 "server" => {
193 "port" => [\$server_port, "20081"],
194 "known-clients" => [\$known_clients_file_name, '/var/lib/gosa-si/clients.db' ],
195 "known-servers" => [\$known_server_file_name, '/var/lib/gosa-si/servers.db'],
196 "login-users" => [\$login_users_file_name, '/var/lib/gosa-si/users.db'],
197 "fai-server" => [\$fai_server_file_name, '/var/lib/gosa-si/fai_server.db'],
198 "fai-release" => [\$fai_release_file_name, '/var/lib/gosa-si/fai_release.db'],
199 "packages-list" => [\$packages_list_file_name, '/var/lib/gosa-si/packages.db'],
200 "messaging" => [\$messaging_file_name, '/var/lib/gosa-si/messaging.db'],
201 "source-list" => [\$sources_list, '/etc/apt/sources.list'],
202 "repo-path" => [\$repo_path, '/srv/www/repository'],
203 "ldap-uri" => [\$ldap_uri, ""],
204 "ldap-base" => [\$ldap_base, ""],
205 "ldap-admin-dn" => [\$ldap_admin_dn, ""],
206 "ldap-admin-password" => [\$ldap_admin_password, ""],
207 "gosa-unit-tag" => [\$gosa_unit_tag, ""],
208 "max-clients" => [\$max_clients, 10],
209 },
210 "GOsaPackages" => {
211 "ip" => [\$gosa_ip, "0.0.0.0"],
212 "port" => [\$gosa_port, "20082"],
213 "job-queue" => [\$job_queue_file_name, '/var/lib/gosa-si/jobs.db'],
214 "job-queue-loop-delay" => [\$job_queue_loop_delay, 3],
215 "messaging-db-loop-delay" => [\$messaging_db_loop_delay, 3],
216 "key" => [\$GosaPackages_key, "none"],
217 },
218 "SIPackages" => {
219 "key" => [\$SIPackages_key, "none"],
220 },
221 );
224 #=== FUNCTION ================================================================
225 # NAME: usage
226 # PARAMETERS: nothing
227 # RETURNS: nothing
228 # DESCRIPTION: print out usage text to STDERR
229 #===============================================================================
230 sub usage {
231 print STDERR << "EOF" ;
232 usage: $prg [-hvf] [-c config]
234 -h : this (help) message
235 -c <file> : config file
236 -f : foreground, process will not be forked to background
237 -v : be verbose (multiple to increase verbosity)
238 -no-bus : starts $prg without connection to bus
239 -no-arp : starts $prg without connection to arp module
241 EOF
242 print "\n" ;
243 }
246 #=== FUNCTION ================================================================
247 # NAME: read_configfile
248 # PARAMETERS: cfg_file - string -
249 # RETURNS: nothing
250 # DESCRIPTION: read cfg_file and set variables
251 #===============================================================================
252 sub read_configfile {
253 my $cfg;
254 if( defined( $cfg_file) && ( (-s $cfg_file) > 0 )) {
255 if( -r $cfg_file ) {
256 $cfg = Config::IniFiles->new( -file => $cfg_file );
257 } else {
258 print STDERR "Couldn't read config file!\n";
259 }
260 } else {
261 $cfg = Config::IniFiles->new() ;
262 }
263 foreach my $section (keys %cfg_defaults) {
264 foreach my $param (keys %{$cfg_defaults{ $section }}) {
265 my $pinfo = $cfg_defaults{ $section }{ $param };
266 ${@$pinfo[ 0 ]} = $cfg->val( $section, $param, @$pinfo[ 1 ] );
267 }
268 }
269 }
272 #=== FUNCTION ================================================================
273 # NAME: logging
274 # PARAMETERS: level - string - default 'info'
275 # msg - string -
276 # facility - string - default 'LOG_DAEMON'
277 # RETURNS: nothing
278 # DESCRIPTION: function for logging
279 #===============================================================================
280 sub daemon_log {
281 # log into log_file
282 my( $msg, $level ) = @_;
283 if(not defined $msg) { return }
284 if(not defined $level) { $level = 1 }
285 if(defined $log_file){
286 open(LOG_HANDLE, ">>$log_file");
287 if(not defined open( LOG_HANDLE, ">>$log_file" )) {
288 print STDERR "cannot open $log_file: $!";
289 return }
290 chomp($msg);
291 $msg =~s/\n//g; # no newlines are allowed in log messages, this is important for later log parsing
292 if($level <= $verbose){
293 my ($seconds, $minutes, $hours, $monthday, $month,
294 $year, $weekday, $yearday, $sommertime) = localtime(time);
295 $hours = $hours < 10 ? $hours = "0".$hours : $hours;
296 $minutes = $minutes < 10 ? $minutes = "0".$minutes : $minutes;
297 $seconds = $seconds < 10 ? $seconds = "0".$seconds : $seconds;
298 my @monthnames = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
299 $month = $monthnames[$month];
300 $monthday = $monthday < 10 ? $monthday = "0".$monthday : $monthday;
301 $year+=1900;
302 my $name = $prg;
304 my $log_msg = "$month $monthday $hours:$minutes:$seconds $name $msg\n";
305 print LOG_HANDLE $log_msg;
306 if( $foreground ) {
307 print STDERR $log_msg;
308 }
309 }
310 close( LOG_HANDLE );
311 }
312 }
315 #=== FUNCTION ================================================================
316 # NAME: check_cmdline_param
317 # PARAMETERS: nothing
318 # RETURNS: nothing
319 # DESCRIPTION: validates commandline parameter
320 #===============================================================================
321 sub check_cmdline_param () {
322 my $err_config;
323 my $err_counter = 0;
324 if(not defined($cfg_file)) {
325 $cfg_file = "/etc/gosa-si/server.conf";
326 if(! -r $cfg_file) {
327 $err_config = "please specify a config file";
328 $err_counter += 1;
329 }
330 }
331 if( $err_counter > 0 ) {
332 &usage( "", 1 );
333 if( defined( $err_config)) { print STDERR "$err_config\n"}
334 print STDERR "\n";
335 exit( -1 );
336 }
337 }
340 #=== FUNCTION ================================================================
341 # NAME: check_pid
342 # PARAMETERS: nothing
343 # RETURNS: nothing
344 # DESCRIPTION: handels pid processing
345 #===============================================================================
346 sub check_pid {
347 $pid = -1;
348 # Check, if we are already running
349 if( open(LOCK_FILE, "<$pid_file") ) {
350 $pid = <LOCK_FILE>;
351 if( defined $pid ) {
352 chomp( $pid );
353 if( -f "/proc/$pid/stat" ) {
354 my($stat) = `cat /proc/$pid/stat` =~ m/$pid \((.+)\).*/;
355 if( $stat ) {
356 daemon_log("ERROR: Already running",1);
357 close( LOCK_FILE );
358 exit -1;
359 }
360 }
361 }
362 close( LOCK_FILE );
363 unlink( $pid_file );
364 }
366 # create a syslog msg if it is not to possible to open PID file
367 if (not sysopen(LOCK_FILE, $pid_file, O_WRONLY|O_CREAT|O_EXCL, 0644)) {
368 my($msg) = "Couldn't obtain lockfile '$pid_file' ";
369 if (open(LOCK_FILE, '<', $pid_file)
370 && ($pid = <LOCK_FILE>))
371 {
372 chomp($pid);
373 $msg .= "(PID $pid)\n";
374 } else {
375 $msg .= "(unable to read PID)\n";
376 }
377 if( ! ($foreground) ) {
378 openlog( $0, "cons,pid", "daemon" );
379 syslog( "warning", $msg );
380 closelog();
381 }
382 else {
383 print( STDERR " $msg " );
384 }
385 exit( -1 );
386 }
387 }
389 #=== FUNCTION ================================================================
390 # NAME: import_modules
391 # PARAMETERS: module_path - string - abs. path to the directory the modules
392 # are stored
393 # RETURNS: nothing
394 # DESCRIPTION: each file in module_path which ends with '.pm' and activation
395 # state is on is imported by "require 'file';"
396 #===============================================================================
397 sub import_modules {
398 daemon_log(" ", 1);
400 if (not -e $modules_path) {
401 daemon_log("ERROR: cannot find directory or directory is not readable: $modules_path", 1);
402 }
404 opendir (DIR, $modules_path) or die "ERROR while loading modules from directory $modules_path : $!\n";
405 while (defined (my $file = readdir (DIR))) {
406 if (not $file =~ /(\S*?).pm$/) {
407 next;
408 }
409 my $mod_name = $1;
411 if( $file =~ /ArpHandler.pm/ ) {
412 if( $no_arp > 0 ) {
413 next;
414 }
415 }
417 eval { require $file; };
418 if ($@) {
419 daemon_log("ERROR: gosa-si-server could not load module $file", 1);
420 daemon_log("$@", 5);
421 } else {
422 my $info = eval($mod_name.'::get_module_info()');
423 # Only load module if get_module_info() returns a non-null object
424 if( $info ) {
425 my ($input_address, $input_key, $input, $input_active, $input_type) = @{$info};
426 $known_modules->{$mod_name} = $info;
427 daemon_log("INFO: module $mod_name loaded", 5);
428 }
429 }
430 }
431 close (DIR);
432 }
435 #=== FUNCTION ================================================================
436 # NAME: sig_int_handler
437 # PARAMETERS: signal - string - signal arose from system
438 # RETURNS: noting
439 # DESCRIPTION: handels tasks to be done befor signal becomes active
440 #===============================================================================
441 sub sig_int_handler {
442 my ($signal) = @_;
444 # if (defined($ldap_handle)) {
445 # $ldap_handle->disconnect;
446 # }
447 # TODO alle verbliebenden ldap verbindungen aus allen heaps beenden
450 daemon_log("shutting down gosa-si-server", 1);
451 system("kill `ps -C gosa-si-server -o pid=`");
452 }
453 $SIG{INT} = \&sig_int_handler;
456 sub check_key_and_xml_validity {
457 my ($crypted_msg, $module_key, $session_id) = @_;
458 my $msg;
459 my $msg_hash;
460 my $error_string;
461 eval{
462 $msg = &decrypt_msg($crypted_msg, $module_key);
464 if ($msg =~ /<xml>/i){
465 $msg =~ s/\s+/ /g; # just for better daemon_log
466 daemon_log("$session_id DEBUG: decrypted_msg: \n$msg", 8);
467 $msg_hash = $xml->XMLin($msg, ForceArray=>1);
469 ##############
470 # check header
471 if( not exists $msg_hash->{'header'} ) { die "no header specified"; }
472 my $header_l = $msg_hash->{'header'};
473 if( 1 > @{$header_l} ) { die 'empty header tag'; }
474 if( 1 < @{$header_l} ) { die 'more than one header specified'; }
475 my $header = @{$header_l}[0];
476 if( 0 == length $header) { die 'empty string in header tag'; }
478 ##############
479 # check source
480 if( not exists $msg_hash->{'source'} ) { die "no source specified"; }
481 my $source_l = $msg_hash->{'source'};
482 if( 1 > @{$source_l} ) { die 'empty source tag'; }
483 if( 1 < @{$source_l} ) { die 'more than one source specified'; }
484 my $source = @{$source_l}[0];
485 if( 0 == length $source) { die 'source error'; }
487 ##############
488 # check target
489 if( not exists $msg_hash->{'target'} ) { die "no target specified"; }
490 my $target_l = $msg_hash->{'target'};
491 if( 1 > @{$target_l} ) { die 'empty target tag'; }
492 }
493 };
494 if($@) {
495 daemon_log("$session_id DEBUG: do not understand the message: $@", 7);
496 $msg = undef;
497 $msg_hash = undef;
498 }
500 return ($msg, $msg_hash);
501 }
504 sub check_outgoing_xml_validity {
505 my ($msg) = @_;
507 my $msg_hash;
508 eval{
509 $msg_hash = $xml->XMLin($msg, ForceArray=>1);
511 ##############
512 # check header
513 my $header_l = $msg_hash->{'header'};
514 if( 1 != @{$header_l} ) {
515 die 'no or more than one headers specified';
516 }
517 my $header = @{$header_l}[0];
518 if( 0 == length $header) {
519 die 'header has length 0';
520 }
522 ##############
523 # check source
524 my $source_l = $msg_hash->{'source'};
525 if( 1 != @{$source_l} ) {
526 die 'no or more than 1 sources specified';
527 }
528 my $source = @{$source_l}[0];
529 if( 0 == length $source) {
530 die 'source has length 0';
531 }
532 unless( $source =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+$/ ||
533 $source =~ /^GOSA$/i ) {
534 die "source '$source' is neither a complete ip-address with port nor 'GOSA'";
535 }
537 ##############
538 # check target
539 my $target_l = $msg_hash->{'target'};
540 if( 0 == @{$target_l} ) {
541 die "no targets specified";
542 }
543 foreach my $target (@$target_l) {
544 if( 0 == length $target) {
545 die "target has length 0";
546 }
547 unless( $target =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+$/ ||
548 $target =~ /^GOSA$/i ||
549 $target =~ /^\*$/ ||
550 $target =~ /KNOWN_SERVER/i ||
551 $target =~ /JOBDB/i ||
552 $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 ){
553 die "target '$target' is not a complete ip-address with port or a valid target name or a mac-address";
554 }
555 }
556 };
557 if($@) {
558 daemon_log("WARNING: outgoing msg is not gosa-si envelope conform", 5);
559 daemon_log("$@ ".(defined($msg) && length($msg)>0)?$msg:"Empty Message", 8);
560 $msg_hash = undef;
561 }
563 return ($msg_hash);
564 }
567 sub input_from_known_server {
568 my ($input, $remote_ip, $session_id) = @_ ;
569 my ($msg, $msg_hash, $module);
571 my $sql_statement= "SELECT * FROM known_server";
572 my $query_res = $known_server_db->select_dbentry( $sql_statement );
574 while( my ($hit_num, $hit) = each %{ $query_res } ) {
575 my $host_name = $hit->{hostname};
576 if( not $host_name =~ "^$remote_ip") {
577 next;
578 }
579 my $host_key = $hit->{hostkey};
580 daemon_log("$session_id DEBUG: input_from_known_server: host_name: $host_name", 7);
581 daemon_log("DEBUG: input_from_known_server: host_key: $host_key", 7);
583 # check if module can open msg envelope with module key
584 my ($tmp_msg, $tmp_msg_hash) = &check_key_and_xml_validity($input, $host_key, $session_id);
585 if( (!$tmp_msg) || (!$tmp_msg_hash) ) {
586 daemon_log("$session_id DEBUG: input_from_known_server: deciphering raise error", 7);
587 daemon_log("$@", 8);
588 next;
589 }
590 else {
591 $msg = $tmp_msg;
592 $msg_hash = $tmp_msg_hash;
593 $module = "SIPackages";
594 last;
595 }
596 }
598 if( (!$msg) || (!$msg_hash) || (!$module) ) {
599 daemon_log("$session_id DEBUG: Incoming message is not from a known server", 7);
600 }
602 return ($msg, $msg_hash, $module);
603 }
606 sub input_from_known_client {
607 my ($input, $remote_ip, $session_id) = @_ ;
608 my ($msg, $msg_hash, $module);
610 my $sql_statement= "SELECT * FROM known_clients";
611 my $query_res = $known_clients_db->select_dbentry( $sql_statement );
612 while( my ($hit_num, $hit) = each %{ $query_res } ) {
613 my $host_name = $hit->{hostname};
614 if( not $host_name =~ /^$remote_ip:\d*$/) {
615 next;
616 }
617 my $host_key = $hit->{hostkey};
618 &daemon_log("$session_id DEBUG: input_from_known_client: host_name: $host_name", 7);
619 &daemon_log("$session_id DEBUG: input_from_known_client: host_key: $host_key", 7);
621 # check if module can open msg envelope with module key
622 ($msg, $msg_hash) = &check_key_and_xml_validity($input, $host_key, $session_id);
624 if( (!$msg) || (!$msg_hash) ) {
625 &daemon_log("$session_id DEGUG: input_from_known_client: deciphering raise error", 7);
626 &daemon_log("$@", 8);
627 next;
628 }
629 else {
630 $module = "SIPackages";
631 last;
632 }
633 }
635 if( (!$msg) || (!$msg_hash) || (!$module) ) {
636 &daemon_log("$session_id DEBUG: Incoming message is not from a known client", 7);
637 }
639 return ($msg, $msg_hash, $module);
640 }
643 sub input_from_unknown_host {
644 no strict "refs";
645 my ($input, $session_id) = @_ ;
646 my ($msg, $msg_hash, $module);
647 my $error_string;
649 my %act_modules = %$known_modules;
651 while( my ($mod, $info) = each(%act_modules)) {
653 # check a key exists for this module
654 my $module_key = ${$mod."_key"};
655 if( not defined $module_key ) {
656 if( $mod eq 'ArpHandler' ) {
657 next;
658 }
659 daemon_log("$session_id ERROR: no key specified in config file for $mod", 1);
660 next;
661 }
662 daemon_log("$session_id DEBUG: $mod: $module_key", 7);
664 # check if module can open msg envelope with module key
665 ($msg, $msg_hash) = &check_key_and_xml_validity($input, $module_key, $session_id);
666 if( (not defined $msg) || (not defined $msg_hash) ) {
667 next;
668 }
669 else {
670 $module = $mod;
671 last;
672 }
673 }
675 if( (!$msg) || (!$msg_hash) || (!$module)) {
676 daemon_log("$session_id DEBUG: Incoming message is not from an unknown host", 7);
677 }
679 return ($msg, $msg_hash, $module);
680 }
683 sub create_ciphering {
684 my ($passwd) = @_;
685 if((!defined($passwd)) || length($passwd)==0) {
686 $passwd = "";
687 }
688 $passwd = substr(md5_hex("$passwd") x 32, 0, 32);
689 my $iv = substr(md5_hex('GONICUS GmbH'),0, 16);
690 my $my_cipher = Crypt::Rijndael->new($passwd , Crypt::Rijndael::MODE_CBC());
691 $my_cipher->set_iv($iv);
692 return $my_cipher;
693 }
696 sub encrypt_msg {
697 my ($msg, $key) = @_;
698 my $my_cipher = &create_ciphering($key);
699 my $len;
700 {
701 use bytes;
702 $len= 16-length($msg)%16;
703 }
704 $msg = "\0"x($len).$msg;
705 $msg = $my_cipher->encrypt($msg);
706 chomp($msg = &encode_base64($msg));
707 # there are no newlines allowed inside msg
708 $msg=~ s/\n//g;
709 return $msg;
710 }
713 sub decrypt_msg {
715 my ($msg, $key) = @_ ;
716 $msg = &decode_base64($msg);
717 my $my_cipher = &create_ciphering($key);
718 $msg = $my_cipher->decrypt($msg);
719 $msg =~ s/\0*//g;
720 return $msg;
721 }
724 sub get_encrypt_key {
725 my ($target) = @_ ;
726 my $encrypt_key;
727 my $error = 0;
729 # target can be in known_server
730 if( not defined $encrypt_key ) {
731 my $sql_statement= "SELECT * FROM known_server WHERE hostname='$target'";
732 my $query_res = $known_server_db->select_dbentry( $sql_statement );
733 while( my ($hit_num, $hit) = each %{ $query_res } ) {
734 my $host_name = $hit->{hostname};
735 if( $host_name ne $target ) {
736 next;
737 }
738 $encrypt_key = $hit->{hostkey};
739 last;
740 }
741 }
743 # target can be in known_client
744 if( not defined $encrypt_key ) {
745 my $sql_statement= "SELECT * FROM known_clients WHERE hostname='$target'";
746 my $query_res = $known_clients_db->select_dbentry( $sql_statement );
747 while( my ($hit_num, $hit) = each %{ $query_res } ) {
748 my $host_name = $hit->{hostname};
749 if( $host_name ne $target ) {
750 next;
751 }
752 $encrypt_key = $hit->{hostkey};
753 last;
754 }
755 }
757 return $encrypt_key;
758 }
761 #=== FUNCTION ================================================================
762 # NAME: open_socket
763 # PARAMETERS: PeerAddr string something like 192.168.1.1 or 192.168.1.1:10000
764 # [PeerPort] string necessary if port not appended by PeerAddr
765 # RETURNS: socket IO::Socket::INET
766 # DESCRIPTION: open a socket to PeerAddr
767 #===============================================================================
768 sub open_socket {
769 my ($PeerAddr, $PeerPort) = @_ ;
770 if(defined($PeerPort)){
771 $PeerAddr = $PeerAddr.":".$PeerPort;
772 }
773 my $socket;
774 $socket = new IO::Socket::INET(PeerAddr => $PeerAddr,
775 Porto => "tcp",
776 Type => SOCK_STREAM,
777 Timeout => 5,
778 );
779 if(not defined $socket) {
780 return;
781 }
782 # &daemon_log("DEBUG: open_socket: $PeerAddr", 7);
783 return $socket;
784 }
787 #=== FUNCTION ================================================================
788 # NAME: get_ip
789 # PARAMETERS: interface name (i.e. eth0)
790 # RETURNS: (ip address)
791 # DESCRIPTION: Uses ioctl to get ip address directly from system.
792 #===============================================================================
793 sub get_ip {
794 my $ifreq= shift;
795 my $result= "";
796 my $SIOCGIFADDR= 0x8915; # man 2 ioctl_list
797 my $proto= getprotobyname('ip');
799 socket SOCKET, PF_INET, SOCK_DGRAM, $proto
800 or die "socket: $!";
802 if(ioctl SOCKET, $SIOCGIFADDR, $ifreq) {
803 my ($if, $sin) = unpack 'a16 a16', $ifreq;
804 my ($port, $addr) = sockaddr_in $sin;
805 my $ip = inet_ntoa $addr;
807 if ($ip && length($ip) > 0) {
808 $result = $ip;
809 }
810 }
812 return $result;
813 }
816 sub get_local_ip_for_remote_ip {
817 my $remote_ip= shift;
818 my $result="0.0.0.0";
820 if($remote_ip =~ /^(\d\d?\d?\.){3}\d\d?\d?$/) {
821 if($remote_ip eq "127.0.0.1") {
822 $result = "127.0.0.1";
823 } else {
824 my $PROC_NET_ROUTE= ('/proc/net/route');
826 open(PROC_NET_ROUTE, "<$PROC_NET_ROUTE")
827 or die "Could not open $PROC_NET_ROUTE";
829 my @ifs = <PROC_NET_ROUTE>;
831 close(PROC_NET_ROUTE);
833 # Eat header line
834 shift @ifs;
835 chomp @ifs;
836 foreach my $line(@ifs) {
837 my ($Iface,$Destination,$Gateway,$Flags,$RefCnt,$Use,$Metric,$Mask,$MTU,$Window,$IRTT)=split(/\s/, $line);
838 my $destination;
839 my $mask;
840 my ($d,$c,$b,$a)=unpack('a2 a2 a2 a2', $Destination);
841 $destination= sprintf("%d.%d.%d.%d", hex($a), hex($b), hex($c), hex($d));
842 ($d,$c,$b,$a)=unpack('a2 a2 a2 a2', $Mask);
843 $mask= sprintf("%d.%d.%d.%d", hex($a), hex($b), hex($c), hex($d));
844 if(new NetAddr::IP($remote_ip)->within(new NetAddr::IP($destination, $mask))) {
845 # destination matches route, save mac and exit
846 $result= &get_ip($Iface);
847 last;
848 }
849 }
850 }
851 } else {
852 daemon_log("get_local_ip_for_remote_ip was called with a non-ip parameter: $remote_ip", 1);
853 }
854 return $result;
855 }
858 sub send_msg_to_target {
859 my ($msg, $address, $encrypt_key, $msg_header, $session_id) = @_ ;
860 my $error = 0;
861 my $header;
862 my $new_status;
863 my $act_status;
864 my ($sql_statement, $res);
866 if( $msg_header ) {
867 $header = "'$msg_header'-";
868 } else {
869 $header = "";
870 }
872 # Patch the source ip
873 if($msg =~ /<source>0\.0\.0\.0:\d*?<\/source>/) {
874 my $remote_ip = &get_local_ip_for_remote_ip(sprintf("%s", $address =~ /^([0-9\.]*?):.*$/));
875 $msg =~ s/<source>(0\.0\.0\.0):(\d*?)<\/source>/<source>$remote_ip:$2<\/source>/s;
876 }
878 # encrypt xml msg
879 my $crypted_msg = &encrypt_msg($msg, $encrypt_key);
881 # opensocket
882 my $socket = &open_socket($address);
883 if( !$socket ) {
884 daemon_log("$session_id ERROR: cannot send ".$header."msg to $address , host not reachable", 1);
885 $error++;
886 }
888 if( $error == 0 ) {
889 # send xml msg
890 print $socket $crypted_msg."\n";
892 daemon_log("$session_id INFO: send ".$header."msg to $address", 5);
893 #daemon_log("DEBUG: message:\n$msg", 9);
895 }
897 # close socket in any case
898 if( $socket ) {
899 close $socket;
900 }
902 if( $error > 0 ) { $new_status = "down"; }
903 else { $new_status = $msg_header; }
906 # known_clients
907 $sql_statement = "SELECT * FROM known_clients WHERE hostname='$address'";
908 $res = $known_clients_db->select_dbentry($sql_statement);
909 if( keys(%$res) > 0) {
910 $act_status = $res->{1}->{'status'};
911 if( $act_status eq "down" ) {
912 $sql_statement = "DELETE FROM known_clients WHERE hostname='$address'";
913 $res = $known_clients_db->del_dbentry($sql_statement);
914 daemon_log("$session_id WARNING: failed 2x to send msg to host '$address', delete host from known_clients", 3);
915 } else {
916 $sql_statement = "UPDATE known_clients SET status='$new_status' WHERE hostname='$address'";
917 $res = $known_clients_db->update_dbentry($sql_statement);
918 if($new_status eq "down"){
919 daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
920 } else {
921 daemon_log("$session_id INFO: set '$address' from status '$act_status' to '$new_status'", 5);
922 }
923 }
924 }
926 # known_server
927 $sql_statement = "SELECT * FROM known_server WHERE hostname='$address'";
928 $res = $known_server_db->select_dbentry($sql_statement);
929 if( keys(%$res) > 0 ) {
930 $act_status = $res->{1}->{'status'};
931 if( $act_status eq "down" ) {
932 $sql_statement = "DELETE FROM known_server WHERE hostname='$address'";
933 $res = $known_server_db->del_dbentry($sql_statement);
934 daemon_log("$session_id WARNING: failed 2x to a send msg to host '$address', delete host from known_server", 3);
935 }
936 else {
937 $sql_statement = "UPDATE known_server SET status='$new_status' WHERE hostname='$address'";
938 $res = $known_server_db->update_dbentry($sql_statement);
939 if($new_status eq "down"){
940 daemon_log("$session_id WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
941 }
942 else {
943 daemon_log("$session_id INFO: set '$address' from status '$act_status' to '$new_status'", 5);
944 }
945 }
946 }
947 return $error;
948 }
951 sub update_jobdb_status_for_send_msgs {
952 my ($answer, $error) = @_;
953 if( $answer =~ /<jobdb_id>(\d+)<\/jobdb_id>/ ) {
954 my $jobdb_id = $1;
956 # sending msg faild
957 if( $error ) {
958 if (not $answer =~ /<header>trigger_action_reinstall<\/header>/) {
959 my $sql_statement = "UPDATE $job_queue_tn ".
960 "SET status='error', result='can not deliver msg, please consult log file' ".
961 "WHERE id=$jobdb_id";
962 my $res = $job_db->update_dbentry($sql_statement);
963 }
965 # sending msg was successful
966 } else {
967 my $sql_statement = "UPDATE $job_queue_tn ".
968 "SET status='done' ".
969 "WHERE id=$jobdb_id AND status='processed'";
970 my $res = $job_db->update_dbentry($sql_statement);
971 }
972 }
973 }
975 sub _start {
976 my ($kernel) = $_[KERNEL];
977 &trigger_db_loop($kernel);
978 $global_kernel = $kernel;
979 $kernel->yield('create_fai_server_db', $fai_server_tn );
980 $kernel->yield('create_fai_release_db', $fai_release_tn );
981 $kernel->sig(USR1 => "sig_handler");
982 $kernel->sig(USR2 => "create_packages_list_db");
983 }
985 sub sig_handler {
986 my ($kernel, $signal) = @_[KERNEL, ARG0] ;
987 daemon_log("0 INFO got signal '$signal'", 1);
988 $kernel->sig_handled();
989 return;
990 }
992 sub next_task {
993 my ($session, $heap) = @_[SESSION, HEAP];
995 while ( keys( %{ $heap->{task} } ) < $max_children ) {
996 my $next_task = shift @tasks;
997 last unless defined $next_task;
999 my $task = POE::Wheel::Run->new(
1000 Program => sub { process_task($session, $heap, $next_task) },
1001 StdioFilter => POE::Filter::Reference->new(),
1002 StdoutEvent => "task_result",
1003 StderrEvent => "task_debug",
1004 CloseEvent => "task_done",
1005 );
1007 $heap->{task}->{ $task->ID } = $task;
1008 }
1009 }
1011 sub handle_task_result {
1012 my ($kernel, $heap, $result) = @_[KERNEL, HEAP, ARG0];
1013 my $client_answer = $result->{'answer'};
1014 if( $client_answer =~ s/session_id=(\d+)$// ) {
1015 my $session_id = $1;
1016 if( defined $session_id ) {
1017 my $session_reference = $kernel->ID_id_to_session($session_id);
1018 if( defined $session_reference ) {
1019 $heap = $session_reference->get_heap();
1020 }
1021 }
1023 if(exists $heap->{'client'}) {
1024 $heap->{'client'}->put($client_answer);
1025 }
1026 }
1027 $kernel->sig(CHLD => "child_reap");
1028 }
1030 sub handle_task_debug {
1031 my $result = $_[ARG0];
1032 print STDERR "$result\n";
1033 }
1035 sub handle_task_done {
1036 my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
1037 delete $heap->{task}->{$task_id};
1038 $kernel->yield("next_task");
1039 }
1041 sub process_task {
1042 no strict "refs";
1043 my ($session, $heap, $input) = @_;
1044 my $session_id = $session->ID;
1045 my ($msg, $msg_hash, $module);
1046 my $error = 0;
1047 my $answer_l;
1048 my ($answer_header, @answer_target_l, $answer_source);
1049 my $client_answer = "";
1051 daemon_log("", 5);
1052 daemon_log("$session_id INFO: Incoming msg with session ID $session_id from '".$heap->{'remote_ip'}."'", 5);
1053 #daemon_log("$session_id DEBUG: Incoming msg:\n$input", 9);
1055 ####################
1056 # check incoming msg
1057 # msg is from a new client or gosa
1058 ($msg, $msg_hash, $module) = &input_from_unknown_host($input, $session_id);
1059 # msg is from a gosa-si-server or gosa-si-bus
1060 if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1061 ($msg, $msg_hash, $module) = &input_from_known_server($input, $heap->{'remote_ip'}, $session_id);
1062 }
1063 # msg is from a gosa-si-client
1064 if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1065 ($msg, $msg_hash, $module) = &input_from_known_client($input, $heap->{'remote_ip'}, $session_id);
1066 }
1067 # an error occurred
1068 if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
1069 # if an incoming msg could not be decrypted (maybe a wrong key), send client a ping. If the client
1070 # could not understand a msg from its server the client cause a re-registering process
1071 daemon_log("$session_id INFO cannot understand incoming msg, send 'ping'-msg to all host with ip '".$heap->{remote_ip}."' to cause a re-registering of the client if necessary", 5);
1072 my $sql_statement = "SELECT * FROM $main::known_clients_tn WHERE (hostname LIKE '".$heap->{'remote_ip'}."%')";
1073 my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1074 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1075 my $host_name = $hit->{'hostname'};
1076 my $host_key = $hit->{'hostkey'};
1077 my $ping_msg = "<xml> <header>gosa_ping</header> <source>$server_address</source> <target>$host_name</target></xml>";
1078 my $error = &send_msg_to_target($ping_msg, $host_name, $host_key, "gosa_ping", $session_id);
1079 &update_jobdb_status_for_send_msgs($ping_msg, $error);
1080 }
1081 $error++;
1082 }
1084 ######################
1085 # process incoming msg
1086 if( $error == 0) {
1087 daemon_log("$session_id INFO: Incoming msg with header '".@{$msg_hash->{'header'}}[0].
1088 "' from '".$heap->{'remote_ip'}."'", 5);
1089 daemon_log("$session_id DEBUG: Processing module ".$module, 7);
1090 $answer_l = &{ $module."::process_incoming_msg" }($msg, $msg_hash, $session_id);
1092 if ( 0 < @{$answer_l} ) {
1093 my $answer_str = join("\n", @{$answer_l});
1094 daemon_log("$session_id DEBUG: $module: Got answer from module: \n".$answer_str,8);
1095 } else {
1096 daemon_log("$session_id DEBUG: $module: Got no answer from module!" ,8);
1097 }
1099 }
1100 if( !$answer_l ) { $error++ };
1102 ########
1103 # answer
1104 if( $error == 0 ) {
1106 foreach my $answer ( @{$answer_l} ) {
1107 # for each answer in answer list
1109 # check outgoing msg to xml validity
1110 my $answer_hash = &check_outgoing_xml_validity($answer);
1111 if( not defined $answer_hash ) {
1112 next;
1113 }
1115 $answer_header = @{$answer_hash->{'header'}}[0];
1116 @answer_target_l = @{$answer_hash->{'target'}};
1117 $answer_source = @{$answer_hash->{'source'}}[0];
1119 # deliver msg to all targets
1120 foreach my $answer_target ( @answer_target_l ) {
1122 # targets of msg are all gosa-si-clients in known_clients_db
1123 if( $answer_target eq "*" ) {
1124 # answer is for all clients
1125 my $sql_statement= "SELECT * FROM known_clients";
1126 my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1127 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1128 my $host_name = $hit->{hostname};
1129 my $host_key = $hit->{hostkey};
1130 my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1131 &update_jobdb_status_for_send_msgs($answer, $error);
1132 }
1133 }
1135 # targets of msg are all gosa-si-server in known_server_db
1136 elsif( $answer_target eq "KNOWN_SERVER" ) {
1137 # answer is for all server in known_server
1138 my $sql_statement= "SELECT * FROM known_server";
1139 my $query_res = $known_server_db->select_dbentry( $sql_statement );
1140 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1141 my $host_name = $hit->{hostname};
1142 my $host_key = $hit->{hostkey};
1143 $answer =~ s/KNOWN_SERVER/$host_name/g;
1144 my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1145 &update_jobdb_status_for_send_msgs($answer, $error);
1146 }
1147 }
1149 # target of msg is GOsa
1150 elsif( $answer_target eq "GOSA" ) {
1151 my $session_id = ($1) if $answer =~ /<session_id>(\d+?)<\/session_id>/;
1152 my $add_on = "";
1153 if( defined $session_id ) {
1154 $add_on = ".session_id=$session_id";
1155 }
1156 # answer is for GOSA and has to returned to connected client
1157 my $gosa_answer = &encrypt_msg($answer, $GosaPackages_key);
1158 $client_answer = $gosa_answer.$add_on;
1159 }
1161 # target of msg is job queue at this host
1162 elsif( $answer_target eq "JOBDB") {
1163 $answer =~ /<header>(\S+)<\/header>/;
1164 my $header;
1165 if( defined $1 ) { $header = $1; }
1166 my $error = &send_msg_to_target($answer, $server_address, $GosaPackages_key, $header, $session_id);
1167 &update_jobdb_status_for_send_msgs($answer, $error);
1168 }
1170 # target of msg is a mac address
1171 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 ) {
1172 daemon_log("$session_id INFO: target is mac address '$answer_target', looking for host in known_clients", 5);
1173 my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$answer_target'";
1174 my $query_res = $known_clients_db->select_dbentry( $sql_statement );
1175 my $found_ip_flag = 0;
1176 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1177 my $host_name = $hit->{hostname};
1178 my $host_key = $hit->{hostkey};
1179 $answer =~ s/$answer_target/$host_name/g;
1180 daemon_log("$session_id INFO: found host '$host_name', associated to '$answer_target'", 5);
1181 my $error = &send_msg_to_target($answer, $host_name, $host_key, $answer_header, $session_id);
1182 &update_jobdb_status_for_send_msgs($answer, $error);
1183 $found_ip_flag++ ;
1184 }
1185 if( $found_ip_flag == 0) {
1186 daemon_log("$session_id WARNING: no host found in known_clients with mac address '$answer_target'", 3);
1187 if( $bus_activ eq "true" ) {
1188 daemon_log("$session_id INFO: try to forward msg '$answer_header' to bus '$bus_address'", 5);
1189 my $sql_statement = "SELECT * FROM known_server WHERE hostname='$bus_address'";
1190 my $query_res = $known_server_db->select_dbentry( $sql_statement );
1191 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1192 my $bus_address = $hit->{hostname};
1193 my $bus_key = $hit->{hostkey};
1194 my $error = &send_msg_to_target($answer, $bus_address, $bus_key, $answer_header, $session_id);
1195 &update_jobdb_status_for_send_msgs($answer, $error);
1196 last;
1197 }
1198 }
1200 }
1202 # answer is for one specific host
1203 } else {
1204 # get encrypt_key
1205 my $encrypt_key = &get_encrypt_key($answer_target);
1206 if( not defined $encrypt_key ) {
1207 # unknown target, forward msg to bus
1208 daemon_log("$session_id WARNING: unknown target '$answer_target'", 3);
1209 if( $bus_activ eq "true" ) {
1210 daemon_log("$session_id INFO: try to forward msg '$answer_header' to bus '$bus_address'", 5);
1211 my $sql_statement = "SELECT * FROM known_server WHERE hostname='$bus_address'";
1212 my $query_res = $known_server_db->select_dbentry( $sql_statement );
1213 my $res_length = keys( %{$query_res} );
1214 if( $res_length == 0 ){
1215 daemon_log("$session_id WARNING: send '$answer_header' to '$bus_address' failed, ".
1216 "no bus found in known_server", 3);
1217 }
1218 else {
1219 while( my ($hit_num, $hit) = each %{ $query_res } ) {
1220 my $bus_key = $hit->{hostkey};
1221 my $error = &send_msg_to_target($answer, $bus_address, $bus_key, $answer_header,$session_id );
1222 &update_jobdb_status_for_send_msgs($answer, $error);
1223 }
1224 }
1225 }
1226 next;
1227 }
1228 my $error = &send_msg_to_target($answer, $answer_target, $encrypt_key, $answer_header,$session_id);
1229 &update_jobdb_status_for_send_msgs($answer, $error);
1230 }
1231 }
1232 }
1233 }
1235 my $filter = POE::Filter::Reference->new();
1236 my %result = (
1237 status => "seems ok to me",
1238 answer => $client_answer,
1239 );
1241 my $output = $filter->put( [ \%result ] );
1242 print @$output;
1245 }
1248 sub trigger_db_loop {
1249 my ($kernel) = @_ ;
1250 $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
1251 $kernel->delay_set('watch_for_done_jobs', $job_queue_loop_delay);
1252 $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
1253 $kernel->delay_set('watch_for_delivery_messages', $messaging_db_loop_delay);
1254 $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
1255 }
1258 sub watch_for_done_jobs {
1259 my ($kernel,$heap) = @_[KERNEL, HEAP];
1261 my $sql_statement = "SELECT * FROM ".$job_queue_tn.
1262 " WHERE status='done'";
1263 my $res = $job_db->select_dbentry( $sql_statement );
1265 while( my ($id, $hit) = each %{$res} ) {
1266 my $jobdb_id = $hit->{id};
1267 my $sql_statement = "DELETE FROM $job_queue_tn WHERE id=$jobdb_id";
1268 my $res = $job_db->del_dbentry($sql_statement);
1269 }
1271 $kernel->delay_set('watch_for_done_jobs',$job_queue_loop_delay);
1272 }
1275 sub watch_for_new_jobs {
1276 if($watch_for_new_jobs_in_progress == 0) {
1277 $watch_for_new_jobs_in_progress = 1;
1278 my ($kernel,$heap) = @_[KERNEL, HEAP];
1280 # check gosa job queue for jobs with executable timestamp
1281 my $timestamp = &get_time();
1282 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE status='waiting' AND (CAST (timestamp AS INTEGER)) < $timestamp ORDER BY timestamp";
1283 my $res = $job_db->exec_statement( $sql_statement );
1285 # Merge all new jobs that would do the same actions
1286 my @drops;
1287 my $hits;
1288 foreach my $hit (reverse @{$res} ) {
1289 my $macaddress= lc @{$hit}[8];
1290 my $headertag= @{$hit}[5];
1291 if(
1292 defined($hits->{$macaddress}) &&
1293 defined($hits->{$macaddress}->{$headertag}) &&
1294 defined($hits->{$macaddress}->{$headertag}[0])
1295 ) {
1296 push @drops, "DELETE FROM $job_queue_tn WHERE id = $hits->{$macaddress}->{$headertag}[0]";
1297 }
1298 $hits->{$macaddress}->{$headertag}= $hit;
1299 }
1301 # Delete new jobs with a matching job in state 'processing'
1302 foreach my $macaddress (keys %{$hits}) {
1303 foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
1304 my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
1305 if(defined($jobdb_id)) {
1306 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND headertag='$jobdb_headertag' AND status='processing'";
1307 my $res = $job_db->exec_statement( $sql_statement );
1308 foreach my $hit (@{$res}) {
1309 push @drops, "DELETE FROM $job_queue_tn WHERE id=$jobdb_id";
1310 }
1311 } else {
1312 daemon_log("J ERROR: Job without id exists for macaddress $macaddress!", 1);
1313 }
1314 }
1315 }
1317 # Commit deletion
1318 $job_db->exec_statementlist(\@drops);
1320 # Look for new jobs that could be executed
1321 foreach my $macaddress (keys %{$hits}) {
1323 # Look if there is an executing job
1324 my $sql_statement = "SELECT * FROM $job_queue_tn WHERE macaddress LIKE '$macaddress' AND status='processing'";
1325 my $res = $job_db->exec_statement( $sql_statement );
1327 # Skip new jobs for host if there is a processing job
1328 if(defined($res) and defined @{$res}[0]) {
1329 next;
1330 }
1332 foreach my $jobdb_headertag (keys %{$hits->{$macaddress}}) {
1333 my $jobdb_id = @{$hits->{$macaddress}->{$jobdb_headertag}}[0];
1334 if(defined($jobdb_id)) {
1335 my $job_msg = @{$hits->{$macaddress}->{$jobdb_headertag}}[7];
1337 daemon_log("J DEBUG: its time to execute $job_msg", 7);
1338 my $sql_statement = "SELECT * FROM known_clients WHERE macaddress LIKE '$macaddress'";
1339 my $res_hash = $known_clients_db->select_dbentry( $sql_statement );
1341 # expect macaddress is unique!!!!!!
1342 my $target = $res_hash->{1}->{hostname};
1344 # change header
1345 $job_msg =~ s/<header>job_/<header>gosa_/;
1347 # add sqlite_id
1348 $job_msg =~ s/<\/xml>$/<jobdb_id>$jobdb_id<\/jobdb_id><\/xml>/;
1350 $job_msg =~ /<header>(\S+)<\/header>/;
1351 my $header = $1 ;
1352 my $func_error = &send_msg_to_target($job_msg, $server_address, $GosaPackages_key, $header, "J");
1354 # update status in job queue to 'processing'
1355 $sql_statement = "UPDATE $job_queue_tn SET status='processing' WHERE id=$jobdb_id";
1356 my $res = $job_db->update_dbentry($sql_statement);
1357 # TODO: abfangen ob alles in ordnung ist oder nicht, wenn nicht error schmeißen
1359 # We don't want parallel processing
1360 last;
1361 }
1362 }
1363 }
1365 $watch_for_new_jobs_in_progress = 0;
1366 $kernel->delay_set('watch_for_new_jobs', $job_queue_loop_delay);
1367 }
1368 }
1371 sub watch_for_new_messages {
1372 my ($kernel,$heap) = @_[KERNEL, HEAP];
1373 my @coll_user_msg; # collection list of outgoing messages
1375 # check messaging_db for new incoming messages with executable timestamp
1376 my $timestamp = &get_time();
1377 my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( (CAST(timestamp AS INTEGER))<$timestamp AND flag='n' AND direction='in' )";
1378 my $res = $messaging_db->exec_statement( $sql_statement );
1379 foreach my $hit (@{$res}) {
1381 # create outgoing messages
1382 my $message_to = @{$hit}[3];
1384 # translate message_to to plain login name
1385 my @message_to_l = split(/,/, $message_to);
1386 my %receiver_h;
1387 foreach my $receiver (@message_to_l) {
1388 if ($receiver =~ /^u_([\s\S]*)$/) {
1389 $receiver_h{$1} = 0;
1390 } elsif ($receiver =~ /^g_([\s\S]*)$/) {
1391 # TODO implement receiver translation
1392 } else {
1393 my $sbjct = &encode_base64(@{$hit}[1]);
1394 my $msg = &encode_base64(@{$hit}[7]);
1395 &daemon_log("M WARNING: unknown receiver '$receiver' for a user-message 'sbjct - msg'", 3);
1396 }
1397 }
1398 my @receiver_l = keys(%receiver_h);
1400 my $message_id = @{$hit}[0];
1402 #add each outgoing msg to messaging_db
1403 my $receiver;
1404 foreach $receiver (@receiver_l) {
1405 my $sql_statement = "INSERT INTO $messaging_tn (id, subject, message_from, message_to, flag, direction, delivery_time, message, timestamp) ".
1406 "VALUES ('".
1407 $message_id."', '". # id
1408 @{$hit}[1]."', '". # subject
1409 @{$hit}[2]."', '". # message_from
1410 $receiver."', '". # message_to
1411 "none"."', '". # flag
1412 "out"."', '". # direction
1413 @{$hit}[6]."', '". # delivery_time
1414 @{$hit}[7]."', '". # message
1415 $timestamp."'". # timestamp
1416 ")";
1417 &daemon_log("M DEBUG: $sql_statement", 1);
1418 my $res = $messaging_db->exec_statement($sql_statement);
1419 &daemon_log("M INFO: message '".@{$hit}[0]."' is prepared for delivery to receiver '$receiver'", 5);
1420 }
1422 # set incoming message to flag d=deliverd
1423 $sql_statement = "UPDATE $messaging_tn SET flag='p' WHERE id='$message_id'";
1424 &daemon_log("M DEBUG: $sql_statement", 7);
1425 $res = $messaging_db->update_dbentry($sql_statement);
1426 &daemon_log("M INFO: message '$message_id' is set to flag 'p' (processed)", 5);
1427 }
1429 $kernel->delay_set('watch_for_new_messages', $messaging_db_loop_delay);
1430 return;
1431 }
1433 sub watch_for_delivery_messages {
1434 my ($kernel, $heap) = @_[KERNEL, HEAP];
1436 # select outgoing messages
1437 my $sql_statement = "SELECT * FROM $messaging_tn WHERE ( flag='p' AND direction='out' )";
1438 #&daemon_log("0 DEBUG: $sql", 7);
1439 my $res = $messaging_db->exec_statement( $sql_statement );
1441 # build out msg for each usr
1442 foreach my $hit (@{$res}) {
1443 my $receiver = @{$hit}[3];
1444 my $msg_id = @{$hit}[0];
1445 my $subject = @{$hit}[1];
1446 my $message = @{$hit}[7];
1448 # resolve usr -> host where usr is logged in
1449 my $sql = "SELECT * FROM $login_users_tn WHERE (user='$receiver')";
1450 #&daemon_log("0 DEBUG: $sql", 7);
1451 my $res = $login_users_db->exec_statement($sql);
1453 # reciver is logged in nowhere
1454 if (not ref(@$res[0]) eq "ARRAY") { next; }
1456 # receiver is logged in at host
1457 my $receiver_host = @{@{$res}[0]}[0];
1459 # fetch key to encrypt msg propperly for usr/host
1460 $sql = "SELECT * FROM $known_clients_tn WHERE (hostname='$receiver_host')";
1461 &daemon_log("0 DEBUG: $sql", 7);
1462 $res = $known_clients_db->exec_statement($sql);
1463 my $receiver_key = @{@{$res}[0]}[2];
1465 my %data = ('subject' => $subject, 'message' => $message, 'usr' => $receiver);
1466 my $out_msg = &build_msg("usr_msg", $server_address, $receiver_host, \%data );
1467 my $error_state = &send_msg_to_target($out_msg, $receiver_host, $receiver_key, "usr_msg", 0);
1469 if ($error_state == 0) {
1470 # set outgoing msg at db to deliverd
1471 my $sql = "UPDATE $messaging_tn SET flag='d' WHERE (id='$msg_id' AND direction='out' AND message_to='$receiver')";
1472 &daemon_log("0 DEBUG: $sql", 7);
1473 my $res = $messaging_db->exec_statement($sql);
1474 }
1475 }
1477 $kernel->delay_set('watch_for_delivery_messages', $messaging_db_loop_delay);
1478 return;
1479 }
1482 sub watch_for_done_messages {
1483 my ($kernel,$heap) = @_[KERNEL, HEAP];
1485 my $sql = "SELECT * FROM $messaging_tn WHERE (flag='p' AND direction='in')";
1486 #&daemon_log("0 DEBUG: $sql", 7);
1487 my $res = $messaging_db->exec_statement($sql);
1489 foreach my $hit (@{$res}) {
1490 my $msg_id = @{$hit}[0];
1492 my $sql = "SELECT * FROM $messaging_tn WHERE (id='$msg_id' AND direction='out' AND (NOT flag='s'))";
1493 #&daemon_log("0 DEBUG: $sql", 7);
1494 my $res = $messaging_db->exec_statement($sql);
1496 # not all usr msgs have been seen till now
1497 if ( ref(@$res[0]) eq "ARRAY") { next; }
1499 $sql = "DELETE FROM $messaging_tn WHERE (id='$msg_id')";
1500 #&daemon_log("0 DEBUG: $sql", 7);
1501 $res = $messaging_db->exec_statement($sql);
1503 }
1505 $kernel->delay_set('watch_for_done_messages', $messaging_db_loop_delay);
1506 return;
1507 }
1510 sub get_ldap_handle {
1511 my ($session_id) = @_;
1512 my $heap;
1513 my $ldap_handle;
1515 if (not defined $session_id ) { $session_id = 0 };
1516 if ($session_id =~ /[^0-9]*/) { $session_id = 0 };
1518 if ($session_id == 0) {
1519 daemon_log("$session_id DEBUG: get_ldap_handle invoked without a session_id, create a new ldap_handle", 7);
1520 $ldap_handle = Net::LDAP->new( $ldap_uri );
1521 $ldap_handle->bind($ldap_admin_dn, password => $ldap_admin_password);
1523 } else {
1524 my $session_reference = $global_kernel->ID_id_to_session($session_id);
1525 if( defined $session_reference ) {
1526 $heap = $session_reference->get_heap();
1527 }
1529 if (not defined $heap) {
1530 daemon_log("$session_id DEBUG: cannot get heap for session_id '$session_id'", 7);
1531 return;
1532 }
1534 # TODO: This "if" is nonsense, because it doesn't prove that the
1535 # used handle is still valid - or if we've to reconnect...
1536 #if (not exists $heap->{ldap_handle}) {
1537 $ldap_handle = Net::LDAP->new( $ldap_uri );
1538 $ldap_handle->bind($ldap_admin_dn, password => $ldap_admin_password);
1539 $heap->{ldap_handle} = $ldap_handle;
1540 #}
1541 }
1542 return $ldap_handle;
1543 }
1546 sub change_fai_state {
1547 my ($st, $targets, $session_id) = @_;
1548 $session_id = 0 if not defined $session_id;
1549 # Set FAI state to localboot
1550 my %mapActions= (
1551 reboot => '',
1552 update => 'softupdate',
1553 localboot => 'localboot',
1554 reinstall => 'install',
1555 rescan => '',
1556 wake => '',
1557 memcheck => 'memcheck',
1558 sysinfo => 'sysinfo',
1559 install => 'install',
1560 );
1562 # Return if this is unknown
1563 if (!exists $mapActions{ $st }){
1564 daemon_log("$session_id ERROR: unknown action '$st', can not translate ot FAIstate", 1);
1565 return;
1566 }
1568 my $state= $mapActions{ $st };
1570 my $ldap_handle = &get_ldap_handle($session_id);
1571 if( defined($ldap_handle) ) {
1573 # Build search filter for hosts
1574 my $search= "(&(objectClass=GOhard)";
1575 foreach (@{$targets}){
1576 $search.= "(macAddress=$_)";
1577 }
1578 $search.= ")";
1580 # If there's any host inside of the search string, procress them
1581 if (!($search =~ /macAddress/)){
1582 daemon_log("$session_id ERROR: no macAddress found in filter statement for LDAP search: '$search'", 1);
1583 return;
1584 }
1586 # Perform search for Unit Tag
1587 my $mesg = $ldap_handle->search(
1588 base => $ldap_base,
1589 scope => 'sub',
1590 attrs => ['dn', 'FAIstate', 'objectClass'],
1591 filter => "$search"
1592 );
1594 if ($mesg->count) {
1595 my @entries = $mesg->entries;
1596 foreach my $entry (@entries) {
1597 # Only modify entry if it is not set to '$state'
1598 if ($entry->get_value("FAIstate") ne "$state"){
1599 daemon_log("$session_id INFO: Setting FAIstate to '$state' for ".$entry->dn, 5);
1600 my $result;
1601 my %tmp = map { $_ => 1 } $entry->get_value("objectClass");
1602 if (exists $tmp{'FAIobject'}){
1603 if ($state eq ''){
1604 $result= $ldap_handle->modify($entry->dn, changes => [
1605 delete => [ FAIstate => [] ] ]);
1606 } else {
1607 $result= $ldap_handle->modify($entry->dn, changes => [
1608 replace => [ FAIstate => $state ] ]);
1609 }
1610 } elsif ($state ne ''){
1611 $result= $ldap_handle->modify($entry->dn, changes => [
1612 add => [ objectClass => 'FAIobject' ],
1613 add => [ FAIstate => $state ] ]);
1614 }
1616 # Errors?
1617 if ($result->code){
1618 daemon_log("$session_id Error: Setting FAIstate to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
1619 }
1620 } else {
1621 daemon_log("$session_id DEBUG FAIstate at host '".$entry->dn."' already at state '$st'", 7);
1622 }
1623 }
1624 }
1625 # if no ldap handle defined
1626 } else {
1627 daemon_log("$session_id ERROR: no LDAP handle defined for update FAIstate", 1);
1628 }
1630 }
1633 sub change_goto_state {
1634 my ($st, $targets, $session_id) = @_;
1635 $session_id = 0 if not defined $session_id;
1637 # Switch on or off?
1638 my $state= $st eq 'active' ? 'active': 'locked';
1640 my $ldap_handle = &get_ldap_handle($session_id);
1641 if( defined($ldap_handle) ) {
1643 # Build search filter for hosts
1644 my $search= "(&(objectClass=GOhard)";
1645 foreach (@{$targets}){
1646 $search.= "(macAddress=$_)";
1647 }
1648 $search.= ")";
1650 # If there's any host inside of the search string, procress them
1651 if (!($search =~ /macAddress/)){
1652 return;
1653 }
1655 # Perform search for Unit Tag
1656 my $mesg = $ldap_handle->search(
1657 base => $ldap_base,
1658 scope => 'sub',
1659 attrs => ['dn', 'gotoMode'],
1660 filter => "$search"
1661 );
1663 if ($mesg->count) {
1664 my @entries = $mesg->entries;
1665 foreach my $entry (@entries) {
1667 # Only modify entry if it is not set to '$state'
1668 if ($entry->get_value("gotoMode") ne $state){
1670 daemon_log("$session_id INFO: Setting gotoMode to '$state' for ".$entry->dn, 5);
1671 my $result;
1672 $result= $ldap_handle->modify($entry->dn, changes => [
1673 replace => [ gotoMode => $state ] ]);
1675 # Errors?
1676 if ($result->code){
1677 &daemon_log("$session_id Error: Setting gotoMode to '$state' for ".$entry->dn. "failed: ".$result->error, 1);
1678 }
1680 }
1681 }
1682 }
1684 }
1685 }
1688 sub run_create_fai_server_db {
1689 my ($kernel, $session, $heap, $table_name) = @_[KERNEL, SESSION, HEAP, ARG0];
1690 my $session_id = $session->ID;
1691 my $task = POE::Wheel::Run->new(
1692 Program => sub { &create_fai_server_db($table_name,$kernel, undef, $session_id) },
1693 StdoutEvent => "session_run_result",
1694 StderrEvent => "session_run_debug",
1695 CloseEvent => "session_run_done",
1696 );
1698 $heap->{task}->{ $task->ID } = $task;
1699 return;
1700 }
1703 sub create_fai_server_db {
1704 my ($table_name, $kernel, $dont_create_packages_list, $session_id) = @_;
1705 my $result;
1707 if (not defined $session_id) { $session_id = 0; }
1708 my $ldap_handle = &get_ldap_handle();
1709 if(defined($ldap_handle)) {
1710 daemon_log("$session_id INFO: create_fai_server_db: start", 5);
1711 my $mesg= $ldap_handle->search(
1712 base => $ldap_base,
1713 scope => 'sub',
1714 attrs => ['FAIrepository', 'gosaUnitTag'],
1715 filter => "(&(FAIrepository=*)(objectClass=FAIrepositoryServer))",
1716 );
1717 if($mesg->{'resultCode'} == 0 &&
1718 $mesg->count != 0) {
1719 foreach my $entry (@{$mesg->{entries}}) {
1720 if($entry->exists('FAIrepository')) {
1721 # Add an entry for each Repository configured for server
1722 foreach my $repo(@{$entry->get_value('FAIrepository', asref => 1)}) {
1723 my($tmp_url,$tmp_server,$tmp_release,$tmp_sections) = split(/\|/, $repo);
1724 my $tmp_tag= $entry->get_value('gosaUnitTag') || "";
1725 $result= $fai_server_db->add_dbentry( {
1726 table => $table_name,
1727 primkey => ['server', 'release', 'tag'],
1728 server => $tmp_url,
1729 release => $tmp_release,
1730 sections => $tmp_sections,
1731 tag => (length($tmp_tag)>0)?$tmp_tag:"",
1732 } );
1733 }
1734 }
1735 }
1736 }
1737 daemon_log("$session_id INFO: create_fai_server_db: finished", 5);
1739 # TODO: Find a way to post the 'create_packages_list_db' event
1740 if(not defined($dont_create_packages_list)) {
1741 &create_packages_list_db(undef, undef, $session_id);
1742 }
1743 }
1745 $ldap_handle->disconnect;
1746 return $result;
1747 }
1750 sub run_create_fai_release_db {
1751 my ($session, $heap, $table_name) = @_[SESSION, HEAP, ARG0];
1752 my $session_id = $session->ID;
1753 my $task = POE::Wheel::Run->new(
1754 Program => sub { &create_fai_release_db($table_name, $session_id) },
1755 StdoutEvent => "session_run_result",
1756 StderrEvent => "session_run_debug",
1757 CloseEvent => "session_run_done",
1758 );
1760 $heap->{task}->{ $task->ID } = $task;
1761 return;
1762 }
1765 sub create_fai_release_db {
1766 my ($table_name, $session_id) = @_;
1767 my $result;
1769 # used for logging
1770 if (not defined $session_id) { $session_id = 0; }
1772 my $ldap_handle = &get_ldap_handle();
1773 if(defined($ldap_handle)) {
1774 daemon_log("$session_id INFO: create_fai_release_db: start",5);
1775 my $mesg= $ldap_handle->search(
1776 base => $ldap_base,
1777 scope => 'sub',
1778 attrs => [],
1779 filter => "(&(objectClass=organizationalUnit)(ou=fai))",
1780 );
1781 if($mesg->{'resultCode'} == 0 &&
1782 $mesg->count != 0) {
1783 # Walk through all possible FAI container ou's
1784 my @sql_list;
1785 my $timestamp= &get_time();
1786 foreach my $ou (@{$mesg->{entries}}) {
1787 my $tmp_classes= resolve_fai_classes($ou->dn, $ldap_handle, $session_id);
1788 if(defined($tmp_classes) && ref($tmp_classes) eq 'HASH') {
1789 my @tmp_array=get_fai_release_entries($tmp_classes);
1790 if(@tmp_array) {
1791 foreach my $entry (@tmp_array) {
1792 if(defined($entry) && ref($entry) eq 'HASH') {
1793 my $sql=
1794 "INSERT INTO $table_name "
1795 ."(timestamp, release, class, type, state) VALUES ("
1796 .$timestamp.","
1797 ."'".$entry->{'release'}."',"
1798 ."'".$entry->{'class'}."',"
1799 ."'".$entry->{'type'}."',"
1800 ."'".$entry->{'state'}."')";
1801 push @sql_list, $sql;
1802 }
1803 }
1804 }
1805 }
1806 }
1808 daemon_log("$session_id DEBUG: Inserting ".scalar @sql_list." entries to DB",8);
1809 if(@sql_list) {
1810 unshift @sql_list, "VACUUM";
1811 unshift @sql_list, "DELETE FROM $table_name";
1812 $fai_release_db->exec_statementlist(\@sql_list);
1813 }
1814 daemon_log("$session_id DEBUG: Done with inserting",7);
1815 }
1816 daemon_log("$session_id INFO: create_fai_release_db: finished",5);
1817 }
1818 $ldap_handle->disconnect;
1819 return $result;
1820 }
1822 sub get_fai_types {
1823 my $tmp_classes = shift || return undef;
1824 my @result;
1826 foreach my $type(keys %{$tmp_classes}) {
1827 if(defined($tmp_classes->{$type}[0]) && (!($tmp_classes->{$type}[0] =~ /^.*?removed.*?$/))) {
1828 my $entry = {
1829 type => $type,
1830 state => $tmp_classes->{$type}[0],
1831 };
1832 push @result, $entry;
1833 }
1834 }
1836 return @result;
1837 }
1839 sub get_fai_state {
1840 my $result = "";
1841 my $tmp_classes = shift || return $result;
1843 foreach my $type(keys %{$tmp_classes}) {
1844 if(defined($tmp_classes->{$type}[0])) {
1845 $result = $tmp_classes->{$type}[0];
1847 # State is equal for all types in class
1848 last;
1849 }
1850 }
1852 return $result;
1853 }
1855 sub resolve_fai_classes {
1856 my ($fai_base, $ldap_handle, $session_id) = @_;
1857 if (not defined $session_id) { $session_id = 0; }
1858 my $result;
1859 my @possible_fai_classes= ("FAIscript", "FAIhook", "FAIpartitionTable", "FAItemplate", "FAIvariable", "FAIprofile", "FAIpackageList");
1860 my $fai_filter= "(|(&(objectClass=FAIclass)(|(objectClass=".join(")(objectClass=", @possible_fai_classes).")))(objectClass=FAIbranch))";
1861 my $fai_classes;
1863 daemon_log("$session_id DEBUG: Searching for FAI entries in base $fai_base",7);
1864 my $mesg= $ldap_handle->search(
1865 base => $fai_base,
1866 scope => 'sub',
1867 attrs => ['cn','objectClass','FAIstate'],
1868 filter => $fai_filter,
1869 );
1870 daemon_log("$session_id DEBUG: Found ".$mesg->count()." FAI entries",7);
1872 if($mesg->{'resultCode'} == 0 &&
1873 $mesg->count != 0) {
1874 foreach my $entry (@{$mesg->{entries}}) {
1875 if($entry->exists('cn')) {
1876 my $tmp_dn= $entry->dn();
1878 # Skip classname and ou dn parts for class
1879 my $tmp_release = ($1) if $tmp_dn =~ /^[^,]+,[^,]+,(.*?),$fai_base$/;
1881 # Skip classes without releases
1882 if((!defined($tmp_release)) || length($tmp_release)==0) {
1883 next;
1884 }
1886 my $tmp_cn= $entry->get_value('cn');
1887 my $tmp_state= $entry->get_value('FAIstate');
1889 my $tmp_type;
1890 # Get FAI type
1891 for my $oclass(@{$entry->get_value('objectClass', asref => 1)}) {
1892 if(grep $_ eq $oclass, @possible_fai_classes) {
1893 $tmp_type= $oclass;
1894 last;
1895 }
1896 }
1898 if($tmp_release =~ /^.*?,.*?$/ && (!($tmp_release =~ /^.*?\\,.*?$/))) {
1899 # A Subrelease
1900 my @sub_releases = split(/,/, $tmp_release);
1902 # Walk through subreleases and build hash tree
1903 my $hash;
1904 while(my $tmp_sub_release = pop @sub_releases) {
1905 $hash .= "\{'$tmp_sub_release'\}->";
1906 }
1907 eval('push @{$fai_classes->'.$hash.'{$tmp_cn}->{$tmp_type}}, (defined($tmp_state) && length($tmp_state)>0)?$tmp_state:"";');
1908 } else {
1909 # A branch, no subrelease
1910 push @{$fai_classes->{$tmp_release}->{$tmp_cn}->{$tmp_type}}, (defined($tmp_state) && length($tmp_state)>0)?$tmp_state:"";
1911 }
1912 } elsif (!$entry->exists('cn')) {
1913 my $tmp_dn= $entry->dn();
1914 my $tmp_release = ($1) if $tmp_dn =~ /^(.*?),$fai_base$/;
1916 # Skip classes without releases
1917 if((!defined($tmp_release)) || length($tmp_release)==0) {
1918 next;
1919 }
1921 if($tmp_release =~ /^.*?,.*?$/ && (!($tmp_release =~ /^.*?\\,.*?$/))) {
1922 # A Subrelease
1923 my @sub_releases= split(/,/, $tmp_release);
1925 # Walk through subreleases and build hash tree
1926 my $hash;
1927 while(my $tmp_sub_release = pop @sub_releases) {
1928 $hash .= "\{'$tmp_sub_release'\}->";
1929 }
1930 # Remove the last two characters
1931 chop($hash);
1932 chop($hash);
1934 eval('$fai_classes->'.$hash.'= {}');
1935 } else {
1936 # A branch, no subrelease
1937 if(!exists($fai_classes->{$tmp_release})) {
1938 $fai_classes->{$tmp_release} = {};
1939 }
1940 }
1941 }
1942 }
1944 # The hash is complete, now we can honor the copy-on-write based missing entries
1945 foreach my $release (keys %$fai_classes) {
1946 $result->{$release}= deep_copy(apply_fai_inheritance($fai_classes->{$release}));
1947 }
1948 }
1949 return $result;
1950 }
1952 sub apply_fai_inheritance {
1953 my $fai_classes = shift || return {};
1954 my $tmp_classes;
1956 # Get the classes from the branch
1957 foreach my $class (keys %{$fai_classes}) {
1958 # Skip subreleases
1959 if($class =~ /^ou=.*$/) {
1960 next;
1961 } else {
1962 $tmp_classes->{$class}= deep_copy($fai_classes->{$class});
1963 }
1964 }
1966 # Apply to each subrelease
1967 foreach my $subrelease (keys %{$fai_classes}) {
1968 if($subrelease =~ /ou=/) {
1969 foreach my $tmp_class (keys %{$tmp_classes}) {
1970 if(!exists($fai_classes->{$subrelease}->{$tmp_class})) {
1971 $fai_classes->{$subrelease}->{$tmp_class} =
1972 deep_copy($tmp_classes->{$tmp_class});
1973 } else {
1974 foreach my $type (keys %{$tmp_classes->{$tmp_class}}) {
1975 if(!exists($fai_classes->{$subrelease}->{$tmp_class}->{$type})) {
1976 $fai_classes->{$subrelease}->{$tmp_class}->{$type}=
1977 deep_copy($tmp_classes->{$tmp_class}->{$type});
1978 }
1979 }
1980 }
1981 }
1982 }
1983 }
1985 # Find subreleases in deeper levels
1986 foreach my $subrelease (keys %{$fai_classes}) {
1987 if($subrelease =~ /ou=/) {
1988 foreach my $subsubrelease (keys %{$fai_classes->{$subrelease}}) {
1989 if($subsubrelease =~ /ou=/) {
1990 apply_fai_inheritance($fai_classes->{$subrelease});
1991 }
1992 }
1993 }
1994 }
1996 return $fai_classes;
1997 }
1999 sub get_fai_release_entries {
2000 my $tmp_classes = shift || return;
2001 my $parent = shift || "";
2002 my @result = shift || ();
2004 foreach my $entry (keys %{$tmp_classes}) {
2005 if(defined($entry)) {
2006 if($entry =~ /^ou=.*$/) {
2007 my $release_name = $entry;
2008 $release_name =~ s/ou=//g;
2009 if(length($parent)>0) {
2010 $release_name = $parent."/".$release_name;
2011 }
2012 my @bufentries = get_fai_release_entries($tmp_classes->{$entry}, $release_name, @result);
2013 foreach my $bufentry(@bufentries) {
2014 push @result, $bufentry;
2015 }
2016 } else {
2017 my @types = get_fai_types($tmp_classes->{$entry});
2018 foreach my $type (@types) {
2019 push @result,
2020 {
2021 'class' => $entry,
2022 'type' => $type->{'type'},
2023 'release' => $parent,
2024 'state' => $type->{'state'},
2025 };
2026 }
2027 }
2028 }
2029 }
2031 return @result;
2032 }
2034 sub deep_copy {
2035 my $this = shift;
2036 if (not ref $this) {
2037 $this;
2038 } elsif (ref $this eq "ARRAY") {
2039 [map deep_copy($_), @$this];
2040 } elsif (ref $this eq "HASH") {
2041 +{map { $_ => deep_copy($this->{$_}) } keys %$this};
2042 } else { die "what type is $_?" }
2043 }
2046 sub session_run_result {
2047 my ($kernel, $heap, $client_answer) = @_[KERNEL, HEAP, ARG0];
2048 $kernel->sig(CHLD => "child_reap");
2049 }
2051 sub session_run_debug {
2052 my $result = $_[ARG0];
2053 print STDERR "$result\n";
2054 }
2056 sub session_run_done {
2057 my ( $kernel, $heap, $task_id ) = @_[ KERNEL, HEAP, ARG0 ];
2058 delete $heap->{task}->{$task_id};
2059 }
2062 sub create_sources_list {
2063 my $session_id = shift;
2064 my $ldap_handle = &main::get_ldap_handle;
2065 my $result="/tmp/gosa_si_tmp_sources_list";
2067 # Remove old file
2068 if(stat($result)) {
2069 unlink($result);
2070 &main::daemon_log("$session_id DEBUG: remove an old version of '$result'", 7);
2071 }
2073 my $fh;
2074 open($fh, ">$result");
2075 if (not defined $fh) {
2076 &main::daemon_log("$session_id DEBUG: cannot open '$result' for writing", 7);
2077 return undef;
2078 }
2079 if(defined($main::ldap_server_dn) and length($main::ldap_server_dn) > 0) {
2080 my $mesg=$ldap_handle->search(
2081 base => $main::ldap_server_dn,
2082 scope => 'base',
2083 attrs => 'FAIrepository',
2084 filter => 'objectClass=FAIrepositoryServer'
2085 );
2086 if($mesg->count) {
2087 foreach my $entry(@{$mesg->{'entries'}}) {
2088 foreach my $value(@{$entry->get_value('FAIrepository', asref => 1)}) {
2089 my ($server, $tag, $release, $sections)= split /\|/, $value;
2090 my $line = "deb $server $release";
2091 $sections =~ s/,/ /g;
2092 $line.= " $sections";
2093 print $fh $line."\n";
2094 }
2095 }
2096 }
2097 } else {
2098 if (defined $main::ldap_server_dn){
2099 &main::daemon_log("$session_id ERROR: something wrong with ldap_server_dn '$main::ldap_server_dn', abort create_sources_list", 1);
2100 } else {
2101 &main::daemon_log("$session_id ERROR: no ldap_server_dn found, abort create_sources_list", 1);
2102 }
2103 }
2104 close($fh);
2106 return $result;
2107 }
2110 sub run_create_packages_list_db {
2111 my ($kernel, $session, $heap) = @_[KERNEL, SESSION, HEAP];
2112 my $session_id = $session->ID;
2114 my $task = POE::Wheel::Run->new(
2115 Priority => +20,
2116 Program => sub {&create_packages_list_db(undef, undef, $session_id)},
2117 StdoutEvent => "session_run_result",
2118 StderrEvent => "session_run_debug",
2119 CloseEvent => "session_run_done",
2120 );
2121 $heap->{task}->{ $task->ID } = $task;
2122 }
2125 sub create_packages_list_db {
2126 my ($ldap_handle, $sources_file, $session_id) = @_;
2128 # it should not be possible to trigger a recreation of packages_list_db
2129 # while packages_list_db is under construction, so set flag packages_list_under_construction
2130 # which is tested befor recreation can be started
2131 if (-r $packages_list_under_construction) {
2132 daemon_log("$session_id WARNING: packages_list_db is right now under construction, please wait until this process is finished", 3);
2133 return;
2134 } else {
2135 daemon_log("$session_id INFO: create_packages_list_db: start", 5);
2136 # set packages_list_under_construction to true
2137 system("touch $packages_list_under_construction");
2138 @packages_list_statements=();
2139 }
2141 if (not defined $session_id) { $session_id = 0; }
2142 if (not defined $ldap_handle) {
2143 $ldap_handle= &get_ldap_handle();
2145 if (not defined $ldap_handle) {
2146 daemon_log("$session_id ERROR: no ldap_handle available to create_packages_list_db", 1);
2147 unlink($packages_list_under_construction);
2148 return;
2149 }
2150 }
2151 if (not defined $sources_file) {
2152 &main::daemon_log("$session_id INFO: no sources_file given for creating packages list so trigger creation of it", 5);
2153 $sources_file = &create_sources_list($session_id);
2154 }
2156 if (not defined $sources_file) {
2157 &main::daemon_log("$session_id ERROR: no sources_file given under '$sources_file', skip create_packages_list_db", 1);
2158 unlink($packages_list_under_construction);
2159 return;
2160 }
2162 my $line;
2164 open(CONFIG, "<$sources_file") or do {
2165 daemon_log( "$session_id ERROR: create_packages_list_db: Failed to open '$sources_file'", 1);
2166 unlink($packages_list_under_construction);
2167 return;
2168 };
2170 # Read lines
2171 while ($line = <CONFIG>){
2172 # Unify
2173 chop($line);
2174 $line =~ s/^\s+//;
2175 $line =~ s/^\s+/ /;
2177 # Strip comments
2178 $line =~ s/#.*$//g;
2180 # Skip empty lines
2181 if ($line =~ /^\s*$/){
2182 next;
2183 }
2185 # Interpret deb line
2186 if ($line =~ /^deb [^\s]+\s[^\s]+\s[^\s]+/){
2187 my( $baseurl, $dist, $sections ) = ($line =~ /^deb\s([^\s]+)\s+([^\s]+)\s+(.*)$/);
2188 my $section;
2189 foreach $section (split(' ', $sections)){
2190 &parse_package_info( $baseurl, $dist, $section, $session_id );
2191 }
2192 }
2193 }
2195 close (CONFIG);
2197 find(\&cleanup_and_extract, keys( %repo_dirs ));
2198 &main::strip_packages_list_statements();
2199 unshift @packages_list_statements, "VACUUM";
2200 $packages_list_db->exec_statementlist(\@packages_list_statements);
2201 unlink($packages_list_under_construction);
2202 daemon_log("$session_id INFO: create_packages_list_db: finished", 5);
2203 return;
2204 }
2206 # This function should do some intensive task to minimize the db-traffic
2207 sub strip_packages_list_statements {
2208 my @existing_entries= @{$packages_list_db->exec_statement("SELECT * FROM $main::packages_list_tn")};
2209 my @new_statement_list=();
2210 my $hash;
2211 my $insert_hash;
2212 my $update_hash;
2213 my $delete_hash;
2214 my $local_timestamp=get_time();
2216 foreach my $existing_entry (@existing_entries) {
2217 $hash->{@{$existing_entry}[0]}->{@{$existing_entry}[1]}->{@{$existing_entry}[2]}= $existing_entry;
2218 }
2220 foreach my $statement (@packages_list_statements) {
2221 if($statement =~ /^INSERT/i) {
2222 # Assign the values from the insert statement
2223 my ($distribution,$package,$version,$section,$description,$template,$timestamp) = ($1,$2,$3,$4,$5,$6,$7) if $statement =~
2224 /^INSERT\s+?INTO\s+?$main::packages_list_tn\s+?VALUES\s*?\('(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)',\s*?'(.*?)'\s*?\)$/si;
2225 if(exists($hash->{$distribution}->{$package}->{$version})) {
2226 # If section or description has changed, update the DB
2227 if(
2228 (! (@{$hash->{$distribution}->{$package}->{$version}}[3] eq $section)) or
2229 (! (@{$hash->{$distribution}->{$package}->{$version}}[4] eq $description))
2230 ) {
2231 @{$update_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,undef);
2232 }
2233 } else {
2234 # Insert a non-existing entry to db
2235 @{$insert_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,$template);
2236 }
2237 } elsif ($statement =~ /^UPDATE/i) {
2238 my ($template,$package,$version) = ($1,$2,$3) if $statement =~
2239 /^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;
2240 foreach my $distribution (keys %{$hash}) {
2241 if(exists($insert_hash->{$distribution}->{$package}->{$version})) {
2242 # update the insertion hash to execute only one query per package (insert instead insert+update)
2243 @{$insert_hash->{$distribution}->{$package}->{$version}}[5]= $template;
2244 } elsif(exists($hash->{$distribution}->{$package}->{$version})) {
2245 if( ! (@{$hash->{$distribution}->{$package}->{$version}}[5] eq $template)) {
2246 my $section;
2247 my $description;
2248 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[3]) and
2249 length(@{$update_hash->{$distribution}->{$package}->{$version}}[3]) > 0 ) {
2250 $section= @{$update_hash->{$distribution}->{$package}->{$version}}[3];
2251 }
2252 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[4])) {
2253 $description= @{$update_hash->{$distribution}->{$package}->{$version}}[4];
2254 }
2255 @{$update_hash->{$distribution}->{$package}->{$version}} = ($distribution,$package,$version,$section,$description,$template);
2256 }
2257 }
2258 }
2259 }
2260 }
2262 # TODO: Check for orphaned entries
2264 # unroll the insert_hash
2265 foreach my $distribution (keys %{$insert_hash}) {
2266 foreach my $package (keys %{$insert_hash->{$distribution}}) {
2267 foreach my $version (keys %{$insert_hash->{$distribution}->{$package}}) {
2268 push @new_statement_list, "INSERT INTO $main::packages_list_tn VALUES ('$distribution','$package','$version',"
2269 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[3]',"
2270 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[4]',"
2271 ."'@{$insert_hash->{$distribution}->{$package}->{$version}}[5]',"
2272 ."'$local_timestamp')";
2273 }
2274 }
2275 }
2277 # unroll the update hash
2278 foreach my $distribution (keys %{$update_hash}) {
2279 foreach my $package (keys %{$update_hash->{$distribution}}) {
2280 foreach my $version (keys %{$update_hash->{$distribution}->{$package}}) {
2281 my $set = "";
2282 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[3])) {
2283 $set .= "section = '@{$update_hash->{$distribution}->{$package}->{$version}}[3]', ";
2284 }
2285 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[4])) {
2286 $set .= "description = '@{$update_hash->{$distribution}->{$package}->{$version}}[4]', ";
2287 }
2288 if(defined(@{$update_hash->{$distribution}->{$package}->{$version}}[5])) {
2289 $set .= "template = '@{$update_hash->{$distribution}->{$package}->{$version}}[5]', ";
2290 }
2291 if(defined($set) and length($set) > 0) {
2292 $set .= "timestamp = '$local_timestamp'";
2293 } else {
2294 next;
2295 }
2296 push @new_statement_list,
2297 "UPDATE $main::packages_list_tn SET $set WHERE"
2298 ." distribution = '$distribution'"
2299 ." AND package = '$package'"
2300 ." AND version = '$version'";
2301 }
2302 }
2303 }
2305 @packages_list_statements = @new_statement_list;
2306 }
2309 sub parse_package_info {
2310 my ($baseurl, $dist, $section, $session_id)= @_;
2311 my ($package);
2312 if (not defined $session_id) { $session_id = 0; }
2313 my ($path) = ($baseurl =~ m%://[^/]*(.*)$%);
2314 $repo_dirs{ "${repo_path}/pool" } = 1;
2316 foreach $package ("Packages.gz"){
2317 daemon_log("$session_id DEBUG: create_packages_list: fetch $baseurl, $dist, $section", 7);
2318 get_package( "$baseurl/dists/$dist/$section/binary-$arch/$package", "$outdir/$dist/$section", $session_id );
2319 parse_package( "$outdir/$dist/$section", $dist, $path, $session_id );
2320 }
2322 }
2325 sub get_package {
2326 my ($url, $dest, $session_id)= @_;
2327 if (not defined $session_id) { $session_id = 0; }
2329 my $tpath = dirname($dest);
2330 -d "$tpath" || mkpath "$tpath";
2332 # This is ugly, but I've no time to take a look at "how it works in perl"
2333 if(0 == system("wget '$url' -O '$dest' 2>/dev/null") ) {
2334 system("gunzip -cd '$dest' > '$dest.in'");
2335 daemon_log("$session_id DEBUG: run command: gunzip -cd '$dest' > '$dest.in'", 5);
2336 unlink($dest);
2337 daemon_log("$session_id DEBUG: delete file '$dest'", 5);
2338 } else {
2339 daemon_log("$session_id ERROR: create_packages_list_db: get_packages: fetching '$url' failed!", 1);
2340 }
2341 return 0;
2342 }
2345 sub parse_package {
2346 my ($path, $dist, $srv_path, $session_id)= @_;
2347 if (not defined $session_id) { $session_id = 0;}
2348 my ($package, $version, $section, $description);
2349 my $PACKAGES;
2350 my $timestamp = &get_time();
2352 if(not stat("$path.in")) {
2353 daemon_log("$session_id ERROR: create_packages_list: parse_package: file '$path.in' is not readable",1);
2354 return;
2355 }
2357 open($PACKAGES, "<$path.in");
2358 if(not defined($PACKAGES)) {
2359 daemon_log("$session_id ERROR: create_packages_list_db: parse_package: cannot open '$path.in'",1);
2360 return;
2361 }
2363 # Read lines
2364 while (<$PACKAGES>){
2365 my $line = $_;
2366 # Unify
2367 chop($line);
2369 # Use empty lines as a trigger
2370 if ($line =~ /^\s*$/){
2371 my $sql = "INSERT INTO packages_list VALUES ('$dist', '$package', '$version', '$section', '$description', '', '$timestamp')";
2372 push(@packages_list_statements, $sql);
2373 $package = "none";
2374 $version = "none";
2375 $section = "none";
2376 $description = "none";
2377 next;
2378 }
2380 # Trigger for package name
2381 if ($line =~ /^Package:\s/){
2382 ($package)= ($line =~ /^Package: (.*)$/);
2383 next;
2384 }
2386 # Trigger for version
2387 if ($line =~ /^Version:\s/){
2388 ($version)= ($line =~ /^Version: (.*)$/);
2389 next;
2390 }
2392 # Trigger for description
2393 if ($line =~ /^Description:\s/){
2394 ($description)= &encode_base64(($line =~ /^Description: (.*)$/));
2395 next;
2396 }
2398 # Trigger for section
2399 if ($line =~ /^Section:\s/){
2400 ($section)= ($line =~ /^Section: (.*)$/);
2401 next;
2402 }
2404 # Trigger for filename
2405 if ($line =~ /^Filename:\s/){
2406 my ($filename) = ($line =~ /^Filename: (.*)$/);
2407 store_fileinfo( $package, $filename, $dist, $srv_path, $version, $repo_path );
2408 next;
2409 }
2410 }
2412 close( $PACKAGES );
2413 unlink( "$path.in" );
2414 &main::daemon_log("$session_id DEBUG: unlink '$path.in'", 1);
2415 }
2418 sub store_fileinfo {
2419 my( $package, $file, $dist, $path, $vers, $srvdir) = @_;
2421 my %fileinfo = (
2422 'package' => $package,
2423 'dist' => $dist,
2424 'version' => $vers,
2425 );
2427 $repo_files{ "${srvdir}/$file" } = \%fileinfo;
2428 }
2431 sub cleanup_and_extract {
2432 my $fileinfo = $repo_files{ $File::Find::name };
2434 if( defined $fileinfo ) {
2436 my $dir = "$outdir/$fileinfo->{ 'dist' }/debconf.d";
2437 my $sql;
2438 my $package = $fileinfo->{ 'package' };
2439 my $newver = $fileinfo->{ 'version' };
2441 mkpath($dir);
2442 system( "dpkg -e '$File::Find::name' '$dir/DEBIAN'" );
2444 if( -f "$dir/DEBIAN/templates" ) {
2446 daemon_log("DEBUG: Found debconf templates in '$package' - $newver", 5);
2448 my $tmpl= "";
2449 {
2450 local $/=undef;
2451 open FILE, "$dir/DEBIAN/templates";
2452 $tmpl = &encode_base64(<FILE>);
2453 close FILE;
2454 }
2455 rmtree("$dir/DEBIAN/templates");
2457 $sql= "update $main::packages_list_tn set template = '$tmpl' where package = '$package' and version = '$newver';";
2458 push @packages_list_statements, $sql;
2459 }
2460 }
2462 return;
2463 }
2466 #==== MAIN = main ==============================================================
2467 # parse commandline options
2468 Getopt::Long::Configure( "bundling" );
2469 GetOptions("h|help" => \&usage,
2470 "c|config=s" => \$cfg_file,
2471 "f|foreground" => \$foreground,
2472 "v|verbose+" => \$verbose,
2473 "no-bus+" => \$no_bus,
2474 "no-arp+" => \$no_arp,
2475 );
2477 # read and set config parameters
2478 &check_cmdline_param ;
2479 &read_configfile;
2480 &check_pid;
2482 $SIG{CHLD} = 'IGNORE';
2484 # forward error messages to logfile
2485 if( ! $foreground ) {
2486 open( STDIN, '+>/dev/null' );
2487 open( STDOUT, '+>&STDIN' );
2488 open( STDERR, '+>&STDIN' );
2489 }
2491 # Just fork, if we are not in foreground mode
2492 if( ! $foreground ) {
2493 chdir '/' or die "Can't chdir to /: $!";
2494 $pid = fork;
2495 setsid or die "Can't start a new session: $!";
2496 umask 0;
2497 } else {
2498 $pid = $$;
2499 }
2501 # Do something useful - put our PID into the pid_file
2502 if( 0 != $pid ) {
2503 open( LOCK_FILE, ">$pid_file" );
2504 print LOCK_FILE "$pid\n";
2505 close( LOCK_FILE );
2506 if( !$foreground ) {
2507 exit( 0 )
2508 };
2509 }
2511 daemon_log(" ", 1);
2512 daemon_log("$0 started!", 1);
2514 if ($no_bus > 0) {
2515 $bus_activ = "false"
2516 }
2518 # connect to gosa-si job queue
2519 $job_db = GOSA::DBsqlite->new($job_queue_file_name);
2520 $job_db->create_table($job_queue_tn, \@job_queue_col_names);
2522 # connect to known_clients_db
2523 $known_clients_db = GOSA::DBsqlite->new($known_clients_file_name);
2524 $known_clients_db->create_table($known_clients_tn, \@known_clients_col_names);
2526 # connect to known_server_db
2527 $known_server_db = GOSA::DBsqlite->new($known_server_file_name);
2528 $known_server_db->create_table($known_server_tn, \@known_server_col_names);
2530 # connect to login_usr_db
2531 $login_users_db = GOSA::DBsqlite->new($login_users_file_name);
2532 $login_users_db->create_table($login_users_tn, \@login_users_col_names);
2534 # connect to fai_server_db and fai_release_db
2535 unlink($fai_server_file_name);
2536 $fai_server_db = GOSA::DBsqlite->new($fai_server_file_name);
2537 $fai_server_db->create_table($fai_server_tn, \@fai_server_col_names);
2539 unlink($fai_release_file_name);
2540 $fai_release_db = GOSA::DBsqlite->new($fai_release_file_name);
2541 $fai_release_db->create_table($fai_release_tn, \@fai_release_col_names);
2543 # connect to packages_list_db
2544 #unlink($packages_list_file_name);
2545 unlink($packages_list_under_construction);
2546 $packages_list_db = GOSA::DBsqlite->new($packages_list_file_name);
2547 $packages_list_db->create_table($packages_list_tn, \@packages_list_col_names);
2549 # connect to messaging_db
2550 $messaging_db = GOSA::DBsqlite->new($messaging_file_name);
2551 $messaging_db->create_table($messaging_tn, \@messaging_col_names);
2554 # create xml object used for en/decrypting
2555 $xml = new XML::Simple();
2557 # create socket for incoming xml messages
2559 POE::Component::Server::TCP->new(
2560 Port => $server_port,
2561 ClientInput => sub {
2562 my ($kernel, $input) = @_[KERNEL, ARG0];
2563 push(@tasks, $input);
2564 $kernel->yield("next_task");
2565 },
2566 InlineStates => {
2567 next_task => \&next_task,
2568 task_result => \&handle_task_result,
2569 task_done => \&handle_task_done,
2570 task_debug => \&handle_task_debug,
2571 child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!" },
2572 }
2573 );
2575 daemon_log("start socket for incoming xml messages at port '$server_port' ", 1);
2577 # create session for repeatedly checking the job queue for jobs
2578 POE::Session->create(
2579 inline_states => {
2580 _start => \&_start,
2581 sig_handler => \&sig_handler,
2582 watch_for_new_messages => \&watch_for_new_messages,
2583 watch_for_delivery_messages => \&watch_for_delivery_messages,
2584 watch_for_done_messages => \&watch_for_done_messages,
2585 watch_for_new_jobs => \&watch_for_new_jobs,
2586 watch_for_done_jobs => \&watch_for_done_jobs,
2587 create_packages_list_db => \&run_create_packages_list_db,
2588 create_fai_server_db => \&run_create_fai_server_db,
2589 create_fai_release_db => \&run_create_fai_release_db,
2590 session_run_result => \&session_run_result,
2591 session_run_debug => \&session_run_debug,
2592 session_run_done => \&session_run_done,
2593 child_reap => sub { "Do nothing special. I'm just a comment, but i'm necessary!" },
2594 }
2595 );
2598 # import all modules
2599 &import_modules;
2601 # check wether all modules are gosa-si valid passwd check
2603 POE::Kernel->run();
2604 exit;