1 ## @file
2 # @details A GOsa-SI event module containing all functions common used by GOsa
3 # @brief Implementation of a GOsa-SI event module.
5 package gosaTriggered;
6 use Exporter;
7 @ISA = qw(Exporter);
8 my @events = (
9 "get_events",
10 "get_login_usr_for_client",
11 "get_client_for_login_usr",
12 "gen_smb_hash",
13 "trigger_reload_syslog_config",
14 "trigger_reload_ntp_config",
15 "trigger_reload_ldap_config",
16 "ping",
17 "network_completition",
18 "set_activated_for_installation",
19 "new_key_for_client",
20 "detect_hardware",
21 "get_login_usr",
22 "get_login_client",
23 "trigger_action_localboot",
24 "trigger_action_faireboot",
25 "trigger_action_reboot",
26 "trigger_action_activate",
27 "trigger_action_lock",
28 "trigger_action_halt",
29 "trigger_action_update",
30 "trigger_action_reinstall",
31 "trigger_action_memcheck",
32 "trigger_action_sysinfo",
33 "trigger_action_instant_update",
34 "trigger_action_rescan",
35 "trigger_action_wake",
36 "recreate_fai_server_db",
37 "recreate_fai_release_db",
38 "recreate_packages_list_db",
39 "send_user_msg",
40 "get_available_kernel",
41 "trigger_activate_new",
42 "get_hosts_with_module",
43 # "get_dak_keyring",
44 # "import_dak_key",
45 # "remove_dak_key",
46 # "get_dak_queue",
47 );
48 @EXPORT = @events;
50 use strict;
51 use warnings;
52 use GOSA::GosaSupportDaemon;
53 use Data::Dumper;
54 use Crypt::SmbHash;
55 use Net::ARP;
56 use Net::Ping;
57 use Socket;
58 use Time::HiRes qw( usleep);
59 use MIME::Base64;
61 BEGIN {}
63 END {}
65 ### Start ######################################################################
67 ## @method get_events()
68 # A brief function returning a list of functions which are exported by importing the module.
69 # @return List of all provided functions
70 sub get_events {
71 return \@events;
72 }
74 ## @method send_usr_msg($msg, $msg_hash, $session_id)
75 # This function accepts usr messages from GOsa, split mulitple target messages to mulitiple single target messages and put all messages into messaging_db
76 # @param msg - STRING - xml message
77 # @param msg_hash - HASHREF - message information parsed into a hash
78 # @param session_id - INTEGER - POE session id of the processing of this message
79 # @return (out_msg) - ARRAY - Array containing the answer message from client
80 sub send_user_msg {
81 my ($msg, $msg_hash, $session_id) = @_ ;
82 my $header = @{$msg_hash->{'header'}}[0];
83 my $source = @{$msg_hash->{'source'}}[0];
84 my $target = @{$msg_hash->{'target'}}[0];
86 #my $subject = &decode_base64(@{$msg_hash->{'subject'}}[0]); # just for debugging
87 my $subject = @{$msg_hash->{'subject'}}[0];
88 my $from = @{$msg_hash->{'from'}}[0];
89 my @users = exists $msg_hash->{'user'} ? @{$msg_hash->{'user'}} : () ;
90 my @groups = exists $msg_hash->{'group'} ? @{$msg_hash->{'group'}} : ();
91 my $delivery_time = @{$msg_hash->{'delivery_time'}}[0];
92 #my $message = &decode_base64(@{$msg_hash->{'message'}}[0]); # just for debugging
93 my $message = @{$msg_hash->{'message'}}[0];
95 # keep job queue uptodate if necessary
96 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
97 if( defined $jobdb_id) {
98 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
99 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
100 my $res = $main::job_db->exec_statement($sql_statement);
101 }
103 # error handling
104 if (not $delivery_time =~ /^\d{14}$/) {
105 my $error_string = "delivery_time '$delivery_time' is not a valid timestamp, please use format 'yyyymmddhhmmss'";
106 &main::daemon_log("$session_id ERROR: $error_string", 1);
107 return &create_xml_string(&create_xml_hash($header, $target, $source, $error_string));
108 }
110 # determine new message id
111 my $new_msg_id = 1;
112 my $new_msg_id_sql = "SELECT MAX(id) FROM $main::messaging_tn";
113 my $new_msg_id_res = $main::messaging_db->exec_statement($new_msg_id_sql);
114 if (defined @{@{$new_msg_id_res}[0]}[0] ) {
115 $new_msg_id = int(@{@{$new_msg_id_res}[0]}[0]);
116 $new_msg_id += 1;
117 }
119 # highlight user name and group name
120 my @receiver_l;
121 @users = map(push(@receiver_l, "u_$_"), @users);
122 @groups = map(push(@receiver_l, "g_$_"), @groups);
124 # Sanitiy check of receivers list
125 if (@receiver_l == 0) {
126 &main::daemon_log("$session_id ERROR: 'send_usr_msg'-message contains neither a 'usr' nor a 'group' tag. No receiver specified.", 1);
127 return;
128 }
130 # add incoming message to messaging_db
131 my $func_dic = {table=>$main::messaging_tn,
132 primkey=>[],
133 id=>$new_msg_id,
134 subject=>$subject,
135 message_from=>$from,
136 message_to=>join(",", @receiver_l),
137 flag=>"n",
138 direction=>"in",
139 delivery_time=>$delivery_time,
140 message=>$message,
141 timestamp=>&get_time(),
142 };
143 my $res = $main::messaging_db->add_dbentry($func_dic);
144 if (not $res == 0) {
145 &main::daemon_log("$session_id ERROR: gosaTriggered.pm: cannot add message to message_db: $res", 1);
146 } else {
147 &main::daemon_log("$session_id INFO: gosaTriggered.pm: message with subject '".&decode_base64($subject)."' successfully added to message_db", 5);
148 }
150 return;
151 }
154 sub recreate_fai_server_db {
155 my ($msg, $msg_hash, $session_id) = @_ ;
156 my $out_msg;
158 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
159 if( defined $jobdb_id) {
160 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
161 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
162 my $res = $main::job_db->exec_statement($sql_statement);
163 }
165 $main::fai_server_db->create_table("new_fai_server", \@main::fai_server_col_names);
166 &main::create_fai_server_db("new_fai_server",undef,"dont", $session_id);
167 $main::fai_server_db->move_table("new_fai_server", $main::fai_server_tn);
169 my @out_msg_l = ( $out_msg );
170 return @out_msg_l;
171 }
174 sub recreate_fai_release_db {
175 my ($msg, $msg_hash, $session_id) = @_ ;
176 my $out_msg;
178 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
179 if( defined $jobdb_id) {
180 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
181 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
182 my $res = $main::job_db->exec_statement($sql_statement);
183 }
185 $main::fai_release_db->create_table("new_fai_release", \@main::fai_release_col_names);
186 &main::create_fai_release_db("new_fai_release", $session_id);
187 $main::fai_release_db->move_table("new_fai_release", $main::fai_release_tn);
189 my @out_msg_l = ( $out_msg );
190 return @out_msg_l;
191 }
194 sub recreate_packages_list_db {
195 my ($msg, $msg_hash, $session_id) = @_ ;
196 my $out_msg;
198 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
199 if( defined $jobdb_id) {
200 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
201 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
202 my $res = $main::job_db->exec_statement($sql_statement);
203 }
205 &main::create_packages_list_db;
207 my @out_msg_l = ( $out_msg );
208 return @out_msg_l;
209 }
212 sub get_login_usr_for_client {
213 my ($msg, $msg_hash, $session_id) = @_ ;
214 my $header = @{$msg_hash->{'header'}}[0];
215 my $source = @{$msg_hash->{'source'}}[0];
216 my $target = @{$msg_hash->{'target'}}[0];
217 my $client = @{$msg_hash->{'client'}}[0];
219 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
220 if( defined $jobdb_id) {
221 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
222 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
223 my $res = $main::job_db->exec_statement($sql_statement);
224 }
226 $header =~ s/^gosa_//;
228 my $sql_statement = "SELECT * FROM known_clients WHERE hostname='$client' OR macaddress LIKE '$client'";
229 my $res = $main::known_clients_db->select_dbentry($sql_statement);
231 my $out_msg = "<xml><header>$header</header><source>$target</source><target>$source</target>";
232 $out_msg .= &db_res2xml($res);
233 $out_msg .= "</xml>";
235 my @out_msg_l = ( $out_msg );
236 return @out_msg_l;
237 }
240 sub get_client_for_login_usr {
241 my ($msg, $msg_hash, $session_id) = @_ ;
242 my $header = @{$msg_hash->{'header'}}[0];
243 my $source = @{$msg_hash->{'source'}}[0];
244 my $target = @{$msg_hash->{'target'}}[0];
246 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
247 if( defined $jobdb_id) {
248 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
249 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
250 my $res = $main::job_db->exec_statement($sql_statement);
251 }
253 my $usr = @{$msg_hash->{'usr'}}[0];
254 $header =~ s/^gosa_//;
256 my $sql_statement = "SELECT * FROM known_clients WHERE login LIKE '%$usr%'";
257 my $res = $main::known_clients_db->select_dbentry($sql_statement);
259 my $out_msg = "<xml><header>$header</header><source>$target</source><target>$source</target>";
260 $out_msg .= &db_res2xml($res);
261 $out_msg .= "</xml>";
262 my @out_msg_l = ( $out_msg );
263 return @out_msg_l;
265 }
268 sub ping {
269 my ($msg, $msg_hash, $session_id) = @_ ;
270 my $header = @{$msg_hash->{header}}[0];
271 my $target = @{$msg_hash->{target}}[0];
272 my $source = @{$msg_hash->{source}}[0];
273 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
274 my $error = 0;
275 my $answer_msg;
276 my ($sql, $res);
278 if( defined $jobdb_id) {
279 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
280 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
281 my $res = $main::job_db->exec_statement($sql_statement);
282 }
284 # send message
285 $sql = "SELECT * FROM $main::known_clients_tn WHERE ((hostname='$target') || (macaddress LIKE '$target'))";
286 $res = $main::known_clients_db->exec_statement($sql);
288 # sanity check of db result
289 my ($host_name, $host_key);
290 if ((defined $res) && (@$res > 0) && @{@$res[0]} > 0) {
291 $host_name = @{@$res[0]}[0];
292 $host_key = @{@$res[0]}[2];
293 } else {
294 &main::daemon_log("$session_id ERROR: cannot determine host_name and host_key from known_clients_db at function ping\n$msg", 1);
295 $error = 1;
296 }
298 if (not $error) {
299 my $client_hash = &create_xml_hash("ping", $main::server_address, $host_name);
300 &add_content2xml_hash($client_hash, 'session_id', $session_id);
301 my $client_msg = &create_xml_string($client_hash);
302 &main::send_msg_to_target($client_msg, $host_name, $host_key, $header, $session_id);
304 my $message_id;
305 my $i = 0;
306 while (1) {
307 $i++;
308 $sql = "SELECT * FROM $main::incoming_tn WHERE headertag='answer_$session_id'";
309 $res = $main::incoming_db->exec_statement($sql);
310 if (ref @$res[0] eq "ARRAY") {
311 $message_id = @{@$res[0]}[0];
312 last;
313 }
315 # do not run into a endless loop
316 if ($i > 100) { last; }
317 usleep(100000);
318 }
320 # if an answer to the question exists
321 if (defined $message_id) {
322 my $answer_xml = @{@$res[0]}[3];
323 my %data = ( 'answer_xml' => 'bin noch da' );
324 $answer_msg = &build_msg("got_ping", $target, $source, \%data);
325 my $forward_to_gosa = @{$msg_hash->{'forward_to_gosa'}}[0];
326 if (defined $forward_to_gosa){
327 $answer_msg =~s/<\/xml>/<forward_to_gosa>$forward_to_gosa<\/forward_to_gosa><\/xml>/;
328 }
329 $sql = "DELETE FROM $main::incoming_tn WHERE id=$message_id";
330 $res = $main::incoming_db->exec_statement($sql);
331 }
333 }
335 return ( $answer_msg );
336 }
340 sub gen_smb_hash {
341 my ($msg, $msg_hash, $session_id) = @_ ;
342 my $source = @{$msg_hash->{source}}[0];
343 my $target = @{$msg_hash->{target}}[0];
344 my $password = @{$msg_hash->{password}}[0];
346 my %data= ('hash' => join(q[:], ntlmgen $password));
347 my $out_msg = &build_msg("gen_smb_hash", $target, $source, \%data );
348 my $forward_to_gosa = @{$msg_hash->{'forward_to_gosa'}}[0];
349 if (defined $forward_to_gosa) {
350 $out_msg =~s/<\/xml>/<forward_to_gosa>$forward_to_gosa<\/forward_to_gosa><\/xml>/;
351 }
353 return ( $out_msg );
354 }
357 sub network_completition {
358 my ($msg, $msg_hash, $session_id) = @_ ;
359 my $source = @{$msg_hash->{source}}[0];
360 my $target = @{$msg_hash->{target}}[0];
361 my $name = @{$msg_hash->{hostname}}[0];
363 # Can we resolv the name?
364 my %data;
365 if (inet_aton($name)){
366 my $address = inet_ntoa(inet_aton($name));
367 my $p = Net::Ping->new('tcp');
368 my $mac= "";
369 if ($p->ping($address, 1)){
370 $mac = Net::ARP::arp_lookup("", $address);
371 }
373 %data= ('ip' => $address, 'mac' => $mac);
374 } else {
375 %data= ('ip' => '', 'mac' => '');
376 }
378 my $out_msg = &build_msg("network_completition", $target, $source, \%data );
379 my $forward_to_gosa = @{$msg_hash->{'forward_to_gosa'}}[0];
380 if (defined $forward_to_gosa) {
381 $out_msg =~s/<\/xml>/<forward_to_gosa>$forward_to_gosa<\/forward_to_gosa><\/xml>/;
382 }
384 return ( $out_msg );
385 }
388 sub detect_hardware {
389 my ($msg, $msg_hash, $session_id) = @_ ;
390 # just forward msg to client, but dont forget to split off 'gosa_' in header
391 my $source = @{$msg_hash->{source}}[0];
392 my $target = @{$msg_hash->{target}}[0];
393 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
394 if( defined $jobdb_id) {
395 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
396 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
397 my $res = $main::job_db->exec_statement($sql_statement);
398 }
400 my $out_hash = &create_xml_hash("detect_hardware", $source, $target);
401 if( defined $jobdb_id ) {
402 &add_content2xml_hash($out_hash, 'jobdb_id', $jobdb_id);
403 }
404 my $out_msg = &create_xml_string($out_hash);
406 my @out_msg_l = ( $out_msg );
407 return @out_msg_l;
409 }
411 sub trigger_reload_syslog_config {
412 my ($msg, $msg_hash, $session_id) = @_ ;
414 # Sanity check of macaddress
415 # TODO
417 my $macaddress = @{$msg_hash->{macaddress}}[0];
419 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
420 if( defined $jobdb_id) {
421 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
422 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
423 my $res = $main::job_db->exec_statement($sql_statement);
424 }
426 my $out_msg = &ClientPackages::new_syslog_config($macaddress, $session_id);
427 my @out_msg_l = ( $out_msg );
429 return @out_msg_l;
432 }
434 sub trigger_reload_ntp_config {
435 my ($msg, $msg_hash, $session_id) = @_ ;
437 # Sanity check of macaddress
438 # TODO
440 my $macaddress = @{$msg_hash->{macaddress}}[0];
442 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
443 if( defined $jobdb_id) {
444 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
445 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
446 my $res = $main::job_db->exec_statement($sql_statement);
447 }
449 my $out_msg = &ClientPackages::new_ntp_config($macaddress, $session_id);
450 my @out_msg_l = ( $out_msg );
452 return @out_msg_l;
454 }
456 sub trigger_reload_ldap_config {
457 my ($msg, $msg_hash, $session_id) = @_ ;
458 my $target = @{$msg_hash->{target}}[0];
460 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
461 if( defined $jobdb_id) {
462 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
463 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
464 my $res = $main::job_db->exec_statement($sql_statement);
465 }
467 my $out_msg = &ClientPackages::new_ldap_config($target, $session_id);
468 my @out_msg_l = ( $out_msg );
470 return @out_msg_l;
471 }
474 sub set_activated_for_installation {
475 my ($msg, $msg_hash, $session_id) = @_;
476 my $header = @{$msg_hash->{header}}[0];
477 my $source = @{$msg_hash->{source}}[0];
478 my $target = @{$msg_hash->{target}}[0];
479 my $mac= (defined($msg_hash->{'macaddress'}))?@{$msg_hash->{'macaddress'}}[0]:undef;
480 my @out_msg_l;
482 # update status of job
483 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
484 if( defined $jobdb_id) {
485 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
486 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
487 my $res = $main::job_db->exec_statement($sql_statement);
488 }
490 # If a client gets a 'set_activated_for_installation' msg, always deliver a fresh 'new_ldap_config'
491 # just for backup and robustness purposes
492 my $ldap_out_msg = &ClientPackages::new_ldap_config($mac, $session_id);
493 push(@out_msg_l, $ldap_out_msg);
495 # create set_activated_for_installation message for delivery
496 my $out_hash = &create_xml_hash("set_activated_for_installation", $source, $target);
497 if( defined $jobdb_id ) {
498 &add_content2xml_hash($out_hash, 'jobdb_id', $jobdb_id);
499 }
500 my $out_msg = &create_xml_string($out_hash);
501 push(@out_msg_l, $out_msg);
503 return @out_msg_l;
504 }
507 sub trigger_action_faireboot {
508 my ($msg, $msg_hash, $session_id) = @_;
509 my $macaddress = @{$msg_hash->{macaddress}}[0];
510 my $source = @{$msg_hash->{source}}[0];
512 my @out_msg_l;
513 $msg =~ s/<header>gosa_trigger_action_faireboot<\/header>/<header>trigger_action_faireboot<\/header>/;
514 push(@out_msg_l, $msg);
516 &main::change_goto_state('locked', \@{$msg_hash->{macaddress}}, $session_id);
517 &main::change_fai_state('install', \@{$msg_hash->{macaddress}}, $session_id);
519 # set job to status 'done', job will be deleted automatically
520 my $sql_statement = "UPDATE $main::job_queue_tn ".
521 "SET status='done', modified='1'".
522 "WHERE (macaddress='$macaddress' AND status='processing')";
523 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
524 my $res = $main::job_db->update_dbentry( $sql_statement );
526 return @out_msg_l;
527 }
530 sub trigger_action_lock {
531 my ($msg, $msg_hash, $session_id) = @_;
532 my $macaddress = @{$msg_hash->{macaddress}}[0];
533 my $source = @{$msg_hash->{source}}[0];
535 &main::change_goto_state('locked', \@{$msg_hash->{macaddress}}, $session_id);
536 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
537 if( defined $jobdb_id) {
538 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
539 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
540 my $res = $main::job_db->exec_statement($sql_statement);
541 }
543 my @out_msg_l;
544 return @out_msg_l;
545 }
548 sub trigger_action_activate {
549 my ($msg, $msg_hash, $session_id) = @_;
550 my $macaddress = @{$msg_hash->{macaddress}}[0];
551 my $source = @{$msg_hash->{source}}[0];
553 &main::change_goto_state('active', \@{$msg_hash->{macaddress}}, $session_id);
554 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
555 if( defined $jobdb_id) {
556 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
557 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
558 my $res = $main::job_db->exec_statement($sql_statement);
559 }
561 my $out_hash = &create_xml_hash("set_activated_for_installation", $source, $macaddress);
562 if( exists $msg_hash->{'jobdb_id'} ) {
563 &add_content2xml_hash($out_hash, 'jobdb_id', @{$msg_hash->{'jobdb_id'}}[0]);
564 }
565 my $out_msg = &create_xml_string($out_hash);
567 my @out_msg_l = ($out_msg);
568 return @out_msg_l;
570 }
573 sub trigger_action_localboot {
574 my ($msg, $msg_hash, $session_id) = @_;
575 my $macaddress= $msg_hash->{macaddress}[0];
576 my $target= $msg_hash->{target}[0];
577 my @out_msg_l;
578 $msg =~ s/<header>gosa_trigger_action_localboot<\/header>/<header>trigger_action_localboot<\/header>/;
580 # Check for running jobs. In that case return a message to GOsa that running jobs have to be deleted/aborted
581 # befor trigger_action_localboot could be effective. Running jobs usually sets FAIstate and GOtomode to
582 # what they need again and again and overwrite the 'trigger_action_localboot' setting
583 my $job_sql= "SELECT * FROM $main::job_queue_tn WHERE macaddress='$macaddress'";
584 my $job_res = $main::job_db->select_dbentry($job_sql);
585 my $job_res_count = keys(%$job_res);
586 if ($job_res_count) {
587 push(@out_msg_l, "<xml><header>answer</header><source>$target</source><target>GOSA</target><answer1>existing_job_in_queue</answer1></xml>");
588 }
590 &main::change_fai_state('localboot', \@{$msg_hash->{macaddress}}, $session_id);
591 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
592 if( defined $jobdb_id) {
593 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
594 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
595 my $res = $main::job_db->exec_statement($sql_statement);
596 }
598 push(@out_msg_l, $msg);
599 return @out_msg_l;
600 }
603 sub trigger_action_halt {
604 my ($msg, $msg_hash, $session_id) = @_;
605 $msg =~ s/<header>gosa_trigger_action_halt<\/header>/<header>trigger_action_halt<\/header>/;
607 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
608 if( defined $jobdb_id) {
609 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
610 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
611 my $res = $main::job_db->exec_statement($sql_statement);
612 }
614 my @out_msg_l = ($msg);
615 return @out_msg_l;
616 }
619 sub trigger_action_reboot {
620 my ($msg, $msg_hash, $session_id) = @_;
621 $msg =~ s/<header>gosa_trigger_action_reboot<\/header>/<header>trigger_action_reboot<\/header>/;
623 &main::change_fai_state('reboot', \@{$msg_hash->{macaddress}}, $session_id);
624 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
625 if( defined $jobdb_id) {
626 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
627 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
628 my $res = $main::job_db->exec_statement($sql_statement);
629 }
631 my @out_msg_l = ($msg);
632 return @out_msg_l;
633 }
636 sub trigger_action_memcheck {
637 my ($msg, $msg_hash, $session_id) = @_ ;
638 $msg =~ s/<header>gosa_trigger_action_memcheck<\/header>/<header>trigger_action_memcheck<\/header>/;
640 &main::change_fai_state('memcheck', \@{$msg_hash->{macaddress}}, $session_id);
641 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
642 if( defined $jobdb_id) {
643 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
644 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
645 my $res = $main::job_db->exec_statement($sql_statement);
646 }
648 my @out_msg_l = ($msg);
649 return @out_msg_l;
650 }
653 sub trigger_action_reinstall {
654 my ($msg, $msg_hash, $session_id) = @_;
655 $msg =~ s/<header>gosa_trigger_action_reinstall<\/header>/<header>trigger_action_reinstall<\/header>/;
657 &main::change_fai_state('reinstall', \@{$msg_hash->{macaddress}}, $session_id);
659 my %data = ( 'macaddress' => \@{$msg_hash->{macaddress}} );
660 my $wake_msg = &build_msg("trigger_wake", "GOSA", "KNOWN_SERVER", \%data);
661 # invoke trigger wake for this gosa-si-server
662 &main::server_server_com::trigger_wake($msg, $msg_hash, $session_id);
664 my @out_msg_l = ($wake_msg, $msg);
665 return @out_msg_l;
666 }
669 sub trigger_action_update {
670 my ($msg, $msg_hash, $session_id) = @_;
671 $msg =~ s/<header>gosa_trigger_action_update<\/header>/<header>trigger_action_update<\/header>/;
673 &main::change_fai_state('update', \@{$msg_hash->{macaddress}}, $session_id);
675 my %data = ( 'macaddress' => \@{$msg_hash->{macaddress}} );
676 my $wake_msg = &build_msg("trigger_wake", "GOSA", "KNOWN_SERVER", \%data);
677 # invoke trigger wake for this gosa-si-server
678 &main::server_server_com::trigger_wake($msg, $msg_hash, $session_id);
680 my @out_msg_l = ($wake_msg, $msg);
681 return @out_msg_l;
682 }
685 sub trigger_action_instant_update {
686 my ($msg, $msg_hash, $session_id) = @_;
687 $msg =~ s/<header>gosa_trigger_action_instant_update<\/header>/<header>trigger_action_instant_update<\/header>/;
689 &main::change_fai_state('update', \@{$msg_hash->{macaddress}}, $session_id);
691 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
692 if( defined $jobdb_id) {
693 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
694 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
695 my $res = $main::job_db->exec_statement($sql_statement);
696 }
699 my %data = ( 'macaddress' => \@{$msg_hash->{macaddress}} );
700 my $wake_msg = &build_msg("trigger_wake", "GOSA", "KNOWN_SERVER", \%data);
701 # invoke trigger wake for this gosa-si-server
702 &main::server_server_com::trigger_wake($msg, $msg_hash, $session_id);
704 my @out_msg_l = ($wake_msg, $msg);
705 return @out_msg_l;
706 }
709 sub trigger_action_sysinfo {
710 my ($msg, $msg_hash, $session_id) = @_;
711 $msg =~ s/<header>gosa_trigger_action_sysinfo<\/header>/<header>trigger_action_sysinfo<\/header>/;
713 &main::change_fai_state('sysinfo', \@{$msg_hash->{macaddress}}, $session_id);
714 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
715 if( defined $jobdb_id) {
716 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
717 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
718 my $res = $main::job_db->exec_statement($sql_statement);
719 }
721 my @out_msg_l = ($msg);
722 return @out_msg_l;
723 }
726 sub new_key_for_client {
727 my ($msg, $msg_hash, $session_id) = @_;
729 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
730 if( defined $jobdb_id) {
731 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
732 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
733 my $res = $main::job_db->exec_statement($sql_statement);
734 }
736 $msg =~ s/<header>gosa_new_key_for_client<\/header>/<header>new_key<\/header>/;
737 my @out_msg_l = ($msg);
738 return @out_msg_l;
739 }
742 sub trigger_action_rescan {
743 my ($msg, $msg_hash, $session_id) = @_;
745 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
746 if( defined $jobdb_id) {
747 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
748 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
749 my $res = $main::job_db->exec_statement($sql_statement);
750 }
753 $msg =~ s/<header>gosa_trigger_action_rescan<\/header>/<header>detect_hardware<header>/;
754 my @out_msg_l = ($msg);
755 return @out_msg_l;
756 }
759 sub trigger_action_wake {
760 my ($msg, $msg_hash, $session_id) = @_;
762 my $jobdb_id = @{$msg_hash->{'jobdb_id'}}[0];
763 if( defined $jobdb_id) {
764 my $sql_statement = "UPDATE $main::job_queue_tn SET status='processed' WHERE id=$jobdb_id";
765 &main::daemon_log("$session_id DEBUG: $sql_statement", 7);
766 my $res = $main::job_db->exec_statement($sql_statement);
767 }
769 # build out message
770 my $out_hash = &create_xml_hash("trigger_wake", "GOSA", "KNOWN_SERVER");
771 foreach (@{$msg_hash->{'macaddress'}}) {
772 &add_content2xml_hash($out_hash, 'macaddress', $_);
773 }
774 if (defined $jobdb_id){
775 &add_content2xml_hash($out_hash, 'jobdb_id', $jobdb_id);
776 }
777 my $out_msg = &create_xml_string($out_hash);
779 # invoke trigger wake for this gosa-si-server
780 &main::server_server_com::trigger_wake($out_msg, $out_hash, $session_id);
782 # send trigger wake to all other gosa-si-server
783 my @out_msg_l = ($out_msg);
784 return @out_msg_l;
785 }
788 sub get_available_kernel {
789 my ($msg, $msg_hash, $session_id) = @_;
791 my $source = @{$msg_hash->{'source'}}[0];
792 my $target = @{$msg_hash->{'target'}}[0];
793 my $fai_release= @{$msg_hash->{'fai_release'}}[0];
795 my @kernel;
796 # Get Kernel packages for release
797 my $sql_statement = "SELECT * FROM $main::packages_list_tn WHERE distribution='$fai_release' AND package LIKE 'linux\-image\-%'";
798 my $res_hash = $main::packages_list_db->select_dbentry($sql_statement);
799 my %data;
800 my $i=1;
802 foreach my $package (keys %{$res_hash}) {
803 $data{"answer".$i++}= $data{"answer".$i++}= ${$res_hash}{$package}->{'package'};
804 }
805 $data{"answer".$i++}= "default";
807 my $out_msg = &build_msg("get_available_kernel", $target, $source, \%data);
808 my $forward_to_gosa = @{$msg_hash->{'forward_to_gosa'}}[0];
809 if (defined $forward_to_gosa) {
810 $out_msg =~s/<\/xml>/<forward_to_gosa>$forward_to_gosa<\/forward_to_gosa><\/xml>/;
811 }
813 return ( $out_msg );
814 }
816 sub trigger_activate_new {
817 my ($msg, $msg_hash, $session_id, $ldap_handle) = @_;
819 my $source = @{$msg_hash->{'source'}}[0];
820 my $target = @{$msg_hash->{'target'}}[0];
821 my $header= @{$msg_hash->{'header'}}[0];
822 my $mac= (defined($msg_hash->{'mac'}))?@{$msg_hash->{'mac'}}[0]:undef;
823 my $ogroup= (defined($msg_hash->{'ogroup'}))?@{$msg_hash->{'ogroup'}}[0]:undef;
824 my $timestamp= (defined($msg_hash->{'timestamp'}))?@{$msg_hash->{'timestamp'}}[0]:undef;
825 my $base= (defined($msg_hash->{'base'}))?@{$msg_hash->{'base'}}[0]:undef;
826 my $hostname= (defined($msg_hash->{'fqdn'}))?@{$msg_hash->{'fqdn'}}[0]:undef;
827 my $ip_address= (defined($msg_hash->{'ip'}))?@{$msg_hash->{'ip'}}[0]:undef;
828 my $dhcp_statement= (defined($msg_hash->{'dhcp'}))?@{$msg_hash->{'dhcp'}}[0]:undef;
829 my $jobdb_id= (defined($msg_hash->{'jobdb_id'}))?@{$msg_hash->{'jobdb_id'}}[0]:undef;
831 # Sanity check for base
832 if (ref($base) eq "HASH") {
833 # Incoming msg has a xml tag 'base' but no content
834 $base = undef;
835 }
837 # In case that the client is sleeping, wake it up
838 my %data = ( 'macaddress' => $mac );
839 my $wake_msg = &build_msg("trigger_wake", "GOSA", "KNOWN_SERVER", \%data);
840 &main::server_server_com::trigger_wake($msg, $msg_hash, $session_id);
841 my $sql_statement= "SELECT * FROM $main::known_server_tn";
842 my $query_res = $main::known_server_db->select_dbentry( $sql_statement );
843 while( my ($hit_num, $hit) = each %{ $query_res } ) {
844 my $host_name = $hit->{hostname};
845 my $host_key = $hit->{hostkey};
846 $wake_msg =~ s/<target>\S+<\/target>/<target>$host_name<\/target>/g;
847 my $error = &main::send_msg_to_target($wake_msg, $host_name, $host_key, $header, $session_id);
848 }
850 my $ldap_entry;
851 my $ogroup_entry;
852 my $changed_attributes_counter = 0;
854 my $activate_client = 0;
856 if(defined($ogroup)) {
857 my $ldap_mesg= $ldap_handle->search(
858 base => $main::ldap_base,
859 scope => 'sub',
860 filter => "(&(objectClass=gosaGroupOfnames)(cn=$ogroup))",
861 );
862 if($ldap_mesg->count == 1) {
863 $ogroup_entry= $ldap_mesg->pop_entry();
864 &main::daemon_log("$session_id DEBUG: A GosaGroupOfNames with cn '$ogroup' was found in base '".$main::ldap_base."'!", 5);
865 } elsif ($ldap_mesg->count == 0) {
866 &main::daemon_log("$session_id ERROR: A GosaGroupOfNames with cn '$ogroup' was not found in base '".$main::ldap_base."'!", 1);
867 $main::job_db->exec_statement("UPDATE ".$main::job_queue_tn." SET status = 'waiting' WHERE id = $jobdb_id");
868 $main::job_db->exec_statement("UPDATE ".$main::job_queue_tn." SET timestamp = '".(&calc_timestamp(&get_time(), 'plus', 10))."' WHERE id = $jobdb_id");
869 return undef;
870 } else {
871 &main::daemon_log("$session_id ERROR: More than one ObjectGroups with cn '$ogroup' was found in base '".$main::ldap_base."'!", 1);
872 $main::job_db->exec_statement("UPDATE ".$main::job_queue_tn." SET status = 'waiting' WHERE id = $jobdb_id");
873 $main::job_db->exec_statement("UPDATE ".$main::job_queue_tn." SET timestamp = '".(&calc_timestamp(&get_time(), 'plus', 10))."' WHERE id = $jobdb_id");
874 return undef;
875 }
877 # build the base, use optional base parameter or take it from ogroup
878 if(!(defined($base) && (length($base) > 0))) {
879 # Subtract the ObjectGroup cn
880 $base = $1 if $ogroup_entry->dn =~ /cn=$ogroup,ou=groups,(.*)$/;
881 &main::daemon_log("$session_id DEBUG: New base for system with mac address '$mac' is '$base'", 5);
882 }
883 }
885 # prepend ou=systems (configurable through config)
886 $base = $main::new_systems_ou.",".$base;
888 # Search for an existing entry (should be in ou=incoming)
889 my $ldap_mesg= $ldap_handle->search(
890 base => $main::ldap_base,
891 scope => 'sub',
892 filter => "(&(objectClass=GOhard)(|(macAddress=$mac)(dhcpHWaddress=$mac)))",
893 );
895 # TODO: Find a way to guess an ip address for hosts with no ldap entry (MAC->ARP->IP)
896 if($ldap_mesg->count == 1) {
897 &main::daemon_log("$session_id DEBUG: One system with mac address '$mac' was found in base '".$main::ldap_base."'!", 5);
898 # Get the entry from LDAP
899 $ldap_entry= $ldap_mesg->pop_entry();
901 if(!($ldap_entry->dn() eq "cn=".$ldap_entry->get_value('cn').",$base")) {
902 # Move the entry to the new ou
903 $ldap_entry->changetype('moddn');
904 $ldap_entry->add(
905 newrdn => "cn=".$ldap_entry->get_value('cn'),
906 deleteoldrdn => 1,
907 newsuperior => $base,
908 );
909 # To prevent replication problems just re-queue the job with 10 seconds in the future
910 my $moddn_result = $ldap_entry->update($ldap_handle);
911 if ($moddn_result->code() != 0) {
912 my $error_string = "Moving the system with mac address '$mac' to new base '$base' failed (code '".$moddn_result->code()."') with '".$moddn_result->{'errorMessage'}."'!";
913 &main::daemon_log("$session_id ERROR: $error_string", 1);
914 my $sql = "UPDATE $main::job_queue_tn SET status='error', result='$error_string' WHERE id=$jobdb_id";
915 return undef;
916 } else {
917 &main::daemon_log("$session_id INFO: System with mac address '$mac' was moved to base '".$main::ldap_base."'! Re-queuing job.", 4);
918 $main::job_db->exec_statement("UPDATE ".$main::job_queue_tn." SET status = 'waiting', timestamp = '".(&calc_timestamp(&get_time(), 'plus', 10))."' WHERE id = $jobdb_id");
919 return undef;
920 }
921 }
923 } elsif ($ldap_mesg->count == 0) {
924 &main::daemon_log("$session_id WARNING: No System with mac address '$mac' was found in base '".$main::ldap_base."'! Re-queuing job.", 4);
925 my $sql_statement = "UPDATE ".$main::job_queue_tn.
926 " SET status='waiting', timestamp = '".(&calc_timestamp(&get_time(), 'plus', 60))."' ".
927 " WHERE id = $jobdb_id";
928 $main::job_db->exec_statement($sql_statement);
929 return undef;
930 }
932 $ldap_mesg= $ldap_handle->search(
933 base => $main::ldap_base,
934 scope => 'sub',
935 filter => "(&(objectClass=GOhard)(|(macAddress=$mac)(dhcpHWaddress=$mac)))",
936 );
938 # TODO: Find a way to guess an ip address for hosts with no ldap entry (MAC->ARP->IP)
939 if($ldap_mesg->count == 1) {
940 $ldap_entry= $ldap_mesg->pop_entry();
941 # Check for needed objectClasses
942 my $oclasses = $ldap_entry->get_value('objectClass', asref => 1);
943 foreach my $oclass ("FAIobject", "GOhard", "gotoWorkstation") {
944 if(!(scalar grep $_ eq $oclass, map {$_ => 1} @$oclasses)) {
945 &main::daemon_log("$session_id INFO: Adding objectClass '$oclass' to system entry with mac adress '$mac'", 1);
946 $ldap_entry->add(
947 objectClass => $oclass,
948 );
949 my $oclass_result = $ldap_entry->update($ldap_handle);
950 if ($oclass_result->code() != 0) {
951 &main::daemon_log("$session_id ERROR: Adding the ObjectClass '$oclass' failed (code '".$oclass_result->code()."') with '".$oclass_result->{'errorMessage'}."'!", 1);
952 } else {
953 &main::daemon_log("$session_id DEBUG: Adding the ObjectClass '$oclass' to '".($ldap_entry->dn())."' succeeded!", 5);
954 }
955 }
956 }
958 # Set FAIstate
959 if(defined($ldap_entry->get_value('FAIstate'))) {
960 if(!($ldap_entry->get_value('FAIstate') eq 'install')) {
961 $ldap_entry->replace(
962 'FAIstate' => 'install'
963 );
964 my $replace_result = $ldap_entry->update($ldap_handle);
965 if ($replace_result->code() != 0) {
966 &main::daemon_log("$session_id ERROR: Setting the FAIstate to install failed with code '".$replace_result->code()."') and message '".$replace_result->{'errorMessage'}."'!", 1);
967 } else {
968 &main::daemon_log("$session_id DEBUG: Setting the FAIstate to install for '".($ldap_entry->dn())."' succeeded!", 5);
969 }
970 }
971 } else {
972 $ldap_entry->add(
973 'FAIstate' => 'install'
974 );
975 my $add_result = $ldap_entry->update($ldap_handle);
976 if ($add_result->code() != 0) {
977 &main::daemon_log("$session_id ERROR: Setting the FAIstate to install failed with code '".$add_result->code()."') and message '".$add_result->{'errorMessage'}."'!", 1);
978 } else {
979 &main::daemon_log("$session_id DEBUG: Setting the FAIstate to install for '".($ldap_entry->dn())."' succeeded!", 5);
980 }
981 }
984 } elsif ($ldap_mesg->count == 0) {
985 # TODO: Create a new entry
986 # $ldap_entry = Net::LDAP::Entry->new();
987 # $ldap_entry->dn("cn=$mac,$base");
988 &main::daemon_log("$session_id WARNING: No System with mac address '$mac' was found in base '".$main::ldap_base."'! Re-queuing job.", 4);
989 $main::job_db->exec_statement("UPDATE ".$main::job_queue_tn." SET status = 'waiting', timestamp = '".(&calc_timestamp(&get_time(), 'plus', 60))."' WHERE id = $jobdb_id");
990 return undef;
991 } else {
992 &main::daemon_log("$session_id ERROR: More than one system with mac address '$mac' was found in base '".$main::ldap_base."'!", 1);
993 }
995 # Add to ObjectGroup
996 my $ogroup_member = $ogroup_entry->get_value('member', asref => 1);
997 if( (!defined($ogroup_member)) ||
998 (!defined($ldap_entry)) ||
999 (!defined($ldap_entry->dn)) ||
1000 (!(scalar grep $_ eq $ldap_entry->dn, @{$ogroup_member}))) {
1001 $ogroup_entry->add (
1002 'member' => $ldap_entry->dn(),
1003 );
1004 my $ogroup_result = $ogroup_entry->update($ldap_handle);
1005 if ($ogroup_result->code() != 0) {
1006 &main::daemon_log("$session_id ERROR: Updating the ObjectGroup '$ogroup' failed (code '".$ogroup_result->code()."') with '".$ogroup_result->{'errorMessage'}."'!", 1);
1007 } else {
1008 &main::daemon_log("$session_id DEBUG: Updating the ObjectGroup '$ogroup' for member '".($ldap_entry->dn())."' succeeded!", 5);
1009 }
1010 } else {
1011 &main::daemon_log("$session_id DEBUG: System with mac address '$mac' is already a member of ObjectGroup '$ogroup'.", 5);
1012 }
1014 # Finally set gotoMode to active
1015 if(defined($ldap_entry->get_value('gotoMode'))) {
1016 if(!($ldap_entry->get_value('gotoMode') eq 'active')) {
1017 $ldap_entry->replace(
1018 'gotoMode' => 'active'
1019 );
1020 my $activate_result = $ldap_entry->update($ldap_handle);
1021 if ($activate_result->code() != 0) {
1022 &main::daemon_log("$session_id ERROR: Activating system '".$ldap_entry->dn()."' failed (code '".$activate_result->code()."') with '".$activate_result->{'errorMessage'}."'!", 1);
1023 } else {
1024 &main::daemon_log("$session_id DEBUG: Activating system '".$ldap_entry->dn()."' succeeded!", 5);
1025 $activate_client = 1;
1026 }
1027 } else {
1028 $activate_client = 1;
1029 }
1030 } else {
1031 $ldap_entry->add(
1032 'gotoMode' => 'active'
1033 );
1034 my $activate_result = $ldap_entry->update($ldap_handle);
1035 if ($activate_result->code() != 0) {
1036 &main::daemon_log("$session_id ERROR: Activating system '".$ldap_entry->dn()."' failed (code '".$activate_result->code()."') with '".$activate_result->{'errorMessage'}."'!", 1);
1037 } else {
1038 &main::daemon_log("$session_id DEBUG: Activating system '".$ldap_entry->dn()."' succeeded!", 5);
1039 $activate_client = 1;
1040 }
1041 }
1043 if($activate_client == 1) {
1044 &main::daemon_log("$session_id DEBIG: Activating system with mac address '$mac'!", 5);
1046 # Create delivery list
1047 my @out_msg_l;
1049 # Set job to done
1050 $main::job_db->exec_statement("UPDATE jobs SET status = 'done' WHERE id = $jobdb_id");
1052 # create set_activated_for_installation message for delivery
1053 my $out_hash = &create_xml_hash("set_activated_for_installation", $source, $target);
1054 my $out_msg = &create_xml_string($out_hash);
1055 push(@out_msg_l, $out_msg);
1057 # Return delivery list of messages
1058 return @out_msg_l;
1060 } else {
1061 &main::daemon_log("$session_id WARNING: Activating system with mac address '$mac' failed! Re-queuing job.", 4);
1062 $main::job_db->exec_statement("UPDATE ".$main::job_queue_tn." SET status = 'waiting', timestamp = '".(&calc_timestamp(&get_time(), 'plus', 60))."' WHERE id = $jobdb_id");
1063 }
1064 return undef;
1065 }
1068 #sub get_dak_keyring {
1069 # my ($msg, $msg_hash) = @_;
1070 # my $source = @{$msg_hash->{'source'}}[0];
1071 # my $target = @{$msg_hash->{'target'}}[0];
1072 # my $header= @{$msg_hash->{'header'}}[0];
1073 # my $session_id = @{$msg_hash->{'session_id'}}[0];
1074 #
1075 # # build return message with twisted target and source
1076 # my $out_hash = &main::create_xml_hash("answer_$header", $target, $source);
1077 # &add_content2xml_hash($out_hash, "session_id", $session_id);
1078 #
1079 # my @keys;
1080 # my %data;
1081 #
1082 # my $keyring = $main::dak_signing_keys_directory."/keyring.gpg";
1083 #
1084 # my $gpg_cmd = `which gpg`; chomp $gpg_cmd;
1085 # my $gpg = "$gpg_cmd --no-default-keyring --no-random-seed --keyring $keyring";
1086 #
1087 # # Check if the keyrings are in place and readable
1088 # if(
1089 # &run_as($main::dak_user, "test -r $keyring")->{'resultCode'} != 0
1090 # ) {
1091 # &add_content2xml_hash($out_hash, "error", "DAK Keyring is not readable");
1092 # } else {
1093 # my $command = "$gpg --list-keys";
1094 # my $output = &run_as($main::dak_user, $command);
1095 # &main::daemon_log("$session_id DEBUG: ".$output->{'command'}, 7);
1096 #
1097 # my $i=0;
1098 # foreach (@{$output->{'output'}}) {
1099 # if ($_ =~ m/^pub\s.*$/) {
1100 # ($keys[$i]->{'pub'}->{'length'}, $keys[$i]->{'pub'}->{'uid'}, $keys[$i]->{'pub'}->{'created'}) = ($1, $2, $3)
1101 # if $_ =~ m/^pub\s*?(\w*?)\/(\w*?)\s(\d{4}-\d{2}-\d{2})/;
1102 # $keys[$i]->{'pub'}->{'expires'} = $1 if $_ =~ m/^pub\s*?\w*?\/\w*?\s\d{4}-\d{2}-\d{2}\s\[expires:\s(\d{4}-\d{2}-\d{2})\]/;
1103 # $keys[$i]->{'pub'}->{'expired'} = $1 if $_ =~ m/^pub\s*?\w*?\/\w*?\s\d{4}-\d{2}-\d{2}\s\[expired:\s(\d{4}-\d{2}-\d{2})\]/;
1104 # } elsif ($_ =~ m/^sub\s.*$/) {
1105 # ($keys[$i]->{'sub'}->{'length'}, $keys[$i]->{'sub'}->{'uid'}, $keys[$i]->{'sub'}->{'created'}) = ($1, $2, $3)
1106 # if $_ =~ m/^sub\s*?(\w*?)\/(\w*?)\s(\d{4}-\d{2}-\d{2})/;
1107 # $keys[$i]->{'sub'}->{'expires'} = $1 if $_ =~ m/^pub\s*?\w*?\/\w*?\s\d{4}-\d{2}-\d{2}\s\[expires:\s(\d{4}-\d{2}-\d{2})\]/;
1108 # $keys[$i]->{'sub'}->{'expired'} = $1 if $_ =~ m/^pub\s*?\w*?\/\w*?\s\d{4}-\d{2}-\d{2}\s\[expired:\s(\d{4}-\d{2}-\d{2})\]/;
1109 # } elsif ($_ =~ m/^uid\s.*$/) {
1110 # push @{$keys[$i]->{'uid'}}, $1 if $_ =~ m/^uid\s*?([^\s].*?)$/;
1111 # } elsif ($_ =~ m/^$/) {
1112 # $i++;
1113 # }
1114 # }
1115 # }
1116 #
1117 # my $i=0;
1118 # foreach my $key (@keys) {
1119 # # &main::daemon_log(Dumper($key));
1120 # &add_content2xml_hash($out_hash, "answer".$i++, $key);
1121 # }
1122 # my $forward_to_gosa = @{$msg_hash->{'forward_to_gosa'}}[0];
1123 # if (defined $forward_to_gosa) {
1124 # &add_content2xml_hash($out_hash, "forward_to_gosa", $forward_to_gosa);
1125 # }
1126 # return &create_xml_string($out_hash);
1127 #}
1128 #
1129 #
1130 #sub import_dak_key {
1131 # my ($msg, $msg_hash) = @_;
1132 # my $source = @{$msg_hash->{'source'}}[0];
1133 # my $target = @{$msg_hash->{'target'}}[0];
1134 # my $header= @{$msg_hash->{'header'}}[0];
1135 # my $session_id = @{$msg_hash->{'session_id'}}[0];
1136 # my $key = &decode_base64(@{$msg_hash->{'key'}}[0]);
1137 #
1138 # # build return message with twisted target and source
1139 # my $out_hash = &main::create_xml_hash("answer_$header", $target, $source);
1140 # &add_content2xml_hash($out_hash, "session_id", $session_id);
1141 #
1142 # my %data;
1143 #
1144 # my $keyring = $main::dak_signing_keys_directory."/keyring.gpg";
1145 #
1146 # my $gpg_cmd = `which gpg`; chomp $gpg_cmd;
1147 # my $gpg = "$gpg_cmd --no-default-keyring --no-random-seed --keyring $keyring";
1148 #
1149 # # Check if the keyrings are in place and writable
1150 # if(
1151 # &run_as($main::dak_user, "test -w $keyring")->{'resultCode'} != 0
1152 # ) {
1153 # &add_content2xml_hash($out_hash, "error", "DAK Keyring is not writable");
1154 # } else {
1155 # my $keyfile;
1156 # open($keyfile, ">/tmp/gosa_si_tmp_dak_key");
1157 # print $keyfile $key;
1158 # close($keyfile);
1159 # my $command = "$gpg --import /tmp/gosa_si_tmp_dak_key";
1160 # my $output = &run_as($main::dak_user, $command);
1161 # &main::daemon_log("$session_id DEBUG: ".$output->{'command'}, 7);
1162 # unlink("/tmp/gosa_si_tmp_dak_key");
1163 #
1164 # if($output->{'resultCode'} != 0) {
1165 # &add_content2xml_hash($out_hash, "error", "Import of DAK key failed! Output was '".$output->{'output'}."'");
1166 # } else {
1167 # &add_content2xml_hash($out_hash, "answer", "Import of DAK key successfull! Output was '".$output->{'output'}."'");
1168 # }
1169 # }
1170 #
1171 # my $forward_to_gosa = @{$msg_hash->{'forward_to_gosa'}}[0];
1172 # if (defined $forward_to_gosa) {
1173 # &add_content2xml_hash($out_hash, "forward_to_gosa", $forward_to_gosa);
1174 # }
1175 # return &create_xml_string($out_hash);
1176 #}
1177 #
1178 #
1179 #sub remove_dak_key {
1180 # my ($msg, $msg_hash) = @_;
1181 # my $source = @{$msg_hash->{'source'}}[0];
1182 # my $target = @{$msg_hash->{'target'}}[0];
1183 # my $header= @{$msg_hash->{'header'}}[0];
1184 # my $session_id = @{$msg_hash->{'session_id'}}[0];
1185 # my $key = @{$msg_hash->{'keyid'}}[0];
1186 # # build return message with twisted target and source
1187 # my $out_hash = &main::create_xml_hash("answer_$header", $target, $source);
1188 # &add_content2xml_hash($out_hash, "session_id", $session_id);
1189 #
1190 # my %data;
1191 #
1192 # my $keyring = $main::dak_signing_keys_directory."/keyring.gpg";
1193 #
1194 # my $gpg_cmd = `which gpg`; chomp $gpg_cmd;
1195 # my $gpg = "$gpg_cmd --no-default-keyring --no-random-seed --homedir ".$main::dak_signing_keys_directory." --keyring $keyring";
1196 #
1197 # # Check if the keyrings are in place and writable
1198 # if(
1199 # &run_as($main::dak_user, "test -w $keyring")->{'resultCode'} != 0
1200 # ) {
1201 # &add_content2xml_hash($out_hash, "error", "DAK keyring is not writable");
1202 # } else {
1203 # # Check if the key is present in the keyring
1204 # if(&run_as($main::dak_user, "$gpg --list-keys $key")->{'resultCode'} == 0) {
1205 # my $command = "$gpg --batch --yes --delete-key $key";
1206 # my $output = &run_as($main::dak_user, $command);
1207 # &main::daemon_log("$session_id DEBUG: ".$output->{'command'}, 7);
1208 # } else {
1209 # &add_content2xml_hash($out_hash, "error", "DAK key with id '$key' was not found in keyring");
1210 # }
1211 # }
1212 #
1213 # my $forward_to_gosa = @{$msg_hash->{'forward_to_gosa'}}[0];
1214 # if (defined $forward_to_gosa) {
1215 # &add_content2xml_hash($out_hash, "forward_to_gosa", $forward_to_gosa);
1216 # }
1217 # return &create_xml_string($out_hash);
1218 #}
1221 #sub get_dak_queue {
1222 # my ($msg, $msg_hash, $session_id) = @_;
1223 # my %data;
1224 # my $source = @{$msg_hash->{'source'}}[0];
1225 # my $target = @{$msg_hash->{'target'}}[0];
1226 # my $header= @{$msg_hash->{'header'}}[0];
1227 #
1228 # my %data;
1229 #
1230 # foreach my $dir ("unchecked", "new", "accepted") {
1231 # foreach my $file(<"$main::dak_queue_directory/$dir/*.changes">) {
1232 # }
1233 # }
1234 #
1235 # my $out_msg = &build_msg("get_dak_queue", $target, $source, \%data);
1236 # my @out_msg_l = ($out_msg);
1237 # return @out_msg_l;
1238 #}
1240 ## @method get_hosts_with_module
1241 # Reports all GOsa-si-server providing the given module.
1242 # @param msg - STRING - xml message with tag get_hosts_with_module
1243 # @param msg_hash - HASHREF - message information parsed into a hash
1244 # @param session_id - INTEGER - POE session id of the processing of this message
1245 # @return out_msg - STRING - feedback to GOsa in success and error case
1246 sub get_hosts_with_module {
1247 my ($msg, $msg_hash, $session_id) = @_;
1248 my $source = @{$msg_hash->{'source'}}[0];
1249 my $target = @{$msg_hash->{'target'}}[0];
1250 my $header= @{$msg_hash->{'header'}}[0];
1251 my $module_name = @{$msg_hash->{'module_name'}}[0];
1252 my $out_hash = &create_xml_hash($header, $target, $source);
1254 # Sanity check of module_name
1255 if ((not exists $msg_hash->{'module_name'}) || (@{$msg_hash->{'module_name'}} != 1)) {
1256 &add_content2xml_hash($out_hash, "error_string", "no module_name specified or module_name tag invalid");
1257 &add_content2xml_hash($out_hash, "error", "module_name");
1258 &main::daemon_log("$session_id ERROR: no module_name specified or module_name tag invalid: $msg", 1);
1259 return (&create_xml_string($out_hash));
1260 }
1262 my $out_msg = &create_xml_string($out_hash);
1264 # Check localhost for module_name
1265 if (exists @{$main::known_modules->{'GosaPackages'}}[2]->{$module_name}) {
1266 my ($local_ip, $local_port) = split(/:/, $target);
1267 my $network_interface= &get_interface_for_ip($local_ip);
1268 my $local_mac = &get_mac_for_interface($network_interface);
1269 $out_msg =~ s/<\/xml>/<result>host0<\/result> <\/xml>/;
1270 my $host_infos = "<ip>$local_ip</ip>";
1271 $host_infos .= " <mac>$local_mac</mac>";
1272 $out_msg =~ s/<\/xml>/\n<answer0> $host_infos <\/answer0> \n <\/xml>/;
1273 }
1275 # Search for opsi hosts in server_db
1276 my $sql = "SELECT * FROM $main::known_server_tn WHERE loaded_modules LIKE '%$module_name%'";
1277 my $res = $main::known_server_db->select_dbentry($sql);
1278 while (my ($hit_id, $hit_hash) = each %$res) {
1279 $out_msg =~ s/<\/xml>/<result>host$hit_id<\/result> <\/xml>/;
1280 my $host_infos = "<ip>".$hit_hash->{'hostname'}."</ip>";
1281 $host_infos .= " <mac>".$hit_hash->{'macaddress'}."</mac>";
1282 $out_msg =~ s/<\/xml>/\n<answer$hit_id> $host_infos <\/answer$hit_id> \n <\/xml>/;
1283 }
1285 return $out_msg;
1286 }
1288 # vim:ts=4:shiftwidth:expandtab
1289 1;