Code

71500ad2ce7a3cd1493af149e0fdc14406fc9f03
[gosa.git] / gosa-si / gosa-si-server
1 #!/usr/bin/perl
2 #===============================================================================
3 #
4 #         FILE:  gosa-sd
5 #
6 #        USAGE:  ./gosa-sd
7 #
8 #  DESCRIPTION:
9 #
10 #      OPTIONS:  ---
11 # REQUIREMENTS:  libconfig-inifiles-perl libcrypt-rijndael-perl libxml-simple-perl 
12 #                libdata-dumper-simple-perl libdbd-sqlite3-perl libnet-ldap-perl
13 #                libpoe-perl
14 #         BUGS:  ---
15 #        NOTES:
16 #       AUTHOR:   (Andreas Rettenberger), <rettenberger@gonicus.de>
17 #      COMPANY:
18 #      VERSION:  1.0
19 #      CREATED:  12.09.2007 08:54:41 CEST
20 #     REVISION:  ---
21 #===============================================================================
23 use strict;
24 use warnings;
25 use Getopt::Long;
26 use Config::IniFiles;
27 use POSIX;
29 use Fcntl;
30 use IO::Socket::INET;
31 use IO::Handle;
32 use IO::Select;
33 use Symbol qw(qualify_to_ref);
34 use Crypt::Rijndael;
35 use MIME::Base64;
36 use Digest::MD5  qw(md5 md5_hex md5_base64);
37 use XML::Simple;
38 use Data::Dumper;
39 use Sys::Syslog qw( :DEFAULT setlogsock);
40 use Cwd;
41 use File::Spec;
42 use GOSA::DBsqlite;
43 use POE qw(Component::Server::TCP);
45 my $modules_path = "/usr/lib/gosa-si/modules";
46 use lib "/usr/lib/gosa-si/modules";
48 my (%cfg_defaults, $foreground, $verbose, $ping_timeout);
49 my ($bus, $msg_to_bus, $bus_cipher);
50 my ($server, $server_mac_address, $server_events);
51 my ($gosa_server, $job_queue_timeout, $job_queue_table_name, $job_queue_file_name,$job_queue_loop_delay);
52 my ($known_modules, $known_clients_file_name, $known_server_file_name);
53 my ($max_clients);
54 my ($pid_file, $procid, $pid, $log_file);
55 my (%free_child, %busy_child, $child_max, $child_min, %child_alive_time, $child_timeout);
56 my ($arp_activ, $arp_fifo, $arp_fifo_path);
57 my ($xml);
59 # variables declared in config file are always set to 'our'
60 our (%cfg_defaults, $log_file, $pid_file, 
61     $bus_activ, $bus_key, $bus_ip, $bus_port,
62     $server_activ, $server_ip, $server_port, $SIPackages_key, $max_clients,
63     $arp_activ, $arp_fifo_path,
64     $gosa_activ, $GosaPackages_key, $gosa_ip, $gosa_port, $gosa_timeout,
65 );
67 # additional variable which should be globaly accessable
68 our $server_address;
69 our $bus_address;
70 our $gosa_address;
71 our $no_bus;
72 our $no_arp;
73 our $verbose;
74 our $forground;
75 our $cfg_file;
77 # specifies the verbosity of the daemon_log
78 $verbose = 0 ;
80 # if foreground is not null, script will be not forked to background
81 $foreground = 0 ;
83 # specifies the timeout seconds while checking the online status of a registrating client
84 $ping_timeout = 5;
86 $no_bus = 0;
88 $no_arp = 0;
90 # name of table for storing gosa jobs
91 our $job_queue_table_name = 'jobs';
92 our $job_db;
94 # holds all other gosa-sd as well as the gosa-sd-bus
95 our $known_server_db;
97 # holds all registrated clients
98 our $known_clients_db;
100 %cfg_defaults =
101 ("general" =>
102     {"log_file" => [\$log_file, "/var/run/".$0.".log"],
103     "pid_file" => [\$pid_file, "/var/run/".$0.".pid"],
104     "child_max" => [\$child_max, 10],
105     "child_min" => [\$child_min, 3],
106     "child_timeout" => [\$child_timeout, 180],
107     "job_queue_timeout" => [\$job_queue_timeout, undef],
108     "job_queue_file_name" => [\$job_queue_file_name, '/var/lib/gosa-si/gosa-si-server_jobs.db'],
109     "job_queue_loop_delay" => [\$job_queue_loop_delay, 3],
110     "known_clients_file_name" => [\$known_clients_file_name, '/var/lib/gosa-si/gosa-si-server_known_clients.db' ],
111     "known_server_file_name" => [\$known_server_file_name, '/var/lib/gosa-si/gosa-si-server_known_server.db'],
112    },
113 "bus" =>
114     {"bus_activ" => [\$bus_activ, "on"],
115     "bus_passwd" => [\$bus_key, ""],
116     "bus_ip" => [\$bus_ip, "0.0.0.0"],
117     "bus_port" => [\$bus_port, "20080"],
118     },
119 "server" =>
120     {"server_activ" => [\$server_activ, "on"],
121     "server_ip" => [\$server_ip, "0.0.0.0"],
122     "server_port" => [\$server_port, "20081"],
123     "SIPackages_key" => [\$SIPackages_key, "none"],
124     "max_clients" => [\$max_clients, 100],
125     },
126 "arp" =>
127     {"arp_activ" => [\$arp_activ, "on"],
128     "arp_fifo_path" => [\$arp_fifo_path, "/var/run/gosa-si/arp-notify"],
129     },
130 "gosa" =>
131     {"gosa_activ" => [\$gosa_activ, "on"],
132     "gosa_ip" => [\$gosa_ip, "0.0.0.0"],
133     "gosa_port" => [\$gosa_port, "20082"],
134     "GosaPackages_key" => [\$GosaPackages_key, "none"],
135     },
136     );
139 #===  FUNCTION  ================================================================
140 #         NAME:  usage
141 #   PARAMETERS:  nothing
142 #      RETURNS:  nothing
143 #  DESCRIPTION:  print out usage text to STDERR
144 #===============================================================================
145 sub usage {
146     print STDERR << "EOF" ;
147 usage: $0 [-hvf] [-c config]
149            -h        : this (help) message
150            -c <file> : config file
151            -f        : foreground, process will not be forked to background
152            -v        : be verbose (multiple to increase verbosity)
153            -no-bus   : starts $0 without connection to bus
154            -no-arp   : starts $0 without connection to arp module
155  
156 EOF
157     print "\n" ;
161 #===  FUNCTION  ================================================================
162 #         NAME:  read_configfile
163 #   PARAMETERS:  cfg_file - string -
164 #      RETURNS:  nothing
165 #  DESCRIPTION:  read cfg_file and set variables
166 #===============================================================================
167 sub read_configfile {
168     my $cfg;
169     if( defined( $cfg_file) && ( length($cfg_file) > 0 )) {
170         if( -r $cfg_file ) {
171             $cfg = Config::IniFiles->new( -file => $cfg_file );
172         } else {
173             print STDERR "Couldn't read config file!\n";
174         }
175     } else {
176         $cfg = Config::IniFiles->new() ;
177     }
178     foreach my $section (keys %cfg_defaults) {
179         foreach my $param (keys %{$cfg_defaults{ $section }}) {
180             my $pinfo = $cfg_defaults{ $section }{ $param };
181             ${@$pinfo[ 0 ]} = $cfg->val( $section, $param, @$pinfo[ 1 ] );
182         }
183     }
187 #===  FUNCTION  ================================================================
188 #         NAME:  logging
189 #   PARAMETERS:  level - string - default 'info'
190 #                msg - string -
191 #                facility - string - default 'LOG_DAEMON'
192 #      RETURNS:  nothing
193 #  DESCRIPTION:  function for logging
194 #===============================================================================
195 sub daemon_log {
196     # log into log_file
197     my( $msg, $level ) = @_;
198     if(not defined $msg) { return }
199     if(not defined $level) { $level = 1 }
200     if(defined $log_file){
201         open(LOG_HANDLE, ">>$log_file");
202         if(not defined open( LOG_HANDLE, ">>$log_file" )) {
203             print STDERR "cannot open $log_file: $!";
204             return }
205             chomp($msg);
206             if($level <= $verbose){
207                 my ($seconds, $minutes, $hours, $monthday, $month,
208                         $year, $weekday, $yearday, $sommertime) = localtime(time);
209                 $hours = $hours < 10 ? $hours = "0".$hours : $hours;
210                 $minutes = $minutes < 10 ? $minutes = "0".$minutes : $minutes;
211                 $seconds = $seconds < 10 ? $seconds = "0".$seconds : $seconds;
212                 my @monthnames = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
213                 $month = $monthnames[$month];
214                 $monthday = $monthday < 10 ? $monthday = "0".$monthday : $monthday;
215                 $year+=1900;
216                 my $name = $0;
217                 $name =~ s/\.\///;
219                 my $log_msg = "$month $monthday $hours:$minutes:$seconds $name $msg\n";
220                 print LOG_HANDLE $log_msg;
221                 if( $foreground ) { 
222                     print STDERR $log_msg;
223                 }
224             }
225         close( LOG_HANDLE );
226     }
227 #log into syslog
228 #    my ($msg, $level, $facility) = @_;
229 #    if(not defined $msg) {return}
230 #    if(not defined $level) {$level = "info"}
231 #    if(not defined $facility) {$facility = "LOG_DAEMON"}
232 #    openlog($0, "pid,cons,", $facility);
233 #    syslog($level, $msg);
234 #    closelog;
235 #    return;
239 sub get_time {
240     my ($seconds, $minutes, $hours, $monthday, $month,
241             $year, $weekday, $yearday, $sommertime) = localtime(time);
242     $hours = $hours < 10 ? $hours = "0".$hours : $hours;
243     $minutes = $minutes < 10 ? $minutes = "0".$minutes : $minutes;
244     $seconds = $seconds < 10 ? $seconds = "0".$seconds : $seconds;
245     $month+=1;
246     $month = $month < 10 ? $month = "0".$month : $month;
247     $monthday = $monthday < 10 ? $monthday = "0".$monthday : $monthday;
248     $year+=1900;
249     return "$year$month$monthday$hours$minutes$seconds";
254 #===  FUNCTION  ================================================================
255 #         NAME:  check_cmdline_param
256 #   PARAMETERS:  nothing
257 #      RETURNS:  nothing
258 #  DESCRIPTION:  validates commandline parameter
259 #===============================================================================
260 sub check_cmdline_param () {
261     my $err_config;
262     my $err_counter = 0;
263         if(not defined($cfg_file)) {
264                 $cfg_file = "/etc/gosa-si/server.conf";
265                 if(! -r $cfg_file) {
266                         $err_config = "please specify a config file";
267                         $err_counter += 1;
268                 }
269     }
270     if( $err_counter > 0 ) {
271         &usage( "", 1 );
272         if( defined( $err_config)) { print STDERR "$err_config\n"}
273         print STDERR "\n";
274         exit( -1 );
275     }
279 #===  FUNCTION  ================================================================
280 #         NAME:  check_pid
281 #   PARAMETERS:  nothing
282 #      RETURNS:  nothing
283 #  DESCRIPTION:  handels pid processing
284 #===============================================================================
285 sub check_pid {
286     $pid = -1;
287     # Check, if we are already running
288     if( open(LOCK_FILE, "<$pid_file") ) {
289         $pid = <LOCK_FILE>;
290         if( defined $pid ) {
291             chomp( $pid );
292             if( -f "/proc/$pid/stat" ) {
293                 my($stat) = `cat /proc/$pid/stat` =~ m/$pid \((.+)\).*/;
294                 if( $0 eq $stat ) {
295                     close( LOCK_FILE );
296                     exit -1;
297                 }
298             }
299         }
300         close( LOCK_FILE );
301         unlink( $pid_file );
302     }
304     # create a syslog msg if it is not to possible to open PID file
305     if (not sysopen(LOCK_FILE, $pid_file, O_WRONLY|O_CREAT|O_EXCL, 0644)) {
306         my($msg) = "Couldn't obtain lockfile '$pid_file' ";
307         if (open(LOCK_FILE, '<', $pid_file)
308                 && ($pid = <LOCK_FILE>))
309         {
310             chomp($pid);
311             $msg .= "(PID $pid)\n";
312         } else {
313             $msg .= "(unable to read PID)\n";
314         }
315         if( ! ($foreground) ) {
316             openlog( $0, "cons,pid", "daemon" );
317             syslog( "warning", $msg );
318             closelog();
319         }
320         else {
321             print( STDERR " $msg " );
322         }
323         exit( -1 );
324     }
327 #===  FUNCTION  ================================================================
328 #         NAME:  import_modules
329 #   PARAMETERS:  module_path - string - abs. path to the directory the modules 
330 #                are stored
331 #      RETURNS:  nothing
332 #  DESCRIPTION:  each file in module_path which ends with '.pm' and activation 
333 #                state is on is imported by "require 'file';"
334 #===============================================================================
335 sub import_modules {
336     daemon_log(" ", 1);
338     if (not -e $modules_path) {
339         daemon_log("ERROR: cannot find directory or directory is not readable: $modules_path", 1);   
340     }
342     opendir (DIR, $modules_path) or die "ERROR while loading modules from directory $modules_path : $!\n";
343     while (defined (my $file = readdir (DIR))) {
344         if (not $file =~ /(\S*?).pm$/) {
345             next;
346         }
347                 my $mod_name = $1;
349         if( $file =~ /ArpHandler.pm/ ) {
350             if( $no_arp > 0 ) {
351                 next;
352             }
353         }
354         
355         eval { require $file; };
356         if ($@) {
357             daemon_log("ERROR: gosa-si-server could not load module $file", 1);
358             daemon_log("$@", 5);
359                 } else {
360                         my $info = eval($mod_name.'::get_module_info()');
361                         # Only load module if get_module_info() returns a non-null object
362                         if( $info ) {
363                                 my ($input_address, $input_key, $input, $input_active, $input_type) = @{$info};
364                                 $known_modules->{$mod_name} = $info;
365                                 daemon_log("module $mod_name loaded", 1);
366                         }
367                 }
368     }   
369     close (DIR);
373 #===  FUNCTION  ================================================================
374 #         NAME:  sig_int_handler
375 #   PARAMETERS:  signal - string - signal arose from system
376 #      RETURNS:  noting
377 #  DESCRIPTION:  handels tasks to be done befor signal becomes active
378 #===============================================================================
379 sub sig_int_handler {
380     my ($signal) = @_;
382     daemon_log("shutting down gosa-si-server", 1);
383     exit(1);
385 $SIG{INT} = \&sig_int_handler;
389 sub check_key_and_xml_validity {
390     my ($crypted_msg, $module_key) = @_;
391 #print STDERR "crypted_msg:$crypted_msg\n";
392 #print STDERR "modul_key:$module_key\n";
394     my $msg;
395     my $msg_hash;
396     eval{
397         $msg = &decrypt_msg($crypted_msg, $module_key);
398         &main::daemon_log("decrypted_msg: \n$msg", 8);
400         $msg_hash = $xml->XMLin($msg, ForceArray=>1);
402         # check header
403         my $header_l = $msg_hash->{'header'};
404         if( 1 != @{$header_l} ) {
405             die'header error';
406         }
407         my $header = @{$header_l}[0];
408         if( 0 == length $header) {
409             die 'header error';
410         }
412         # check source
413         my $source_l = $msg_hash->{'source'};
414         if( 1 != @{$source_l} ) {
415             die'source error';
416         }
417         my $source = @{$source_l}[0];
418         if( 0 == length $source) {
419             die 'source error';
420         }
422         # check target
423         my $target_l = $msg_hash->{'target'};
424         if( 1 != @{$target_l} ) {
425             die'target error';
426         }
427         my $target = @{$target_l}[0];
428         if( 0 == length $target) {
429             die 'target error';
430         }
432     };
433     if($@) {
434         &main::daemon_log("WARNING: do not understand the message", 5);
435         &main::daemon_log("$@", 8);
436     }
438     return ($msg, $msg_hash);
442 sub input_from_known_server {
443     my ($input, $remote_ip) = @_ ;  
444     my ($msg, $msg_hash, $module);
446     my $sql_statement= "SELECT * FROM known_server";
447     my $query_res = $known_server_db->select_dbentry( $sql_statement ); 
449     while( my ($hit_num, $hit) = each %{ $query_res } ) {    
450         my $host_name = $hit->{hostname};
451         if( not $host_name =~ "^$remote_ip") {
452             next;
453         }
454         my $host_key = $hit->{hostkey};
455         daemon_log("SIPackages: known_server host_name: $host_name", 7);
456         daemon_log("SIPackages: known_server host_key: $host_key", 7);
458         # check if module can open msg envelope with module key
459         my ($tmp_msg, $tmp_msg_hash) = &check_key_and_xml_validity($input, $host_key);
460         if( (!$tmp_msg) || (!$tmp_msg_hash) ) {
461             daemon_log("SIPackages: deciphering raise error", 7);
462             daemon_log("$@", 8);
463             next;
464         }
465         else {
466             $msg = $tmp_msg;
467             $msg_hash = $tmp_msg_hash;
468             $module = "SIPackages";
469             last;
470         }
471     }
473     if( (!$msg) || (!$msg_hash) || (!$module) ) {
474         daemon_log("Incoming message is not from a known server", 3);
475     }
476   
477     return ($msg, $msg_hash, $module);
481 sub input_from_known_client {
482     my ($input, $remote_ip) = @_ ;  
483     my ($msg, $msg_hash, $module);
485     my $sql_statement= "SELECT * FROM known_clients";
486     my $query_res = $known_clients_db->select_dbentry( $sql_statement ); 
487     while( my ($hit_num, $hit) = each %{ $query_res } ) {    
488         my $host_name = $hit->{hostname};
489         if( not $host_name =~ /^$remote_ip:\d*$/) {
490             next;
491                 }
492         my $host_key = $hit->{hostkey};
493         &daemon_log("SIPackages: known_client host_name: $host_name", 7);
494         &daemon_log("SIPackages: known_client host_key: $host_key", 7);
496         # check if module can open msg envelope with module key
497         ($msg, $msg_hash) = &check_key_and_xml_validity($input, $host_key);
499         if( (!$msg) || (!$msg_hash) ) {
500             &daemon_log("SIPackages: deciphering raise error", 7);
501             &daemon_log("$@", 8);
502             next;
503         }
504         else {
505             $module = "SIPackages";
506             last;
507         }
508     }
510     if( (!$msg) || (!$msg_hash) || (!$module) ) {
511         &daemon_log("Incoming message is not from a known client", 3);
512     }
514     return ($msg, $msg_hash, $module);
518 sub input_from_unknown_host {
519     no strict "refs";
520     my ($input) = @_ ;
521     my ($msg, $msg_hash, $module);
522     
523         my %act_modules = %$known_modules;
525         while( my ($mod, $info) = each(%act_modules)) {
526         # check a key exists for this module
527         my $module_key = ${$mod."_key"};
528         if( ! $module_key ) {
529             daemon_log("ERROR: no key specified in config file for $mod", 1);
530             next;
531         }
532         daemon_log("$mod: $module_key", 5);
534         # check if module can open msg envelope with module key
535         ($msg, $msg_hash) = &check_key_and_xml_validity($input, $module_key);
536         if( (!$msg) || (!$msg_hash) ) {
537             #daemon_log("$mod: deciphering failed", 5);
538             next;
539         }
540         else {
541             $module = $mod;
542             last;
543         }
544     }
546     if( (!$msg) || (!$msg_hash) || (!$module)) {
547         daemon_log("Incoming message is not from a unknown host", 5);
548     }
550     return ($msg, $msg_hash, $module);
553 sub create_ciphering {
554     my ($passwd) = @_;
555         if((!defined($passwd)) || length($passwd)==0) {
556                 $passwd = "";
557         }
558     $passwd = substr(md5_hex("$passwd") x 32, 0, 32);
559     my $iv = substr(md5_hex('GONICUS GmbH'),0, 16);
560     my $my_cipher = Crypt::Rijndael->new($passwd , Crypt::Rijndael::MODE_CBC());
561     $my_cipher->set_iv($iv);
562     return $my_cipher;
566 sub encrypt_msg {
567     my ($msg, $key) = @_;
568     my $my_cipher = &create_ciphering($key);
569     {
570       use bytes;
571       $msg = "\0"x(16-length($msg)%16).$msg;
572     }
573     $msg = $my_cipher->encrypt($msg);
574     chomp($msg = &encode_base64($msg));
575     # there are no newlines allowed inside msg
576     $msg=~ s/\n//g;
577     return $msg;
581 sub decrypt_msg {
582     my ($msg, $key) = @_ ;
583     $msg = &decode_base64($msg);
584     my $my_cipher = &create_ciphering($key);
585     $msg = $my_cipher->decrypt($msg); 
586     $msg =~ s/\0*//g;
587     return $msg;
591 sub get_encrypt_key {
592     my ($target) = @_ ;
593     my $encrypt_key;
594     my $error = 0;
596     # target can be in known_server
597     if( !$encrypt_key ) {
598         my $sql_statement= "SELECT * FROM known_server WHERE hostname='$target'";
599         my $query_res = $known_server_db->select_dbentry( $sql_statement ); 
600         while( my ($hit_num, $hit) = each %{ $query_res } ) {    
601             my $host_name = $hit->{hostname};
602             if( $host_name ne $target ) {
603                 next;
604             }
605             $encrypt_key = $hit->{hostkey};
606             last;
607         }
608     }
609    
611     # target can be in known_client
612     if( !$encrypt_key ) {
613         my $sql_statement= "SELECT * FROM known_clients WHERE hostname='$target'";
614         my $query_res = $known_clients_db->select_dbentry( $sql_statement ); 
615         while( my ($hit_num, $hit) = each %{ $query_res } ) {    
616             my $host_name = $hit->{hostname};
617             if( $host_name ne $target ) {
618                 next;
619             }
620             $encrypt_key = $hit->{hostkey};
621             last;
622         }
623     }
625     return $encrypt_key;
629 #===  FUNCTION  ================================================================
630 #         NAME:  open_socket
631 #   PARAMETERS:  PeerAddr string something like 192.168.1.1 or 192.168.1.1:10000
632 #                [PeerPort] string necessary if port not appended by PeerAddr
633 #      RETURNS:  socket IO::Socket::INET
634 #  DESCRIPTION:  open a socket to PeerAddr
635 #===============================================================================
636 sub open_socket {
637     my ($PeerAddr, $PeerPort) = @_ ;
638     if(defined($PeerPort)){
639         $PeerAddr = $PeerAddr.":".$PeerPort;
640     }
641     my $socket;
642     $socket = new IO::Socket::INET(PeerAddr => $PeerAddr,
643             Porto => "tcp",
644             Type => SOCK_STREAM,
645             Timeout => 5,
646             );
647     if(not defined $socket) {
648         return;
649     }
650     &daemon_log("open_socket: $PeerAddr", 7);
651     return $socket;
655 sub send_msg_to_target {
656     my ($msg, $address, $encrypt_key, $msg_header) = @_ ;
657     my $error = 0;
658     my $header;
659     my $new_status;
660     my $act_status;
661     my ($sql_statement, $res);
662   
663     if( $msg_header ) {
664         $header = "'$msg_header'-";
665     }
666     else {
667         $header = "";
668     }
670         # Patch the source ip
671         my $remote_ip = sprintf("%s", $address =~ /^([0-9\.]*?):.*$/);
672         $msg =~ s/<source>(0\.0\.0\.0):(\d*?)<\/source>/<source>$remote_ip:\2<\/source>/s;
674     # encrypt xml msg
675     my $crypted_msg = &encrypt_msg($msg, $encrypt_key);
677     # opensocket
678     my $socket = &open_socket($address);
679     if( !$socket ) {
680         daemon_log("cannot send ".$header."msg to $address , host not reachable", 1);
681         $error++;
682     }
683     
684     if( $error == 0 ) {
685         # send xml msg
686         print $socket $crypted_msg."\n";
688         daemon_log("send ".$header."msg to $address", 1);
689         daemon_log("message:\n$msg", 8);
690         
691     }
693     # close socket in any case
694     if( $socket ) {
695         close $socket;
696     }
698     if( $error > 0 ) { $new_status = "down"; }
699     else { $new_status = $msg_header; }
702     # known_clients
703     $sql_statement = "SELECT * FROM known_clients WHERE hostname='$address'";
704     $res = $known_clients_db->select_dbentry($sql_statement);
705     if( keys(%$res) > 0) {
706         $act_status = $res->{1}->{'status'};
707         if( $act_status eq "down" ) {
708             $sql_statement = "DELETE FROM known_clients WHERE hostname='$address'";
709             $res = $known_clients_db->del_dbentry($sql_statement);
710             daemon_log("WARNING: failed 2x to send msg to host '$address', delete host from known_clients", 3);
711         } 
712         else { 
713             $sql_statement = "UPDATE known_clients SET status='$new_status' WHERE hostname='$address'";
714             $res = $known_clients_db->update_dbentry($sql_statement);
715             if($new_status eq "down"){
716                 daemon_log("WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
717             }
718             else {
719                 daemon_log("INFO: set '$address' from status '$act_status' to '$new_status'", 5);
720             }
721         }
722     }
724     # known_server
725     $sql_statement = "SELECT * FROM known_server WHERE hostname='$address'";
726     $res = $known_server_db->select_dbentry($sql_statement);
727     if( keys(%$res) > 0 ) {
728         $act_status = $res->{1}->{'status'};
729         if( $act_status eq "down" ) {
730             $sql_statement = "DELETE FROM known_server WHERE hostname='$address'";
731             $res = $known_clients_db->del_dbentry($sql_statement);
732             daemon_log("WARNING: failed 2x to a send msg to host '$address', delete host from known_server", 3);
733         } 
734         else { 
735             $sql_statement = "UPDATE known_server SET status='$new_status' WHERE hostname='$address'";
736             $res = $known_server_db->update_dbentry($sql_statement);
737             if($new_status eq "down"){
738                 daemon_log("WARNING: set '$address' from status '$act_status' to '$new_status'", 3);
739             }
740             else {
741                 daemon_log("INFO: set '$address' from status '$act_status' to '$new_status'", 5);
742             }
743         }
744     }
746     return; 
750 sub _start {
751     my ($kernel) = $_[KERNEL];
752     &trigger_db_loop($kernel);
756 sub client_input {
757     no strict "refs";
758     my ($heap,$input,$wheel) = @_[HEAP, ARG0, ARG1];
759     my ($msg, $msg_hash, $module);
760     my $error = 0;
761     my $answer_l;
762     my ($answer_header, @answer_target_l, $answer_source);
763     my $client_answer;
765     daemon_log("Incoming msg from '".$heap->{'remote_ip'}."'", 7);
766     daemon_log("\n$input", 8);
768     # msg is from a new client or gosa
769     ($msg, $msg_hash, $module) = &input_from_unknown_host($input);
771     # msg is from a gosa-si-server or gosa-si-bus
772     if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
773         ($msg, $msg_hash, $module) = &input_from_known_server($input, $heap->{'remote_ip'});
774     }
776     # msg is from a gosa-si-client
777     if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
778         ($msg, $msg_hash, $module) = &input_from_known_client($input, $heap->{'remote_ip'});
779     }
781     # an error occurred
782     if(( !$msg ) || ( !$msg_hash ) || ( !$module )){
783         $error++;
784     }
786     ######################
787     # process incoming msg
788     if( $error == 0) {
789         daemon_log("Processing module ".$module, 5);
790         $answer_l = &{ $module."::process_incoming_msg" }($msg, $msg_hash, $heap->{'remote_ip'});
792         if ( 0 > @{$answer_l} ) {
793             my $answer_str = join("\n", @{$answer_l});
794             daemon_log("$module: Got answer from module: \n".$answer_str,8);
795         }
796     }
797     if( !$answer_l ) { $error++ };
799     ########
800     # answer
801     if( $error == 0 ) {
803         # for each answer in answer list
804         foreach my $answer ( @{$answer_l} ) {
806                         my $error = 0;
807                         # check answer if gosa-si envelope conform
808                         if(defined($answer)) {
809                                 my $answer_hash = $xml->XMLin($answer, ForceArray=>1);
810                                 $answer_header = @{$answer_hash->{'header'}}[0];
811                                 @answer_target_l = @{$answer_hash->{'target'}};
812                                 $answer_source = @{$answer_hash->{'source'}}[0];
813                                 if( !$answer_header ) {
814                                         daemon_log('ERROR: module answer is not gosa-si envelope conform: no header', 1);
815                                         daemon_log("\n$answer", 8);
816                                         $error++;
817                                 }
818                                 if( 0 == length @answer_target_l ) {
819                                         daemon_log('ERROR: module answer is not gosa-si envelope conform: no targets', 1);
820                                         daemon_log("\n$answer", 8);
821                                         $error++;
822                                 }
823                                 if( !$answer_source ) {
824                                         daemon_log('ERROR: module answer is not gosa-si envelope conform: no source', 1);
825                                         daemon_log("\n$answer", 8);
826                                         $error++;
827                                 }
829                                 if( $error != 0 ) {
830                                         next;
831                                 }
832                         }
834             # deliver msg to all targets 
835             foreach my $answer_target ( @answer_target_l ) {
836                 if( $answer_target eq "*" ) {
837                     # answer is for all clients
838                     my $sql_statement= "SELECT * FROM known_clients";
839                     my $query_res = $known_clients_db->select_dbentry( $sql_statement ); 
840                     while( my ($hit_num, $hit) = each %{ $query_res } ) {    
841                         my $host_name = $hit->{hostname};
842                         my $host_key = $hit->{hostkey};
843                         &send_msg_to_target($answer, $host_name, $host_key, $answer_header);
844                      }
845                 }
846                 elsif( $answer_target eq "GOSA" ) {
847                     # answer is for GOSA and has to returned to connected client
848                     my $gosa_answer = &encrypt_msg($answer, $GosaPackages_key);
849                     $client_answer = $gosa_answer;
850                 }
851                 elsif( $answer_target eq "KNOWN_SERVER" ) {
852                     # answer is for all server in known_server
853                     my $sql_statement= "SELECT * FROM known_server";
854                     my $query_res = $known_server_db->select_dbentry( $sql_statement ); 
855                     while( my ($hit_num, $hit) = each %{ $query_res } ) {    
856                         my $host_name = $hit->{hostname};
857                         my $host_key = $hit->{hostkey};
858                         $answer =~ s/KNOWN_SERVER/$host_name/g;
859                         &send_msg_to_target($answer, $host_name, $host_key, $answer_header);
860                     }
861                 }
862                 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})/ ) {
863                     daemon_log("target is mac address '$answer_target', looking for host in known_clients", 3);
864                     my $sql_statement = "SELECT * FROM known_clients WHERE macaddress='$answer_target'";
865                     my $query_res = $known_clients_db->select_dbentry( $sql_statement );
866                     my $found_ip_flag = 0;
867                     while( my ($hit_num, $hit) = each %{ $query_res } ) {    
868                         my $host_name = $hit->{hostname};
869                         my $host_key = $hit->{hostkey};
870                         $answer =~ s/$answer_target/$host_name/g;
871                         daemon_log("found host '$host_name', assoziated to '$answer_target'", 3);
872                         &send_msg_to_target($answer, $host_name, $host_key, $answer_header);
873                         $found_ip_flag++ ;
874                     }   
875                     if( $found_ip_flag == 0) {
876                         daemon_log("WARNING: no host found in known_clients with mac address '$answer_target', forward msg to bus", 1);
877                         my $sql_statement = "SELECT * FROM known_server WHERE hostname='$bus_address'";
878                         my $query_res = $known_server_db->select_dbentry( $sql_statement );
879                         while( my ($hit_num, $hit) = each %{ $query_res } ) {    
880                             my $bus_address = $hit->{hostname};
881                             my $bus_key = $hit->{hostkey};
882                             &send_msg_to_target($answer, $bus_address, $bus_key, $answer_header);
883                             last;
884                         }
886                     }
887                 }
888                 else {
889                     # answer is for one specific host
890                     # get encrypt_key
891                     my $encrypt_key = &get_encrypt_key($answer_target);
892                     if( !$encrypt_key ) {
893                         # unknown target, forward msg to bus
894                         daemon_log("WARNING: unknown target '$answer_target', forward msg to bus", 3);
895                         my $sql_statement = "SELECT * FROM known_server WHERE hostname='$bus_address'";
896                         my $query_res = $known_server_db->select_dbentry( $sql_statement );
897                         my $bus_key = $query_res->{1}->{hostkey};
898                         &send_msg_to_target($answer, $bus_address, $bus_key, $answer_header);
899                         next;
900                     }
901                     # send_msg
902                     &send_msg_to_target($answer, $answer_target, $encrypt_key, $answer_header);
903                 }
904             }
905         }
906     }
908     if( $client_answer ) {
909         $heap->{client}->put($client_answer);
910     }
912     return;
917 sub trigger_db_loop {
918 #       my ($kernel) = $_[KERNEL];
919         my ($kernel) = @_ ;
920         $kernel->delay_set('watch_for_new_jobs',3);
924 sub watch_for_new_jobs {
925         my ($kernel,$heap) = @_[KERNEL, HEAP];
927         # check gosa job queue for jobs with executable timestamp
928     my $timestamp = &get_time();
930     my $sql_statement = "SELECT * FROM ".$job_queue_table_name.
931         " WHERE status='waiting' AND timestamp<'$timestamp'";
933         my $res = $job_db->select_dbentry( $sql_statement );
935         while( my ($id, $hit) = each %{$res} ) {         
937                 my $jobdb_id = $hit->{id};
938                 my $macaddress = $hit->{macaddress};
939                 my $job_msg_hash = &transform_msg2hash($hit->{xmlmessage});
940                 my $out_msg_hash = $job_msg_hash;
941         my $sql_statement = "SELECT * FROM known_clients WHERE macaddress='$macaddress'";
942                 my $res_hash = $known_clients_db->select_dbentry( $sql_statement );
943                 # expect macaddress is unique!!!!!!
944                 my $target = $res_hash->{1}->{hostname};
946                 if (not defined $target) {
947                         &daemon_log("ERROR: no host found for mac address: $job_msg_hash->{mac}[0]", 1);
948                         &daemon_log("xml message: $hit->{xmlmessage}", 5);
949             my $sql_statement = "UPDATE $job_queue_table_name ".
950                 "SET status='error', result='no host found for mac address' ".
951                 "WHERE id='$jobdb_id'";
952                         my $res = $job_db->update_dbentry($sql_statement);
953                         next;
954                 }
956                 # add target
957                 &add_content2xml_hash($out_msg_hash, "target", $target);
959                 # add new header
960                 my $out_header = $job_msg_hash->{header}[0];
961                 $out_header =~ s/job_/gosa_/;
962                 delete $out_msg_hash->{header};
963                 &add_content2xml_hash($out_msg_hash, "header", $out_header);
965                 # add sqlite_id 
966                 &add_content2xml_hash($out_msg_hash, "jobdb_id", $jobdb_id); 
968                 my $out_msg = &create_xml_string($out_msg_hash);
970                 # encrypt msg as a GosaPackage module
971                 my $cipher = &create_ciphering($GosaPackages_key);
972                 my $crypted_out_msg = &encrypt_msg($out_msg, $cipher);
974                 my $error = &send_msg_hash2address($out_msg_hash, "$gosa_ip:$gosa_port", $GosaPackages_key);
976                 if ($error == 0) {
977                         my $sql_statement = "UPDATE $job_queue_table_name ".
978                 "SET status='processing', targettag='$target' ".
979                 "WHERE id='$jobdb_id'";
980                         my $res = $job_db->update_dbentry($sql_statement);
981                 } else {
982             my $sql_statement = "UPDATE $job_queue_table_name ".
983                 "SET status='error' ".
984                 "WHERE id='$jobdb_id'";
985                         my $res = $job_db->update_dbentry($sql_statement);
986                 }
987         }
989         $kernel->delay_set('watch_for_new_jobs',3);
993 #==== MAIN = main ==============================================================
994 #  parse commandline options
995 Getopt::Long::Configure( "bundling" );
996 GetOptions("h|help" => \&usage,
997         "c|config=s" => \$cfg_file,
998         "f|foreground" => \$foreground,
999         "v|verbose+" => \$verbose,
1000         "no-bus+" => \$no_bus,
1001         "no-arp+" => \$no_arp,
1002            );
1004 #  read and set config parameters
1005 &check_cmdline_param ;
1006 &read_configfile;
1007 &check_pid;
1009 $SIG{CHLD} = 'IGNORE';
1011 # forward error messages to logfile
1012 if( ! $foreground ) {
1013     open(STDERR, '>>', $log_file);
1014     open(STDOUT, '>>', $log_file);
1017 # Just fork, if we are not in foreground mode
1018 if( ! $foreground ) { 
1019     chdir '/'                 or die "Can't chdir to /: $!";
1020     $pid = fork;
1021     setsid                    or die "Can't start a new session: $!";
1022     umask 0;
1023 } else { 
1024     $pid = $$; 
1027 # Do something useful - put our PID into the pid_file
1028 if( 0 != $pid ) {
1029     open( LOCK_FILE, ">$pid_file" );
1030     print LOCK_FILE "$pid\n";
1031     close( LOCK_FILE );
1032     if( !$foreground ) { 
1033         exit( 0 ) 
1034     };
1037 daemon_log(" ", 1);
1038 daemon_log("$0 started!", 1);
1040 # delete old DBsqlite lock files
1041 system('rm -f /tmp/gosa_si_lock*gosa-si-server*');
1043 # connect to gosa-si job queue
1044 my @job_col_names = ("id", "timestamp", "status", "result", "headertag", "targettag", "xmlmessage", "macaddress");
1045 $job_db = GOSA::DBsqlite->new($job_queue_file_name);
1046 $job_db->create_table('jobs', \@job_col_names);
1048 # connect to known_clients_db
1049 my @clients_col_names = ('hostname', 'status', 'hostkey', 'timestamp', 'macaddress', 'events');
1050 $known_clients_db = GOSA::DBsqlite->new($known_clients_file_name);
1051 $known_clients_db->create_table('known_clients', \@clients_col_names);
1053 # connect to known_server_db
1054 my @server_col_names = ('hostname', 'status', 'hostkey', 'timestamp');
1055 $known_server_db = GOSA::DBsqlite->new($known_server_file_name);
1056 $known_server_db->create_table('known_server', \@server_col_names);
1058 # create xml object used for en/decrypting
1059 $xml = new XML::Simple();
1061 # create socket for incoming xml messages
1062 POE::Component::Server::TCP->new(
1063         Port => $server_port,
1064         ClientInput => \&client_input,
1065 );
1066 daemon_log("start socket for incoming xml messages at port '$server_port' ", 1);
1068 # create session for repeatedly checking the job queue for jobs
1069 POE::Session->create(
1070         inline_states => {
1071                 _start => \&_start,
1072                 watch_for_new_jobs => \&watch_for_new_jobs,
1073         }
1074 );
1077 # import all modules
1078 &import_modules;
1080 # check wether all modules are gosa-si valid passwd check
1082 POE::Kernel->run();
1083 exit;