minor fixes

pandora_console/godmode/wizards/HostDevices.class.php

@@ -58,7 +58,6 @@ class HostDevices extends Wizard
     public $pageLabelsNetScan = [
         'NetScan definition',
         'NetScan features',
-
     ];
 
     /**
@@ -269,6 +268,8 @@ class HostDevices extends Wizard
      */
     public function parseNetScan()
     {
+        global $config;
+
         if ($this->page == 0) {
             // Check if we're updating a task.
             $task_id = get_parameter('task', null);
@@ -333,18 +334,14 @@ class HostDevices extends Wizard
             if ($task_id !== null
                 && $taskname == null
                 && $server_id == null
-                && $id_group == null
+                && empty($id_group) === true
-                && $server == null
+                && empty($network) === true
-                && $datacenter == ''
+                && $interval === 0
-                && $user == ''
-                && $pass == ''
-                && $encrypt == null
-                && $interval == 0
             ) {
                 // Default values, no data received.
                 // User is accesing directly to this page.
                 if (check_acl(
-                    $config['id_usuario'],
+                    $config['id_user'],
                     $this->task['id_group'],
                     $this->access
                 ) != true
@@ -562,7 +559,7 @@ class HostDevices extends Wizard
             // Check ACL. If user is not able to manage target task,
             // redirect him to main page.
             if (check_acl(
-                $config['id_usuario'],
+                $config['id_user'],
                 $this->task['id_group'],
                 $this->access
             ) != true
@@ -878,7 +875,9 @@ class HostDevices extends Wizard
             ];
 
             $form['inputs'][] = [
-                'extra' => '<p><h3>Please, configure task <b>'.io_safe_output($this->task['name']).'</b></h3></p>',
+                'extra' => '<p><h3>Please, configure task <b>'.io_safe_output(
+                    $this->task['name']
+                ).'</b></h3></p>',
             ];
 
             $form['inputs'][] = [
@@ -893,6 +892,7 @@ class HostDevices extends Wizard
                     'selected'      => $this->task['id_network_profile'],
                     'nothing_value' => 0,
                     'nothing'       => __('None'),
+                    'multiple'      => true,
                 ],
             ];
 

pandora_console/godmode/wizards/Wizard.main.php

@@ -41,7 +41,7 @@ class Wizard
     /**
      * Breadcrum
      *
-     * @var array.
+     * @var array
      */
     public $breadcrum;
 

pandora_server/lib/PandoraFMS/Recon/Base.pm

@@ -98,9 +98,9 @@ our @EXPORT = qw(
   $SYSUPTIME
 );
 
-#######################################################################
+################################################################################
 # Create a new ReconTask object.
-#######################################################################
+################################################################################
 sub new {
 	my $class = shift;
 
@@ -289,18 +289,18 @@ sub new {
 	return $self;
 }
 
-########################################################################################
+################################################################################
 # Add an address to a device.
-########################################################################################
+################################################################################
 sub add_addresses($$$) {
 	my ($self, $device, $ip_address) = @_;
 
 	$self->{'visited_devices'}->{$device}->{'addr'}->{$ip_address} = '';
 }
 
-########################################################################################
+################################################################################
 # Add a MAC/IP address to the ARP cache.
-########################################################################################
+################################################################################
 sub add_mac($$$) {
 	my ($self, $mac, $ip_addr) = @_;
 
@@ -308,9 +308,9 @@ sub add_mac($$$) {
 	$self->{'arp_cache'}->{$mac} = $ip_addr;
 }
 
-########################################################################################
+################################################################################
 # Add an interface/MAC to the interface cache.
-########################################################################################
+################################################################################
 sub add_iface($$$) {
 	my ($self, $iface, $mac) = @_;
 
@@ -318,9 +318,9 @@ sub add_iface($$$) {
 	$self->{'ifaces'}->{$mac} = $iface;
 }
 
-########################################################################################
+################################################################################
 # Discover connectivity from address forwarding tables.
-########################################################################################
+################################################################################
 sub aft_connectivity($$) {
 	my ($self, $switch) = @_;
 	my (%mac_temp, @aft_temp);
@@ -367,9 +367,9 @@ sub aft_connectivity($$) {
 }
 
 
-########################################################################################
+################################################################################
 # Return 1 if the given devices are connected to each other, 0 otherwise.
-########################################################################################
+################################################################################
 sub are_connected($$$$$) {
 	my ($self, $dev_1, $if_1, $dev_2, $if_2) = @_;
 
@@ -389,9 +389,9 @@ sub are_connected($$$$$) {
 	return 0;
 }
 
-########################################################################################
+################################################################################
 # Discover as much information as possible from the given device using SNMP.
-########################################################################################
+################################################################################
 sub snmp_discovery($$) {
 	my ($self, $device) = @_;
 
@@ -434,9 +434,9 @@ sub snmp_discovery($$) {
 	$self->call('create_agent', $device);
 }
 
-#######################################################################
+################################################################################
 # Try to call the given function on the given object.
-#######################################################################
+################################################################################
 sub call {
 	my $self = shift;
 	my $func = shift;
@@ -447,18 +447,18 @@ sub call {
 	}
 }
 
-########################################################################################
+################################################################################
 # Disable the VLAN cache.
-########################################################################################
+################################################################################
 sub disable_vlan_cache($$) {
 	my ($self, $device) = @_;
 
 	$self->{'__vlan_cache_enabled__'} = 0;
 }
 
-########################################################################################
+################################################################################
 # Enable the VLAN cache.
-########################################################################################
+################################################################################
 sub enable_vlan_cache($$) {
 	my ($self, $device) = @_;
 
@@ -466,9 +466,9 @@ sub enable_vlan_cache($$) {
 	$self->{'__vlan_cache_enabled__'} = 1;
 }
 
-##########################################################################
+################################################################################
 # Connect the given hosts to its gateway.
-##########################################################################
+################################################################################
 sub gateway_connectivity($$) {
 	my ($self, $host) = @_;
 
@@ -486,9 +486,9 @@ sub gateway_connectivity($$) {
 	$self->mark_connected($gw, '', $host, '');
 }
 
-########################################################################################
+################################################################################
 # Find IP address aliases for the given device.
-########################################################################################
+################################################################################
 sub find_aliases($$) {
 	my ($self, $device) = @_;
 
@@ -518,9 +518,9 @@ sub find_aliases($$) {
 	}
 }
 
-########################################################################################
+################################################################################
 # Find all the interfaces for the given host.
-########################################################################################
+################################################################################
 sub find_ifaces($$) {
 	my ($self, $device) = @_;
 
@@ -553,9 +553,9 @@ sub find_ifaces($$) {
 	}
 }
 
-########################################################################################
+################################################################################
 # Find the device's VLANs and fill the VLAN cache.
-########################################################################################
+################################################################################
 sub find_vlans ($$) {
 	my ($self, $device) = @_;
 	my %vlan_hash;
@@ -570,9 +570,9 @@ sub find_vlans ($$) {
 	push(@{$self->{'vlan_cache'}->{$device}}, @vlans) if (scalar(@vlans) > 0);
 }
 
-########################################################################################
+################################################################################
 # Return the addresses of the given device as an array.
-########################################################################################
+################################################################################
 sub get_addresses($$) {
 	my ($self, $device) = @_;
 
@@ -584,9 +584,9 @@ sub get_addresses($$) {
 	return ($device);
 }
 
-########################################################################################
+################################################################################
 # Return a device structure from an IP address.
-########################################################################################
+################################################################################
 sub get_device($$) {
 	my ($self, $addr) = @_;
 
@@ -597,9 +597,9 @@ sub get_device($$) {
 	return undef;
 }
 
-########################################################################################
+################################################################################
 # Get the SNMP community of the given device. Returns undef if no community was found.
-########################################################################################
+################################################################################
 sub get_community($$) {
 	my ($self, $device) = @_;
 
@@ -612,27 +612,27 @@ sub get_community($$) {
 	return '';
 }
 
-########################################################################################
+################################################################################
 # Return the connection hash.
-########################################################################################
+################################################################################
 sub get_connections($) {
 	my ($self) = @_;
 
 	return $self->{'connections'};
 }
 
-########################################################################################
+################################################################################
 # Return the parent relationship hash.
-########################################################################################
+################################################################################
 sub get_parents($) {
 	my ($self) = @_;
 
 	return $self->{'parents'};
 }
 
-########################################################################################
+################################################################################
 # Get the type of the given device.
-########################################################################################
+################################################################################
 sub get_device_type($$) {
 	my ($self, $device) = @_;
 
@@ -644,18 +644,18 @@ sub get_device_type($$) {
 	return 'host';
 }
 
-########################################################################################
+################################################################################
 # Return all known hosts that are not switches or routers.
-########################################################################################
+################################################################################
 sub get_hosts($) {
 	my ($self) = @_;
 
 	return $self->{'hosts'};
 }
 
-########################################################################################
+################################################################################
 # Add an interface/MAC to the interface cache.
-########################################################################################
+################################################################################
 sub get_iface($$) {
 	my ($self, $mac) = @_;
 
@@ -664,9 +664,9 @@ sub get_iface($$) {
 	return $self->{'ifaces'}->{$mac};
 }
 
-########################################################################################
+################################################################################
 # Get an interface name from an AFT entry. Returns undef on error.
-########################################################################################
+################################################################################
 sub get_if_from_aft($$$) {
 	my ($self, $switch, $mac) = @_;
 
@@ -687,9 +687,9 @@ sub get_if_from_aft($$$) {
 
 }
 
-########################################################################################
+################################################################################
 # Get an interface name from an IP address.
-########################################################################################
+################################################################################
 sub get_if_from_ip($$$) {
 	my ($self, $device, $ip_addr) = @_;
 
@@ -705,9 +705,9 @@ sub get_if_from_ip($$$) {
 	return $if_name;
 }
 
-########################################################################################
+################################################################################
 # Get an interface name from a MAC address.
-########################################################################################
+################################################################################
 sub get_if_from_mac($$$) {
 	my ($self, $device, $mac) = @_;
 
@@ -735,9 +735,9 @@ sub get_if_from_mac($$$) {
 	return '';
 }
 
-########################################################################################
+################################################################################
 # Get an interface name from a port number. Returns '' on error.
-########################################################################################
+################################################################################
 sub get_if_from_port($$$) {
 	my ($self, $switch, $port) = @_;
 
@@ -753,9 +753,9 @@ sub get_if_from_port($$$) {
 	return $if_name;
 }
 
-########################################################################################
+################################################################################
 # Returns the IP address of the given interface (by index).
-########################################################################################
+################################################################################
 sub get_if_ip($$$) {
 	my ($self, $device, $if_index) = @_;
 
@@ -768,9 +768,9 @@ sub get_if_ip($$$) {
 	return '';
 }
 
-########################################################################################
+################################################################################
 # Returns the MAC address of the given interface (by index).
-########################################################################################
+################################################################################
 sub get_if_mac($$$) {
 	my ($self, $device, $if_index) = @_;
 
@@ -783,9 +783,9 @@ sub get_if_mac($$$) {
 	return $mac;
 }
 
-########################################################################################
+################################################################################
 # Returns the type of the given interface (by index).
-########################################################################################
+################################################################################
 sub get_if_type($$$) {
 	my ($self, $device, $if_index) = @_;
 
@@ -795,9 +795,9 @@ sub get_if_type($$$) {
 	return $type;
 }
 
-########################################################################################
+################################################################################
 # Get an IP address from the ARP cache given the MAC address.
-########################################################################################
+################################################################################
 sub get_ip_from_mac($$) {
 	my ($self, $mac_addr) = @_;
 
@@ -808,9 +808,9 @@ sub get_ip_from_mac($$) {
 	return undef;
 }
 
-########################################################################################
+################################################################################
 # Attemtps to find
-########################################################################################
+################################################################################
 sub get_mac_from_ip($$) {
 	my ($self, $host) = @_;
 	my $mac = undef;
@@ -830,9 +830,9 @@ sub get_mac_from_ip($$) {
 	$self->call('message', "Found MAC $mac for host $host in the local ARP cache.", 5);
 }
 
-########################################################################################
+################################################################################
 # Get a port number from an AFT entry. Returns undef on error.
-########################################################################################
+################################################################################
 sub get_port_from_aft($$$) {
 	my ($self, $switch, $mac) = @_;
 
@@ -843,9 +843,9 @@ sub get_port_from_aft($$$) {
 	return $port;
 }
 
-########################################################################################
+################################################################################
 # Fill the route cache.
-########################################################################################
+################################################################################
 sub get_routes($) {
 	my ($self) = @_;
 
@@ -870,9 +870,9 @@ sub get_routes($) {
 	}
 }
 
-########################################################################################
+################################################################################
 # Get the gateway to reach the given host.
-########################################################################################
+################################################################################
 sub get_gateway($) {
 	my ($self, $host) = @_;
 
@@ -890,29 +890,29 @@ sub get_gateway($) {
 	return undef;
 }
 
-########################################################################################
+################################################################################
 # Return a pointer to an array containing configured subnets.
-########################################################################################
+################################################################################
 sub get_subnets($) {
 	my ($self) = @_;
 
 	return $self->{'subnets'};
 }
 
-########################################################################################
+################################################################################
 # Get an array of all the visited devices.
 # NOTE: This functions returns the whole device structures, not just address
 # like get_hosts, get_switches, get_routers and get_all_devices.
-########################################################################################
+################################################################################
 sub get_visited_devices($) {
 	my ($self) = @_;
 
 	return $self->{'visited_devices'};
 }
 
-########################################################################################
+################################################################################
 # Returns an array of found VLAN IDs.
-########################################################################################
+################################################################################
 sub get_vlans($$) {
 	my ($self, $device) = @_;
 
@@ -927,9 +927,9 @@ sub get_vlans($$) {
 	return @{$self->{'vlan_cache'}->{$device}};
 }
 
-########################################################################################
+################################################################################
 # Guess the type of the given device.
-########################################################################################
+################################################################################
 sub guess_device_type($$) {
 	my ($self, $device) = @_;
 
@@ -1004,9 +1004,9 @@ sub guess_device_type($$) {
 	$self->set_device_type($device, $device_type);
 }
 
-########################################################################################
+################################################################################
 # Return 1 if the given device has children.
-########################################################################################
+################################################################################
 sub has_children($$) {
 	my ($self, $device) = @_;
 
@@ -1018,9 +1018,9 @@ sub has_children($$) {
 	return 0;
 }
 
-########################################################################################
+################################################################################
 # Return 1 if the given device has a parent.
-########################################################################################
+################################################################################
 sub has_parent($$) {
 	my ($self, $device) = @_;
 
@@ -1032,9 +1032,9 @@ sub has_parent($$) {
 	return 0;
 }
 
-########################################################################################
+################################################################################
 # Returns 1 if the device belongs to one of the scanned subnets.
-########################################################################################
+################################################################################
 sub in_subnet($$) {
 	my ($self, $device) = @_;
 	$device = ip_to_long($device);
@@ -1051,10 +1051,10 @@ sub in_subnet($$) {
 	return 0;
 }
 
-##########################################################################
+################################################################################
 # Check for switches that are connected to other switches/routers and show
 # up in a switch/router's port.
-##########################################################################
+################################################################################
 sub is_switch_connected($$$) {
 	my ($self, $device, $iface) = @_;
 
@@ -1066,9 +1066,9 @@ sub is_switch_connected($$$) {
 	return 0;
 }
 
-########################################################################################
+################################################################################
 # Returns 1 if the given device has already been visited, 0 otherwise.
-########################################################################################
+################################################################################
 sub is_visited($$) {
 	my ($self, $device) = @_;
 
@@ -1082,10 +1082,10 @@ sub is_visited($$) {
 	return 0;
 }
 
-########################################################################################
+################################################################################
 # Returns 1 if the given device has responded successfully to a snmp request
 # Returns 0 otherwise.
-########################################################################################
+################################################################################
 sub is_snmp_discovered($$) {
 	my ($self, $device) = @_;
 
@@ -1093,9 +1093,9 @@ sub is_snmp_discovered($$) {
 	return (defined($self->{'discovered_cache'}->{$device})) ? 1 : 0;
 }
 
-########################################################################################
+################################################################################
 # Mark the given devices as connected to each other on the given interfaces.
-########################################################################################
+################################################################################
 sub mark_connected($$;$$$) {
 	my ($self, $parent, $parent_if, $child, $child_if) = @_;
 
@@ -1125,9 +1125,9 @@ sub mark_connected($$;$$$) {
 	}
 }
 
-########################################################################################
+################################################################################
 # Mark the given switch as having a connection on the given interface.
-########################################################################################
+################################################################################
 sub mark_switch_connected($$$) {
 	my ($self, $device, $iface) = @_;
 
@@ -1136,9 +1136,9 @@ sub mark_switch_connected($$$) {
 	$self->{'switch_to_switch'}->{"${device}\t${iface}"} = 1;
 }
 
-########################################################################################
+################################################################################
 # Mark the given device as visited.
-########################################################################################
+################################################################################
 sub mark_visited($$) {
 	my ($self, $device) = @_;
 
@@ -1148,20 +1148,20 @@ sub mark_visited($$) {
 	};
 }
 
-########################################################################################
+################################################################################
 # Mark the given device as snmp discovered.
-########################################################################################
+################################################################################
 sub mark_discovered($$) {
 	my ($self, $device) = @_;
 
 	$self->{'discovered_cache'}->{$device} = 1;
 }
 
-########################################################################################
+################################################################################
 # Validate the configuration for the given device.
 # Returns 1 if successfull snmp contact, 0 otherwise.
 # Updates the SNMP community cache on v1, v2 and v2c.
-########################################################################################
+################################################################################
 sub snmp_responds($$) {
 	my ($self, $device) = @_;
 
@@ -1172,10 +1172,10 @@ sub snmp_responds($$) {
 	  : $self->snmp_responds_v122c($device);
 }
 
-########################################################################################
+################################################################################
 # Looks for a working SNMP community for the given device. Returns 1 if one is
 # found, 0 otherwise. Updates the SNMP community cache.
-########################################################################################
+################################################################################
 sub snmp_responds_v122c($$) {
 	my ($self, $device) = @_;
 
@@ -1197,10 +1197,10 @@ sub snmp_responds_v122c($$) {
 }
 
 
-########################################################################################
+################################################################################
 # Validate the SNMP v3 configuration for a device.
 # Returns 1 if successfull snmp contact, 0 otherwise.
-########################################################################################
+################################################################################
 sub snmp_responds_v3($$) {
 	my ($self, $device) = @_;
 
@@ -1215,9 +1215,9 @@ sub snmp_responds_v3($$) {
 	return 0;
 }
 
-##############################################################################
+################################################################################
 # Parse the local ARP cache.
-##############################################################################
+################################################################################
 sub local_arp($) {
 	my ($self) = @_;
 
@@ -1228,9 +1228,9 @@ sub local_arp($) {
 	}
 }
 
-##############################################################################
+################################################################################
 # Parse remote SNMP ARP caches.
-##############################################################################
+################################################################################
 sub remote_arp($$) {
 	my ($self, $device) = @_;
 
@@ -1263,9 +1263,9 @@ sub remote_arp($$) {
 	}
 }
 
-##############################################################################
+################################################################################
 # Ping the given host. Returns 1 if the host is alive, 0 otherwise.
-##############################################################################
+################################################################################
 sub ping ($$$) {
 	my ($self, $host) = @_;
 	my ($timeout, $retries, $packets) = ($self->{'icmp_timeout'},$self->{'icmp_checks'},1,);
@@ -1332,9 +1332,9 @@ sub ping ($$$) {
 	return 0;
 }
 
-##########################################################################
+################################################################################
 # Scan the given subnet.
-##########################################################################
+################################################################################
 sub scan_subnet($) {
 	my ($self) = @_;
 	my $progress = 1;
@@ -1432,9 +1432,9 @@ sub scan_subnet($) {
 }
 
 
-##########################################################################
+################################################################################
 # Perform a Cloud scan
-##########################################################################
+################################################################################
 sub cloud_scan($) {
 	my $self = shift;
 	my ($progress, $step);
@@ -1483,9 +1483,9 @@ sub cloud_scan($) {
 }
 
 
-##########################################################################
+################################################################################
 # Performs a database scan.
-##########################################################################
+################################################################################
 sub database_scan($$$) {
 	my ($self, $type, $obj, $global_percent, $targets) = @_;
 
@@ -1562,9 +1562,9 @@ sub database_scan($$$) {
 }
 
 
-##########################################################################
+################################################################################
 # Perform an Application scan.
-##########################################################################
+################################################################################
 sub app_scan($) {
 	my ($self) = @_;
 	my ($progress, $step);
@@ -1717,9 +1717,9 @@ sub app_scan($) {
 }
 
 
-##########################################################################
+################################################################################
 # Perform a deployment scan.
-##########################################################################
+################################################################################
 sub deploy_scan($) {
 	my $self = shift;
 	my ($progress, $step);
@@ -1753,9 +1753,9 @@ sub deploy_scan($) {
 }
 
 
-##########################################################################
+################################################################################
 # Perform a network scan.
-##########################################################################
+################################################################################
 sub scan($) {
 	my ($self) = @_;
 	my ($progress, $step) = 1, 0;
@@ -1854,27 +1854,27 @@ sub scan($) {
 	}
 }
 
-########################################################################################
+################################################################################
 # Set an SNMP community for the given device.
-########################################################################################
+################################################################################
 sub set_community($$$) {
 	my ($self, $device, $community) = @_;
 
 	$self->{'community_cache'}->{$device} = $community;
 }
 
-########################################################################################
+################################################################################
 # Set the type of the given device.
-########################################################################################
+################################################################################
 sub set_device_type($$$) {
 	my ($self, $device, $type) = @_;
 
 	$self->{'visited_devices'}->{$device}->{'type'} = $type;
 }
 
-########################################################################################
+################################################################################
 # Performs an SNMP WALK and returns the response as an array.
-########################################################################################
+################################################################################
 sub snmp_get($$$) {
 	my ($self, $device, $oid) = @_;
 	my @output;
@@ -1911,9 +1911,9 @@ sub snmp_get($$$) {
 	return @output;
 }
 
-########################################################################################
+################################################################################
 # Get the snmpwalk command seing version 1, 2, 2c or 3.
-########################################################################################
+################################################################################
 sub snmp_get_command {
 	my ($self, $device, $oid, $community, $vlan) = @_;
 	$vlan = defined($vlan) ? "\@" . $vlan : '';
@@ -1938,10 +1938,10 @@ sub snmp_get_command {
 
 }
 
-########################################################################################
+################################################################################
 # Performs an SNMP WALK and returns the value of the given OID. Returns undef
 # on error.
-########################################################################################
+################################################################################
 sub snmp_get_value($$$) {
 	my ($self, $device, $oid) = @_;
 
@@ -1954,9 +1954,9 @@ sub snmp_get_value($$$) {
 	return undef;
 }
 
-########################################################################################
+################################################################################
 # Performs an SNMP WALK and returns an array of values.
-########################################################################################
+################################################################################
 sub snmp_get_value_array($$$) {
 	my ($self, $device, $oid) = @_;
 	my @values;
@@ -1970,9 +1970,9 @@ sub snmp_get_value_array($$$) {
 	return @values;
 }
 
-########################################################################################
+################################################################################
 # Performs an SNMP WALK and returns a hash of values.
-########################################################################################
+################################################################################
 sub snmp_get_value_hash($$$) {
 	my ($self, $device, $oid) = @_;
 	my %values;
@@ -1985,9 +1985,9 @@ sub snmp_get_value_hash($$$) {
 	return %values;
 }
 
-##########################################################################
+################################################################################
 # Connect the given host to its parent using traceroute.
-##########################################################################
+################################################################################
 sub traceroute_connectivity($$) {
 	my ($self, $host) = @_;
 
@@ -2025,10 +2025,10 @@ sub traceroute_connectivity($$) {
 	}
 }
 
-##########################################################################
+################################################################################
 # Returns the credentials with which the host responds to WMI queries or
 # undef if it does not respond to WMI.
-##########################################################################
+################################################################################
 sub responds_to_wmi {
 	my ($self, $target) = @_;
 
@@ -2049,9 +2049,9 @@ sub responds_to_wmi {
 	return undef;
 }
 
-##########################################################################
+################################################################################
 # Add wmi modules to the given host.
-##########################################################################
+################################################################################
 sub wmi_scan {
 	my ($self, $target) = @_;
 
@@ -2087,13 +2087,13 @@ sub wmi_scan {
 	}
 }
 
-##########################################################################
+################################################################################
 # Extra: WMI imported methods. DO NOT EXPORT TO AVOID DOUBLE DEF.
-##########################################################################
+################################################################################
 
-##########################################################################
+################################################################################
 # Performs a wmi get requests and returns the response as an array.
-##########################################################################
+################################################################################
 sub wmi_get {
 	my ($self, $target, $auth, $query) = @_;
 
@@ -2110,10 +2110,10 @@ sub wmi_get {
 	return @output;
 }
 
-##########################################################################
+################################################################################
 # Performs a WMI request and returns the requested column of the first row.
 # Returns undef on error.
-##########################################################################
+################################################################################
 sub wmi_get_value {
 	my ($self, $target, $auth, $query, $column) = @_;
 	my @result;
@@ -2129,10 +2129,10 @@ sub wmi_get_value {
 	return $columns[$column];
 }
 
-##########################################################################
+################################################################################
 # Performs a WMI request and returns row values for the requested column
 # in an array.
-##########################################################################
+################################################################################
 sub wmi_get_value_array {
 	my ($self, $target, $auth, $query, $column) = @_;
 	my @result;
@@ -2149,9 +2149,9 @@ sub wmi_get_value_array {
 	return @result;
 }
 
-##########################################################################
+################################################################################
 # END: WMI imported methods.
-##########################################################################
+################################################################################
 
 1;
 __END__