diff --git a/Info/Airespace.pm b/Info/Airespace.pm index 6e59a33a..87845ef9 100644 --- a/Info/Airespace.pm +++ b/Info/Airespace.pm @@ -28,7 +28,7 @@ # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. package SNMP::Info::Airespace; -$VERSION = '1.04'; +$VERSION = '1.05'; use strict; use Exporter; @@ -37,7 +37,7 @@ use SNMP::Info; @SNMP::Info::Airespace::ISA = qw/SNMP::Info Exporter/; @SNMP::Info::Airespace::EXPORT_OK = qw//; -use vars qw/$VERSION %FUNCS %GLOBALS %MIBS %MUNGE $AUTOLOAD $INIT $DEBUG/; +use vars qw/$VERSION %FUNCS %GLOBALS %MIBS %MUNGE/; %MIBS = ( %SNMP::Info::MIBS, @@ -47,49 +47,113 @@ use vars qw/$VERSION %FUNCS %GLOBALS %MIBS %MUNGE $AUTOLOAD $INIT $DEBUG/; %GLOBALS = ( %SNMP::Info::GLOBALS, - 'serial' => 'agentInventorySerialNumber', - 'os_ver' => 'agentInventoryProductVersion', + 'airespace_model' => 'agentInventoryMachineModel', + 'airespace_serial' => 'agentInventorySerialNumber', + 'airespace_mac' => 'agentInventoryBurnedInMacAddress', + 'airespace_os' => 'agentInventoryOperatingSystem', + 'airespace_vendor' => 'agentInventoryManufacturerName', + 'os_ver' => 'agentInventoryProductVersion', + 'airespace_bssid_mode' => 'agentNetworkBroadcastSsidMode', + 'airespace_mc_mode' => 'agentNetworkMulticastMode', + 'airespace_lwapp_mode' => 'agentSwitchLwappTransportMode', + 'airespace_ul_mode' => 'agentTransferUploadMode', + 'airespace_ul_ip' => 'agentTransferUploadServerIP', + 'airespace_ul_path' => 'agentTransferUploadPath', + 'airespace_ul_file' => 'agentTransferUploadFilename', + 'airespace_ul_type' => 'agentTransferUploadDataType', + 'airespace_ul_start' => 'agentTransferUploadStart', + 'airespace_ul_status' => 'agentTransferUploadStatus', ); %FUNCS = ( %SNMP::Info::FUNCS, - 'i_index2' => 'ifIndex', - 'i_name2' => 'ifName', - 'i_description2' => 'ifDescr', + # AIRESPACE-WIRELESS-MIB::bsnDot11EssTable + 'airespace_ess_idx' => 'bsnDot11EssIndex', + 'airespace_ess_ssid' => 'bsnDot11EssSsid', + 'airespace_ess_macflt' => 'bsnDot11EssMacFiltering', + 'airespace_ess_status' => 'bsnDot11EssAdminStatus', + 'airespace_ess_sec_auth' => 'bsnDot11EssSecurityAuthType', + 'airespace_ess_radio_pol' => 'bsnDot11EssRadioPolicy', + 'airespace_ess_qos' => 'bsnDot11EssQualityOfService', + 'airespace_ess_ifname' => 'bsnDot11EssInterfaceName', + 'airespace_ess_aclname' => 'bsnDot11EssAclName', # AIRESPACE-WIRELESS-MIB::bsnAPTable 'airespace_ap_mac' => 'bsnAPDot3MacAddress', 'airespace_ap_name' => 'bsnAPName', 'airespace_ap_ip' => 'bsnApIpAddress', 'airespace_ap_loc' => 'bsnAPLocation', + 'airespace_ap_sw' => 'bsnAPSoftwareVersion', 'airespace_ap_model' => 'bsnAPModel', 'airespace_ap_serial' => 'bsnAPSerialNumber', + 'airespace_ap_status' => 'bsnAPAdminStatus', + # AIRESPACE-WIRELESS-MIB::bsnAPIfTable + 'airespace_apif_slot' => 'bsnAPIfSlotId', + 'airespace_apif_type' => 'bsnAPIfType', + 'airespace_apif_ch_num' => 'bsnAPIfPhyChannelNumber', + 'airespace_apif_power' => 'bsnAPIfPhyTxPowerLevel', + 'airespace_apif' => 'bsnAPIfOperStatus', + 'airespace_apif_oride' => 'bsnAPIfWlanOverride', + 'airespace_apif_admin' => 'bsnAPIfAdminStatus', # AIRESPACE-WIRELESS-MIB::bsnMobileStationTable - 'fw_port' => 'bsnMobileStationAPMacAddr', + 'airespace_sta_mac' => 'bsnMobileStationAPMacAddr', 'fw_mac' => 'bsnMobileStationMacAddress', + 'airespace_sta_slot' => 'bsnMobileStationAPIfSlotId', + 'airespace_sta_ess_idx' => 'bsnMobileStationEssIndex', + 'airespace_sta_ssid' => 'bsnMobileStationSsid', + 'airespace_sta_delete' => 'bsnMobileStationDeleteAction', + # AIRESPACE-WIRELESS-MIB::bsnUsersTable + 'airespace_user_name' => 'bsnUserName', + 'airespace_user_pw' => 'bsnUserPassword', + 'airespace_user_ess_idx' => 'bsnUserEssIndex', + 'airespace_user_access' => 'bsnUserAccessMode', + 'airespace_user_type' => 'bsnUserType', + 'airespace_user_ifname' => 'bsnUserInterfaceName', + 'airespace_user_rstat' => 'bsnUserRowStatus', + # AIRESPACE-WIRELESS-MIB::bsnBlackListClientTable + 'airespace_bl_mac' => 'bsnBlackListClientMacAddress', + 'airespace_bl_descr' => 'bsnBlackListClientDescription', + 'airespace_bl_rstat' => 'bsnBlackListClientRowStatus', + # AIRESPACE-WIRELESS-MIB::bsnAPIfWlanOverrideTable + 'airespace_oride_id' => 'bsnAPIfWlanOverrideId', + 'airespace_oride_ssid' => 'bsnAPIfWlanOverrideSsid', + # AIRESPACE-SWITCHING-MIB::agentInterfaceConfigTable + 'airespace_if_name' => 'agentInterfaceName', + 'airespace_if_vlan' => 'agentInterfaceVlanId', + 'airespace_if_type' => 'agentInterfaceType', + 'airespace_if_mac' => 'agentInterfaceMacAddress', + 'airespace_if_ip' => 'agentInterfaceIPAddress', + 'airespace_if_mask' => 'agentInterfaceIPNetmask', + 'airespace_if_acl' => 'agentInterfaceAclName', + 'airespace_if_rstat' => 'agentInterfaceRowStatus', # AIRESPACE-SWITCHING-MIB::agentPortConfigTable 'airespace_duplex_admin' => 'agentPortPhysicalMode', 'airespace_duplex' => 'agentPortPhysicalStatus', ); %MUNGE = ( - %SNMP::Info::MUNGE, - # Add ones for our class - 'airespace_ap_mac' => \&SNMP::Info::munge_mac, - 'fw_port' => \&SNMP::Info::munge_mac, + %SNMP::Info::MUNGE, + 'airespace_ap_mac' => \&SNMP::Info::munge_mac, + 'fw_port' => \&SNMP::Info::munge_mac, + 'airespace_bl_mac' => \&SNMP::Info::munge_mac, + 'airespace_if_mac' => \&SNMP::Info::munge_mac, + 'airespace_sta_mac' => \&SNMP::Info::munge_mac, ); sub layers { return '00000011'; } -# Wirless switches do not support ifMIB requirements for get MAC +# Wirless switches do not support ifMIB requirements to get MAC # and port status sub i_index { my $airespace = shift; - my $i_index = $airespace->i_index2(); - my $ap_index = $airespace->airespace_ap_mac(); - + my $partial = shift; + + my $i_index = $airespace->orig_i_index($partial) || {}; + my $ap_index = $airespace->airespace_apif_slot($partial) || {}; + my $if_index = $airespace->airespace_if_name($partial) || {}; + my %if_index; foreach my $iid (keys %$i_index){ my $index = $i_index->{$iid}; @@ -100,46 +164,56 @@ sub i_index { # Get Attached APs as Interfaces foreach my $ap_id (keys %$ap_index){ - my $ap_index = $ap_index->{$ap_id}; - next unless defined $ap_index; - $if_index{$ap_id} = $ap_index; + if ($ap_id =~ /(\d+\.\d+\.\d+\.\d+\.\d+\.\d+)\.(\d+)/) { + my $mac = join(':',map {sprintf("%02x",$_)} split(/\./,$1)); + my $slot = $2; + next unless ( (defined $mac) and (defined $slot) ); + + $if_index{$ap_id} = "$mac.$slot"; + } } + + # Get Switch Interfaces from Interface Config Table + foreach my $if_id (keys %$if_index){ + my $name = $if_index->{$if_id}; + next unless defined $name; + + $if_index{$if_id} = $name; + } + return \%if_index; } sub interfaces { - my $airespace = shift; - my $i_index = $airespace->i_index(); - my $ap_index = $airespace->airespace_ap_mac(); - + my $airespace = shift; + my $partial = shift; + + my $i_index = $airespace->i_index($partial) || {}; + my %if; foreach my $iid (keys %$i_index){ my $index = $i_index->{$iid}; next unless defined $index; if ($index =~ /^\d+$/ ) { - $if{$index} = "1.$index"; + $if{$iid} = "1.$index"; } - elsif ($index =~ /(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}/) { - my $ap = $ap_index->{$iid}; - next unless defined $ap; - $if{$index} = $ap; - } - else { - next; + $if{$iid} = $index; } } return \%if; } sub i_name { - my $airespace = shift; - my $i_index = $airespace->i_index(); - my $i_name2 = $airespace->i_name2(); - my $ap_name = $airespace->airespace_ap_name(); + my $airespace = shift; + my $partial = shift; + + my $i_index = $airespace->i_index($partial) || {}; + my $i_name = $airespace->orig_i_name($partial) || {}; + my $ap_name = $airespace->airespace_ap_name($partial) || {}; my %i_name; foreach my $iid (keys %$i_index){ @@ -147,29 +221,33 @@ sub i_name { next unless defined $index; if ($index =~ /^\d+$/ ) { - my $name = $i_name2->{$iid}; - next unless defined $name; - $i_name{$index} = $name; + my $name = $i_name->{$iid}; + next unless defined $name; + $i_name{$iid} = $name; } elsif ($index =~ /(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}/) { - my $name = $ap_name->{$iid}; - next unless defined $name; - $i_name{$index} = $name; - } + my $idx = $iid; + $idx =~ s/\.\d+$//; + my $name = $ap_name->{$idx}; + next unless defined $name; + $i_name{$iid} = $name; + } + else { - next; + $i_name{$iid} = $index; } } - return \%i_name; + return \%i_name; } sub i_description { my $airespace = shift; - my $i_index = $airespace->i_index(); - my $i_descr = $airespace->i_description2(); - my $ap_loc = $airespace->airespace_ap_loc(); + my $partial = shift; + my $i_index = $airespace->i_index($partial) || {}; + my $i_descr = $airespace->orig_i_description($partial) || {}; + my $ap_loc = $airespace->airespace_ap_loc($partial) || {}; my %descr; foreach my $iid (keys %$i_index){ @@ -177,31 +255,182 @@ sub i_description { next unless defined $index; if ($index =~ /^\d+$/ ) { - my $descr = $i_descr->{$iid}; - next unless defined $descr; - $descr{$index} = $descr; + my $descr = $i_descr->{$iid}; + next unless defined $descr; + $descr{$iid} = $descr; } elsif ($index =~ /(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}/) { - my $name = $ap_loc->{$iid}; - next unless defined $name; - $descr{$index} = $name; - } + my $idx = $iid; + $idx =~ s/\.\d+$//; + my $name = $ap_loc->{$idx}; + next unless defined $name; + $descr{$iid} = $name; + } + else { - next; + $descr{$iid} = $index; } } return \%descr; } +sub i_type { + my $airespace = shift; + my $partial = shift; + + my $i_index = $airespace->i_index($partial) || {}; + my $i_descr = $airespace->orig_i_type($partial) || {}; + my $apif_type = $airespace->airespace_apif_type($partial) || {}; + my $if_type = $airespace->airespace_if_type($partial) || {}; + + my %i_type; + foreach my $iid (keys %$i_index){ + my $index = $i_index->{$iid}; + next unless defined $index; + + if ($index =~ /^\d+$/ ) { + my $descr = $i_descr->{$iid}; + next unless defined $descr; + $i_type{$iid} = $descr; + } + + elsif ($index =~ /(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}/) { + my $type = $apif_type->{$iid}; + next unless defined $type; + $i_type{$iid} = $type; + } + + else { + my $type = $if_type->{$iid}; + $i_type{$iid} = $type; + } + } + return \%i_type; +} + +sub i_up { + my $airespace = shift; + my $partial = shift; + + my $i_index = $airespace->i_index($partial) || {}; + my $i_up = $airespace->orig_i_up($partial) || {}; + my $apif_up = $airespace->airespace_apif($partial) || {}; + + my %i_up; + foreach my $iid (keys %$i_index){ + my $index = $i_index->{$iid}; + next unless defined $index; + + if ($index =~ /^\d+$/ ) { + my $stat = $i_up->{$iid}; + next unless defined $stat; + $i_up{$iid} = $stat; + } + + elsif ($index =~ /(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}/) { + my $stat = $apif_up->{$iid}; + next unless defined $stat; + $i_up{$iid} = $stat; + } + + else { + next; + } + } + return \%i_up; +} + +sub i_up_admin { + my $airespace = shift; + my $partial = shift; + + my $i_index = $airespace->i_index($partial) || {}; + my $i_up = $airespace->orig_i_up($partial) || {}; + my $apif_up = $airespace->airespace_apif_admin($partial) || {}; + + my %i_up_admin; + foreach my $iid (keys %$i_index){ + my $index = $i_index->{$iid}; + next unless defined $index; + + if ($index =~ /^\d+$/ ) { + my $stat = $i_up->{$iid}; + next unless defined $stat; + $i_up_admin{$iid} = $stat; + } + + elsif ($index =~ /(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}/) { + my $stat = $apif_up->{$iid}; + next unless defined $stat; + $i_up_admin{$iid} = $stat; + } + + else { + next; + } + } + return \%i_up_admin; +} + +sub i_mac { + my $airespace = shift; + my $partial = shift; + + my $i_index = $airespace->i_index($partial) || {}; + my $i_mac = $airespace->orig_i_mac($partial) || {}; + my $if_mac = $airespace->airespace_if_mac($partial) || {}; + + my %i_mac; + foreach my $iid (keys %$i_index){ + my $index = $i_index->{$iid}; + next unless defined $index; + + if ($index =~ /^\d+$/ ) { + my $mac = $i_mac->{$iid}; + next unless defined $mac; + $i_mac{$iid} = $mac; + } + + # Don't grab AP MACs - we want the AP to show up on edge switch + # ports + # Some switch interfaces have MACs, virtuals report 00:00:00:00:00:00 + + else { + my $mac = $if_mac->{$iid}; + next unless defined $mac; + next if $mac =~ /00:00:00:00:00:00/; + $i_mac{$iid} = $mac; + } + } + return \%i_mac; +} + +sub i_vlan { + my $airespace = shift; + my $partial = shift; + + my $if_vlan = $airespace->airespace_if_vlan($partial) || {}; + + my %i_vlan; + foreach my $iid (keys %$if_vlan){ + my $vlan = $if_vlan->{$iid}; + next unless defined $vlan; + + $i_vlan{$iid} = $vlan; + } + + return \%i_vlan; +} + sub i_duplex { my $airespace = shift; + my $partial = shift; - my $interfaces = $airespace->interfaces(); - my $ap_duplex = $airespace->airespace_duplex(); + my $ap_duplex = $airespace->airespace_duplex($partial) || {}; my %i_duplex; - foreach my $if (keys %$interfaces){ + foreach my $if (keys %$ap_duplex){ my $duplex = $ap_duplex->{$if}; next unless defined $duplex; @@ -215,12 +444,12 @@ sub i_duplex { sub i_duplex_admin { my $airespace = shift; - - my $interfaces = $airespace->interfaces(); - my $ap_duplex_admin = $airespace->airespace_duplex_admin(); + my $partial = shift; + + my $ap_duplex_admin = $airespace->airespace_duplex_admin($partial) || {}; my %i_duplex_admin; - foreach my $if (keys %$interfaces){ + foreach my $if (keys %$ap_duplex_admin){ my $duplex = $ap_duplex_admin->{$if}; next unless defined $duplex; @@ -232,37 +461,185 @@ sub i_duplex_admin { return \%i_duplex_admin; } - +sub ip_index { + my $airespace = shift; + my $partial = shift; + + my $ip_index = $airespace->orig_ip_index($partial) || {}; + my $if_ip = $airespace->airespace_if_ip() || {}; + + my %ip_index; + foreach my $ip (keys %$ip_index){ + my $iid = $ip_index->{$ip}; + next unless defined $iid; + + $ip_index{$ip} = $iid; + } + + foreach my $iid (keys %$if_ip){ + my $ip = $if_ip->{$iid}; + next unless defined $ip; + next if (defined $partial and $partial !~ /$ip/); + + $ip_index{$ip} = $iid; + } + + return \%ip_index; +} + +sub ip_netmask { + my $airespace = shift; + my $partial = shift; + + my $ip_mask = $airespace->orig_ip_netmask($partial) || {}; + my $if_ip = $airespace->airespace_if_ip() || {}; + my $if_mask = $airespace->airespace_if_mask() || {}; + + my %ip_netmask; + foreach my $ip (keys %$ip_mask){ + my $mask = $ip_mask->{$ip}; + next unless defined $mask; + + $ip_netmask{$ip} = $mask; + } + + foreach my $iid (keys %$if_mask){ + my $ip = $if_ip->{$iid}; + next unless defined $ip; + next if (defined $partial and $partial !~ /$ip/); + my $mask = $if_mask->{$iid}; + next unless defined $mask; + + $ip_netmask{$ip} = $mask; + } + + return \%ip_netmask; +} + # Wireless switches do not support the standard Bridge MIB sub bp_index { my $airespace = shift; - my $i_index = $airespace->i_index2(); - my $ap_index = $airespace->airespace_ap_mac(); + my $partial = shift; + + my $i_index = $airespace->i_index($partial) || {}; my %bp_index; foreach my $iid (keys %$i_index){ my $index = $i_index->{$iid}; next unless defined $index; - $bp_index{$iid} = $index; + $bp_index{$index} = $iid; } - # Get Attached APs as Interfaces - foreach my $ap_id (keys %$ap_index){ - my $ap_index = $ap_index->{$ap_id}; - next unless defined $ap_index; - - $bp_index{$ap_index} = $ap_index; - } return \%bp_index; } +sub fw_port { + my $airespace = shift; + my $partial = shift; + + my $sta_mac = $airespace->airespace_sta_mac($partial) || {}; + my $sta_slot = $airespace->airespace_sta_slot($partial) || {}; + + my %fw_port; + foreach my $iid (keys %$sta_mac){ + my $mac = $sta_mac->{$iid}; + next unless defined $mac; + my $slot = $sta_slot->{$iid}; + next unless defined $slot; + + $fw_port{$iid} = "$mac.$slot"; + } + + return \%fw_port; +} + +sub i_ssidlist { + my $airespace = shift; + my $partial = shift; + + my $apif_override = $airespace->airespace_apif_oride($partial) || {}; + my $apif_type = $airespace->airespace_apif_type($partial) || {}; + my $ssids = $airespace->airespace_ess_ssid() || {}; + my $ssid_policy = $airespace->airespace_ess_radio_pol() || {}; + my $ssid_status = $airespace->airespace_ess_status() || {}; + my $ovride_ssids = $airespace->airespace_oride_ssid($partial) || {}; + + my %i_ssidlist; + foreach my $iid (keys %$apif_override){ + my $override = $apif_override->{$iid}; + next unless defined $override; + + next unless $override =~ /disable/i ; + my $ap_type = $apif_type->{$iid}; + next unless defined $ap_type; + $ap_type =~ s/dot11//; + + foreach my $idx (keys %$ssids){ + my $ssid = $ssids->{$idx}; + next unless defined $ssid; + my $status = $ssid_status->{$idx}; + next unless defined $status; + next if ( $status =~ /disable/ ); + my $policy = $ssid_policy->{$idx}; + next unless $policy =~ /$ap_type/ or $policy =~ /all/; + + $i_ssidlist{"$iid.$idx"} = $ssid; + } + next; + } + + foreach my $iid (keys %$ovride_ssids){ + my $ssid = $ovride_ssids->{$iid}; + next unless $ssid; + + $i_ssidlist{$iid} = $ssid; + } + + return \%i_ssidlist; +} + +sub i_ssidbcast { + my $airespace = shift; + my $partial = shift; + + my $ssidlist = $airespace->i_ssidlist($partial) || {}; + my $bc_mode = $airespace->airespace_bssid_mode() || 'enable'; + + my %bcmap = qw/enable 1 disable 0/; + my $broadcast = $bcmap{$bc_mode}; + + my %i_ssidbcast; + foreach my $iid (keys %$ssidlist){ + $i_ssidbcast{$iid} = $broadcast; + } + + return \%i_ssidbcast; +} + +sub i_80211channel { + my $airespace = shift; + my $partial = shift; + + my $ch_list = $airespace->airespace_apif_ch_num($partial) || {}; + + my %i_80211channel; + foreach my $iid (keys %$ch_list){ + my $ch = $ch_list->{$iid}; + $ch =~ s/ch//; + $i_80211channel{$iid} = $ch; + } + + return \%i_80211channel; +} + 1; __END__ =head1 NAME -SNMP::Info::Airespace - SNMP Interface to Airespace wireless switches +SNMP::Info::Airespace - SNMP Interface to data from AIRESPACE-WIRELESS-MIB +and AIRESPACE-SWITCHING-MIB =head1 AUTHOR @@ -298,17 +675,14 @@ This class emulates bridge functionality for the wireless switch. This enables end station MAC addresses collection and correlation to the thin access point the end station is using for communication. -Normally you use or create a subclass of SNMP::Info that inherits this one. Do not use directly. - -For debugging purposes call the class directly as you would SNMP::Info - - my $airespace = new SNMP::Info::Airespace(...); +Use or create a subclass of SNMP::Info that inherits this one. +Do not use directly. =head2 Inherited Classes =over -=item SNMP::Info +None. =back @@ -328,14 +702,91 @@ These are methods that return scalar value from SNMP =over -=item $airespace->serial() +=item $airespace->airespace_model() + +(B) + +=item $airespace->airespace_serial() (B) +=item $airespace->airespace_mac() + +(B) + +=item $airespace->airespace_os() + +(B) + +=item $airespace->airespace_vendor() + +(B) + =item $airespace->os_ver() (B) +=item $airespace->airespace_bssid_mode() + +(B) + +=item $airespace->airespace_mc_mode() + +(B) + +=item $airespace->airespace_lwapp_mode() + +The LWAPP transport mode decides if the switch is operating in the Layer2 or +Layer3 mode. + +(B) + +=item $airespace->airespace_ul_mode() + +Transfer upload mode configures the mode to use when uploading from the switch. +Normal usage tftp. + +(B) + +=item $airespace->airespace_ul_ip() + +Transfer upload tftpserverip configures the IP address of the server. It is +valid only when the Transfer Mode is tftp. + +(B) + +=item $airespace->airespace_ul_path() + +Transfer upload tftppath configures the directory path where the file is to be +uploaded to. The switch remembers the last file path used. + +(B) + +=item $airespace->airespace_ul_file() + +(B) + +=item $airespace->airespace_ul_type() + +Transfer upload datatype configures the type of file to upload from the switch. + + The types for upload are: + config(2) + errorlog(3) + systemtrace(4) + traplog(5) + crashfile(6) + +(B) + +=item $airespace->airespace_ul_start() + +(B) + +=item $airespace->airespace_ul_status() + +(B) + =back =head2 Overrides @@ -354,75 +805,126 @@ proprietary MIBs. These are methods that return tables of information in the form of a reference to a hash. -=head2 Overrides - =over -=item $airespace->i_index() +=item $airespace->i_ssidlist() -Returns reference to map of IIDs to Interface index. +Returns reference to hash. SSID's recognized by the radio interface. -Extends ifIndex to support thin APs as device interfaces. +=item $airespace->i_ssidbcast() -=item $airespace->interfaces() +Returns reference to hash. Indicates whether the SSID is broadcast. -Returns reference to map of IIDs to ports. Thin APs are implemented as device -interfaces. The thin AP MAC address is used as the port identifier. +=item $airespace->i_80211channel() -=item $airespace->i_name() - -Interface name. Returns (B) for Ethernet interfaces and (B) -for thin AP interfaces. - -=item $airespace->i_description() - -Description of the interface. Returns (B) for Ethernet interfaces and -(B) for thin AP interfaces. - -=item $airespace->i_duplex() - -Returns reference to map of IIDs to current link duplex. Ethernet interfaces only. - -=item $airespace->i_duplex_admin() - -Returns reference to hash of IIDs to admin duplex setting. Ethernet interfaces -only. - -=item $airespace->bp_index() - -Simulates bridge MIB by returning reference to a hash containing the index for -both the keys and values. - -=item $airespace->fw_port() - -(B) - -=item $airespace->fw_mac() - -(B) +Returns reference to hash. Current operating frequency channel of the radio +interface. =back -=head2 AIRESPACE AP Table (B) +=head2 Dot11 Ess Table (B) + +Ess(WLAN) Configuration Table. Maximum of 17 WLANs can be created on +Airespace Switch. Index of 17 is reserved for WLAN for Third Party +APs(non-Airespace APs). + +=over + +=item $airespace->airespace_ess_idx() + +(B) + +=item $airespace->airespace_ess_ssid() + +SSID assigned to ESS(WLAN) + +(B) + +=item $airespace->airespace_ess_macflt() + +Select to filter clients by MAC address. By selecting this Security, you need +to create MacFilters in B or have MacFilters configured on +Radius Servers specified in B + +(B) + +=item $airespace->airespace_ess_status() + +Administrative Status of ESS(WLAN). + +(B) + +=item $airespace->airespace_ess_sec_auth() + +Type of 802.11 Authentication. + +(B) + +=item $airespace->airespace_ess_radio_pol() + +Radio Policy for a WLAN. It can either be All where it will be applicable +to ALL types of protocols or it can be set to apply to combinations of +802.11a, 802.11b, 802.11g. + +(B) + +=item $airespace->airespace_ess_qos() + +Quality of Service for a WLAN. + +(B) + +=item $airespace->airespace_ess_ifname() + +Name of the interface used by this WLAN. + +(B) + +=item $airespace->airespace_ess_aclname() + +Name of ACL for the WLAN. This is applicable only when Web Authentication is +enabled. + +(B) + +=back + +=head2 AP Table (B) + +Table of Airespace APs managed by this Airespace Switch. =over =item $airespace->airespace_ap_mac() +The MAC address of the 802.3 interface of the AP. + (B) =item $airespace->airespace_ap_name() +Name assigned to this AP. If an AP is not configured its factory default name +will be ap:. eg. ap:af:12:be + (B) =item $airespace->airespace_ap_ip() +Ip address of the AP. This will not be available when the switch is operating +in the Layer2 mode. In this case, the attribute will return 0 as value. + (B) =item $airespace->airespace_ap_loc() +User specified location of this AP. + (B) +=item $airespace->airespace_ap_sw() + +(B) + =item $airespace->airespace_ap_model() (B) @@ -431,9 +933,245 @@ both the keys and values. (B) +=item $airespace->airespace_ap_status() + +(B) + =back -=head2 AIRESPACE Agent Port Config Table (B) +=head2 AP Interface Table (B) + +Table of 802.11 interfaces in an Airespace APs. + +=over + +=item $airespace->airespace_apif_slot() + +The slotId of this interface. Value will be 0 for a 802.11a (5Ghz) interface +and will be 1 for 802.11b/g (2.4Ghz) interface. + +(B) + +=item $airespace->airespace_apif_type() + +(B) + +=item $airespace->airespace_apif_ch_num() + +(B) + +=item $airespace->airespace_apif_power() + +The TxPowerLevel N currently being used to transmit data. + +(B) + +=item $airespace->airespace_apif() + +(B) + +=item $airespace->airespace_apif_oride() + +This flag when disabled implies that all WLANs are available from this radio. +However, if this is enabled, then only those WLANs that appear in the +(B) will be available from this radio. + +(B) + +=item $airespace->airespace_apif_admin() + +(B) + +=back + +=head2 Mobile Station Table (B) + +=over + +=item $airespace->airespace_sta_mac() + +Mac Address of the AP on which Mobile Station is associated. + +(B) + +=item $airespace->airespace_sta_slot() + +SlotId of APIf on which mobile station is associated. + +(B) + +=item $airespace->airespace_sta_ess_idx() + +Ess Index of the Wlan(SSID) that is being used by Mobile Station to connect +to the AP. + +(B) + +=item $airespace->airespace_sta_ssid() + +The SSID Advertised by the Mobile Station. + +(B) + +=item $airespace->airespace_sta_delete() + +Action to Deauthenticate the Mobile Station. Set the State to delete. + +(B) + +=back + +=head2 Users Table (B) + +The (conceptual) table listing Wlan Users. + +=over + +=item $airespace->airespace_user_name() + +User name. For MAC filters, this will be the MAC address (eg. 000123456789). + +(B) + +=item $airespace->airespace_user_pw() + +User Password. For MAC filters, this will be "nopassword". + +(B) + +=item $airespace->airespace_user_ess_idx() + +User WLAN ID. Value 0 implies that this applies to any WLAN ID. + +(B) + +=item $airespace->airespace_user_access() + +For MAC filters, this will be "readOnly". + +(B) + +=item $airespace->airespace_user_type() + +User Access Mode. For MAC filters, this will be "macFilter". + +(B) + +=item $airespace->airespace_user_ifname() + +ACL for MAC Filters. An interface name from B + +(B) + +=item $airespace->airespace_user_rstat() + +(B) + +=back + +=head2 Black List Client Table (B) + +The table listing Wlan Black Listed Clients + +=over + +=item $airespace->airespace_bl_mac() + +(B) + +=item $airespace->airespace_bl_descr() + +(B) + +=item $airespace->airespace_bl_rstat() + +(B) + +=back + +=head2 AP Interface WLAN Override Table (B) + +Each entry represents an SSID added to the AP when the attribute +B on the radio is enabled. This means only those WLANs +on the switch that are added to this table will be available on such a radio. + +=over + +=item $airespace->airespace_oride_id() + +Index of the WLAN (B) added to the radio. + +(B) + +=item $airespace->airespace_oride_ssid() + +SSID assigned to the override WLAN. + +(B) + +=back + +=head2 Interface Config Table (B) + +A table of the switch's Interface Config entries. Typically, it will contain +entries for Service Port Interface, DS Port Interface and Virtual Gateway +Interface apart from other entries. + +=over + +=item $airespace->airespace_if_name() + +Interace Name. This values is 'management' for DS port, 'service-port' for +service port and 'virtual' for virtual gateway. For other interfaces, the +name can be anything. These interfaces are already created by default. + +(B) + +=item $airespace->airespace_if_vlan() + +VLAN Id configured for the Interface. + +(B) + +=item $airespace->airespace_if_type() + +The interface's type. The static type is set for the interfaces that are +created by default on the switch and these cannot be deleted. Any other +interface that is created is of type dynamic which can be deleted. + +(B) + +=item $airespace->airespace_if_mac() + +Interface MAC Address. This is only applicable in case of management and +service-port interfaces. + +(B) + +=item $airespace->airespace_if_ip() + +(B) + +=item $airespace->airespace_if_mask() + +(B) + +=item $airespace->airespace_if_acl() + +Name of the Access Control List applied to the interface. This attribute is +applicable only to the management interface and other dynamic interfaces. +If it is required to remove the ACL name for an interface, it should be set +to an empty string. + +(B) + +=item $airespace->airespace_if_rstat() + +(B) + +=back + +=head2 Port Config Table (B) =over @@ -445,4 +1183,97 @@ both the keys and values. (B) +=back + +=head2 Overrides + +=over + +=item $airespace->i_index() + +Returns reference to map of IIDs to Interface index. + +Extends ifIndex to support thin APs and WLAN virtual interfaces as device +interfaces. + +=item $airespace->interfaces() + +Returns reference to map of IIDs to ports. Thin APs are implemented as device +interfaces. The thin AP MAC address airespace_ap_mac() and Slot ID +airespace_apif_slot() are used as the port identifier. Virtual interfaces +use airespace_if_name() as the port identifier. + +=item $airespace->i_name() + +Returns reference to map of IIDs to interface names. Returns B for +Ethernet interfaces, airespace_ap_name() for thin AP interfaces, and +airespace_if_name() for virtual interfaces. + +=item $airespace->i_description() + +Returns reference to map of IIDs to interface types. Returns B +for Ethernet interfaces, airespace_ap_loc() for thin AP interfaces, and +airespace_if_name() for virtual interfaces. + +=item $airespace->i_type() + +Returns reference to map of IIDs to interface descriptions. Returns +B for Ethernet interfaces, airespace_apif_type() for thin AP +interfaces, and airespace_if_type() for virtual interfaces. + +=item $airespace->i_up() + +Returns reference to map of IIDs to link status of the interface. Returns +B for Ethernet interfaces and airespace_apif() for thin AP +interfaces. + +=item $airespace->i_up_admin() + +Returns reference to map of IIDs to administrative status of the interface. +Returns B for Ethernet interfaces and airespace_apif_admin() +for thin AP interfaces. + +=item $airespace->i_mac() + +Returns reference to map of IIDs to MAC address of the interface. Returns +B for Ethernet interfaces and airespace_if_mac() for virtual +interfaces. + +=item $airespace->i_vlan() + +Returns reference to map of IIDs to VLAN ID of the interface. Returns +airespace_if_vlan() for virtual interfaces. + +=item $airespace->i_duplex() + +Returns reference to map of IIDs to current link duplex. Ethernet interfaces +only. + +=item $airespace->i_duplex_admin() + +Returns reference to hash of IIDs to admin duplex setting. Ethernet interfaces +only. + +=item $airespace->ip_index() + +Extends table by mapping airespace_if_ip() to the interface IID. + +=item $airespace->ip_netmask() + +Extends IP table by mapping airespace_if_mask() to airespace_if_ip() + +=item $airespace->bp_index() + +Simulates bridge MIB by returning reference to a hash mapping i_index() to +the interface iid. + +=item $airespace->fw_port() + +Returns reference to a hash, value being airespace_sta_mac() and +airespace_sta_slot() combined to match the interface iid. + +=item $airespace->fw_mac() + +(B) + =cut