#include <sys/queue.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <net/if.h>
#include <net/if_media.h>
#include <net/if_mib.h>
#include <net/if_types.h>
#include <net80211/ieee80211.h>
#include <net80211/ieee80211_ioctl.h>
#include <errno.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <syslog.h>
#include <bsnmp/snmpmod.h>
#include <bsnmp/snmp_mibII.h>
#define SNMPTREE_TYPES
#include "wlan_tree.h"
#include "wlan_snmp.h"
#include "wlan_oid.h"
static struct lmodule *wlan_module;
static const struct asn_oid oid_wlan = OIDX_begemotWlan;
static uint reg_wlan;
static void *wlan_data_timer;
static int wlan_poll_ticks = (15 * 60) * 100;
#define WLAN_LIST_MAXAGE 5
static time_t wlan_iflist_age;
static time_t wlan_peerlist_age;
static time_t wlan_chanlist_age;
static time_t wlan_roamlist_age;
static time_t wlan_tx_paramlist_age;
static time_t wlan_scanlist_age;
static time_t wlan_maclist_age;
static time_t wlan_mrlist_age;
SLIST_HEAD(wlan_ifaces, wlan_iface);
static struct wlan_ifaces wlan_ifaces = SLIST_HEAD_INITIALIZER(wlan_ifaces);
static struct wlan_config wlan_config;
static int bits_get(struct snmp_value *, const u_char *, ssize_t);
static int wlan_add_wif(struct wlan_iface *);
static void wlan_delete_wif(struct wlan_iface *);
static int wlan_attach_newif(struct mibif *);
static int wlan_iface_create(struct wlan_iface *);
static int wlan_iface_destroy(struct wlan_iface *);
static struct wlan_iface * wlan_new_wif(char *);
static void wlan_free_interface(struct wlan_iface *);
static void wlan_free_iflist(void);
static void wlan_free_peerlist(struct wlan_iface *);
static void wlan_scan_free_results(struct wlan_iface *);
static void wlan_mac_free_maclist(struct wlan_iface *);
static void wlan_mesh_free_routes(struct wlan_iface *);
static int wlan_update_interface(struct wlan_iface *);
static void wlan_update_interface_list(void);
static void wlan_update_peers(void);
static void wlan_update_channels(void);
static void wlan_update_roam_params(void);
static void wlan_update_tx_params(void);
static void wlan_scan_update_results(void);
static void wlan_mac_update_aclmacs(void);
static void wlan_mesh_update_routes(void);
static struct wlan_iface * wlan_find_interface(const char *);
static struct wlan_peer * wlan_find_peer(struct wlan_iface *, uint8_t *);
static struct ieee80211_channel* wlan_find_channel(struct wlan_iface *,
uint32_t);
static struct wlan_scan_result * wlan_scan_find_result(struct wlan_iface *,
uint8_t *, uint8_t *);
static struct wlan_mac_mac * wlan_mac_find_mac(struct wlan_iface *,
uint8_t *);
static struct wlan_mesh_route * wlan_mesh_find_route(struct wlan_iface *,
uint8_t *);
static struct wlan_iface * wlan_first_interface(void);
static struct wlan_iface * wlan_next_interface(struct wlan_iface *);
static struct wlan_iface * wlan_mesh_first_interface(void);
static struct wlan_iface * wlan_mesh_next_interface(struct wlan_iface *);
static struct wlan_iface * wlan_get_interface(const struct asn_oid *, uint);
static struct wlan_iface * wlan_get_snmp_interface(const struct asn_oid *,
uint);
static struct wlan_peer * wlan_get_peer(const struct asn_oid *, uint,
struct wlan_iface **);
static struct ieee80211_channel *wlan_get_channel(const struct asn_oid *, uint,
struct wlan_iface **);
static struct ieee80211_roamparam *wlan_get_roam_param(const struct asn_oid *,
uint, struct wlan_iface **);
static struct ieee80211_txparam *wlan_get_tx_param(const struct asn_oid *,
uint, struct wlan_iface **, uint32_t *);
static struct wlan_scan_result *wlan_get_scanr(const struct asn_oid *, uint,
struct wlan_iface **);
static struct wlan_mac_mac * wlan_get_acl_mac(const struct asn_oid *,
uint, struct wlan_iface **);
static struct wlan_iface * wlan_mesh_get_iface(const struct asn_oid *, uint);
static struct wlan_peer * wlan_mesh_get_peer(const struct asn_oid *, uint,
struct wlan_iface **);
static struct wlan_mesh_route * wlan_mesh_get_route(const struct asn_oid *,
uint, struct wlan_iface **);
static struct wlan_iface * wlan_get_next_interface(const struct asn_oid *,
uint);
static struct wlan_iface * wlan_get_next_snmp_interface(const struct
asn_oid *, uint);
static struct wlan_peer * wlan_get_next_peer(const struct asn_oid *, uint,
struct wlan_iface **);
static struct ieee80211_channel *wlan_get_next_channel(const struct asn_oid *,
uint, struct wlan_iface **);
static struct ieee80211_roamparam *wlan_get_next_roam_param(const struct
asn_oid *, uint sub, struct wlan_iface **, uint32_t *);
static struct ieee80211_txparam *wlan_get_next_tx_param(const struct asn_oid *,
uint, struct wlan_iface **, uint32_t *);
static struct wlan_scan_result *wlan_get_next_scanr(const struct asn_oid *,
uint , struct wlan_iface **);
static struct wlan_mac_mac * wlan_get_next_acl_mac(const struct asn_oid *,
uint, struct wlan_iface **);
static struct wlan_iface * wlan_mesh_get_next_iface(const struct asn_oid *,
uint);
static struct wlan_peer * wlan_mesh_get_next_peer(const struct asn_oid *,
uint, struct wlan_iface **);
static struct wlan_mesh_route * wlan_mesh_get_next_route(const struct asn_oid *,
uint sub, struct wlan_iface **);
static uint8_t *wlan_get_ifname(const struct asn_oid *, uint, uint8_t *);
static int wlan_mac_index_decode(const struct asn_oid *, uint, char *,
uint8_t *);
static int wlan_channel_index_decode(const struct asn_oid *, uint,
char *, uint32_t *);
static int wlan_phy_index_decode(const struct asn_oid *, uint, char *,
uint32_t *);
static int wlan_scanr_index_decode(const struct asn_oid *oid, uint sub,
char *wname, uint8_t *ssid, uint8_t *bssid);
static void wlan_append_ifindex(struct asn_oid *, uint,
const struct wlan_iface *);
static void wlan_append_mac_index(struct asn_oid *, uint, char *, uint8_t *);
static void wlan_append_channel_index(struct asn_oid *, uint,
const struct wlan_iface *, const struct ieee80211_channel *);
static void wlan_append_phy_index(struct asn_oid *, uint, char *, uint32_t);
static void wlan_append_scanr_index(struct asn_oid *, uint, char *,
uint8_t *, uint8_t *);
static int wlan_acl_mac_set_status(struct snmp_context *,
struct snmp_value *, uint);
static int wlan_mesh_route_set_status(struct snmp_context *,
struct snmp_value *, uint);
static int32_t wlan_get_channel_type(struct ieee80211_channel *);
static int wlan_scan_compare_result(struct wlan_scan_result *,
struct wlan_scan_result *);
static int wlan_mac_delete_mac(struct wlan_iface *, struct wlan_mac_mac *);
static int wlan_mesh_delete_route(struct wlan_iface *,
struct wlan_mesh_route *);
int
op_wlan_iface(struct snmp_context *ctx, struct snmp_value *val, uint32_t sub,
uint32_t iidx __unused, enum snmp_op op)
{
int rc;
char wname[IFNAMSIZ];
struct wlan_iface *wif;
wlan_update_interface_list();
switch (op) {
case SNMP_OP_GET:
if ((wif = wlan_get_snmp_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
if ((wif = wlan_get_next_snmp_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_ifindex(&val->var, sub, wif);
break;
case SNMP_OP_SET:
if ((wif = wlan_get_snmp_interface(&val->var, sub)) == NULL) {
if (val->var.subs[sub - 1] != LEAF_wlanIfaceName)
return (SNMP_ERR_NOSUCHNAME);
if (wlan_get_ifname(&val->var, sub, wname) == NULL)
return (SNMP_ERR_INCONS_VALUE);
if ((wif = wlan_new_wif(wname)) == NULL)
return (SNMP_ERR_GENERR);
wif->internal = 1;
}
if (wif->status == RowStatus_active &&
val->var.subs[sub - 1] != LEAF_wlanIfaceStatus &&
val->var.subs[sub - 1] != LEAF_wlanIfaceState)
return (SNMP_ERR_INCONS_VALUE);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanIfaceIndex:
return (SNMP_ERR_NOT_WRITEABLE);
case LEAF_wlanIfaceName:
if (val->v.octetstring.len >= IFNAMSIZ)
return (SNMP_ERR_INCONS_VALUE);
if ((ctx->scratch->ptr1 = malloc(IFNAMSIZ)) == NULL)
return (SNMP_ERR_GENERR);
strlcpy(ctx->scratch->ptr1, wif->wname, IFNAMSIZ);
memcpy(wif->wname, val->v.octetstring.octets,
val->v.octetstring.len);
wif->wname[val->v.octetstring.len] = '\0';
return (SNMP_ERR_NOERROR);
case LEAF_wlanParentIfName:
if (val->v.octetstring.len >= IFNAMSIZ)
return (SNMP_ERR_INCONS_VALUE);
if ((ctx->scratch->ptr1 = malloc(IFNAMSIZ)) == NULL)
return (SNMP_ERR_GENERR);
strlcpy(ctx->scratch->ptr1, wif->pname, IFNAMSIZ);
memcpy(wif->pname, val->v.octetstring.octets,
val->v.octetstring.len);
wif->pname[val->v.octetstring.len] = '\0';
return (SNMP_ERR_NOERROR);
case LEAF_wlanIfaceOperatingMode:
ctx->scratch->int1 = wif->mode;
wif->mode = val->v.integer;
return (SNMP_ERR_NOERROR);
case LEAF_wlanIfaceFlags:
if (val->v.octetstring.len > sizeof(wif->flags))
return (SNMP_ERR_INCONS_VALUE);
ctx->scratch->ptr1 = malloc(sizeof(wif->flags));
if (ctx->scratch->ptr1 == NULL)
return (SNMP_ERR_GENERR);
memcpy(ctx->scratch->ptr1, (uint8_t *)&wif->flags,
sizeof(wif->flags));
memcpy((uint8_t *)&wif->flags, val->v.octetstring.octets,
sizeof(wif->flags));
return (SNMP_ERR_NOERROR);
case LEAF_wlanIfaceBssid:
if (val->v.octetstring.len != IEEE80211_ADDR_LEN)
return (SNMP_ERR_INCONS_VALUE);
ctx->scratch->ptr1 = malloc(IEEE80211_ADDR_LEN);
if (ctx->scratch->ptr1 == NULL)
return (SNMP_ERR_GENERR);
memcpy(ctx->scratch->ptr1, wif->dbssid,
IEEE80211_ADDR_LEN);
memcpy(wif->dbssid, val->v.octetstring.octets,
IEEE80211_ADDR_LEN);
return (SNMP_ERR_NOERROR);
case LEAF_wlanIfaceLocalAddress:
if (val->v.octetstring.len != IEEE80211_ADDR_LEN)
return (SNMP_ERR_INCONS_VALUE);
ctx->scratch->ptr1 = malloc(IEEE80211_ADDR_LEN);
if (ctx->scratch->ptr1 == NULL)
return (SNMP_ERR_GENERR);
memcpy(ctx->scratch->ptr1, wif->dlmac,
IEEE80211_ADDR_LEN);
memcpy(wif->dlmac, val->v.octetstring.octets,
IEEE80211_ADDR_LEN);
return (SNMP_ERR_NOERROR);
case LEAF_wlanIfaceStatus:
ctx->scratch->int1 = wif->status;
wif->status = val->v.integer;
if (wif->status == RowStatus_active) {
rc = wlan_iface_create(wif);
if (rc != SNMP_ERR_NOERROR) {
wif->status = ctx->scratch->int1;
return (rc);
}
} else if (wif->status == RowStatus_destroy)
return (wlan_iface_destroy(wif));
else
wif->status = RowStatus_notReady;
return (SNMP_ERR_NOERROR);
case LEAF_wlanIfaceState:
ctx->scratch->int1 = wif->state;
wif->state = val->v.integer;
if (wif->status == RowStatus_active)
if (wlan_config_state(wif, 1) < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
}
abort();
case SNMP_OP_ROLLBACK:
if ((wif = wlan_get_snmp_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanIfaceName:
strlcpy(wif->wname, ctx->scratch->ptr1, IFNAMSIZ);
free(ctx->scratch->ptr1);
break;
case LEAF_wlanParentIfName:
strlcpy(wif->pname, ctx->scratch->ptr1, IFNAMSIZ);
free(ctx->scratch->ptr1);
break;
case LEAF_wlanIfaceOperatingMode:
wif->mode = ctx->scratch->int1;
break;
case LEAF_wlanIfaceFlags:
memcpy((uint8_t *)&wif->flags, ctx->scratch->ptr1,
sizeof(wif->flags));
free(ctx->scratch->ptr1);
break;
case LEAF_wlanIfaceBssid:
memcpy(wif->dbssid, ctx->scratch->ptr1,
IEEE80211_ADDR_LEN);
free(ctx->scratch->ptr1);
break;
case LEAF_wlanIfaceLocalAddress:
memcpy(wif->dlmac, ctx->scratch->ptr1,
IEEE80211_ADDR_LEN);
free(ctx->scratch->ptr1);
break;
case LEAF_wlanIfaceStatus:
wif->status = ctx->scratch->int1;
if (ctx->scratch->int1 == RowStatus_active)
return (SNMP_ERR_GENERR);
else if (wif->internal != 0)
return (wlan_iface_destroy(wif));
break;
case LEAF_wlanIfaceState:
wif->state = ctx->scratch->int1;
if (wif->status == RowStatus_active)
if (wlan_config_state(wif, 1) < 0)
return (SNMP_ERR_GENERR);
break;
}
return (SNMP_ERR_NOERROR);
case SNMP_OP_COMMIT:
switch (val->var.subs[sub - 1]) {
case LEAF_wlanIfaceName:
case LEAF_wlanParentIfName:
case LEAF_wlanIfaceFlags:
case LEAF_wlanIfaceBssid:
case LEAF_wlanIfaceLocalAddress:
free(ctx->scratch->ptr1);
default:
return (SNMP_ERR_NOERROR);
}
default:
abort();
}
switch (val->var.subs[sub - 1]) {
case LEAF_wlanIfaceIndex:
val->v.integer = wif->index;
return (SNMP_ERR_NOERROR);
case LEAF_wlanIfaceName:
return (string_get(val, wif->wname, -1));
case LEAF_wlanParentIfName:
return (string_get(val, wif->pname, -1));
case LEAF_wlanIfaceOperatingMode:
val->v.integer = wif->mode;
return (SNMP_ERR_NOERROR);
case LEAF_wlanIfaceFlags:
return (bits_get(val, (uint8_t *)&wif->flags,
sizeof(wif->flags)));
case LEAF_wlanIfaceBssid:
return (string_get(val, wif->dbssid, IEEE80211_ADDR_LEN));
case LEAF_wlanIfaceLocalAddress:
return (string_get(val, wif->dlmac, IEEE80211_ADDR_LEN));
case LEAF_wlanIfaceStatus:
val->v.integer = wif->status;
return (SNMP_ERR_NOERROR);
case LEAF_wlanIfaceState:
val->v.integer = wif->state;
return (SNMP_ERR_NOERROR);
}
abort();
}
int
op_wlan_if_parent(struct snmp_context *ctx __unused, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
struct wlan_iface *wif;
wlan_update_interface_list();
switch (op) {
case SNMP_OP_GET:
if ((wif = wlan_get_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
if ((wif = wlan_get_next_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_ifindex(&val->var, sub, wif);
break;
case SNMP_OP_SET:
return (SNMP_ERR_NOT_WRITEABLE);
case SNMP_OP_COMMIT:
case SNMP_OP_ROLLBACK:
default:
abort();
}
switch (val->var.subs[sub - 1]) {
case LEAF_wlanIfParentDriverCapabilities:
return (bits_get(val, (uint8_t *)&wif->drivercaps,
sizeof(wif->drivercaps)));
case LEAF_wlanIfParentCryptoCapabilities:
return (bits_get(val, (uint8_t *)&wif->cryptocaps,
sizeof(wif->cryptocaps)));
case LEAF_wlanIfParentHTCapabilities:
return (bits_get(val, (uint8_t *)&wif->htcaps,
sizeof(wif->htcaps)));
}
abort();
}
int
op_wlan_iface_config(struct snmp_context *ctx, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
int intval, vlen, rc;
char *strval;
struct wlan_iface *wif;
wlan_update_interface_list();
switch (op) {
case SNMP_OP_GET:
if ((wif = wlan_get_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
goto get_config;
case SNMP_OP_GETNEXT:
if ((wif = wlan_get_next_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_ifindex(&val->var, sub, wif);
goto get_config;
case SNMP_OP_SET:
if ((wif = wlan_get_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
intval = val->v.integer;
strval = NULL;
vlen = 0;
switch (val->var.subs[sub - 1]) {
case LEAF_wlanIfaceCountryCode:
if (val->v.octetstring.len != WLAN_COUNTRY_CODE_SIZE)
return (SNMP_ERR_INCONS_VALUE);
break;
case LEAF_wlanIfaceDesiredSsid:
if (val->v.octetstring.len > IEEE80211_NWID_LEN)
return (SNMP_ERR_INCONS_VALUE);
break;
case LEAF_wlanIfaceDesiredBssid:
if (val->v.octetstring.len != IEEE80211_ADDR_LEN)
return (SNMP_ERR_INCONS_VALUE);
break;
case LEAF_wlanIfacePacketBurst:
ctx->scratch->int1 = wif->packet_burst;
break;
case LEAF_wlanIfaceRegDomain:
ctx->scratch->int1 = wif->reg_domain;
break;
case LEAF_wlanIfaceDesiredChannel:
ctx->scratch->int1 = wif->desired_channel;
break;
case LEAF_wlanIfaceDynamicFreqSelection:
ctx->scratch->int1 = wif->dyn_frequency;
break;
case LEAF_wlanIfaceFastFrames:
ctx->scratch->int1 = wif->fast_frames;
break;
case LEAF_wlanIfaceDturbo:
ctx->scratch->int1 = wif->dturbo;
break;
case LEAF_wlanIfaceTxPower:
ctx->scratch->int1 = wif->tx_power;
break;
case LEAF_wlanIfaceFragmentThreshold:
ctx->scratch->int1 = wif->frag_threshold;
break;
case LEAF_wlanIfaceRTSThreshold:
ctx->scratch->int1 = wif->rts_threshold;
break;
case LEAF_wlanIfaceWlanPrivacySubscribe:
ctx->scratch->int1 = wif->priv_subscribe;
break;
case LEAF_wlanIfaceBgScan:
ctx->scratch->int1 = wif->bg_scan;
break;
case LEAF_wlanIfaceBgScanIdle:
ctx->scratch->int1 = wif->bg_scan_idle;
break;
case LEAF_wlanIfaceBgScanInterval:
ctx->scratch->int1 = wif->bg_scan_interval;
break;
case LEAF_wlanIfaceBeaconMissedThreshold:
ctx->scratch->int1 = wif->beacons_missed;
break;
case LEAF_wlanIfaceRoamingMode:
ctx->scratch->int1 = wif->roam_mode;
break;
case LEAF_wlanIfaceDot11d:
ctx->scratch->int1 = wif->dot11d;
break;
case LEAF_wlanIfaceDot11h:
ctx->scratch->int1 = wif->dot11h;
break;
case LEAF_wlanIfaceDynamicWds:
ctx->scratch->int1 = wif->dynamic_wds;
break;
case LEAF_wlanIfacePowerSave:
ctx->scratch->int1 = wif->power_save;
break;
case LEAF_wlanIfaceApBridge:
ctx->scratch->int1 = wif->ap_bridge;
break;
case LEAF_wlanIfaceBeaconInterval:
ctx->scratch->int1 = wif->beacon_interval;
break;
case LEAF_wlanIfaceDtimPeriod:
ctx->scratch->int1 = wif->dtim_period;
break;
case LEAF_wlanIfaceHideSsid:
ctx->scratch->int1 = wif->hide_ssid;
break;
case LEAF_wlanIfaceInactivityProccess:
ctx->scratch->int1 = wif->inact_process;
break;
case LEAF_wlanIfaceDot11gProtMode:
ctx->scratch->int1 = wif->do11g_protect;
break;
case LEAF_wlanIfaceDot11gPureMode:
ctx->scratch->int1 = wif->dot11g_pure;
break;
case LEAF_wlanIfaceDot11nPureMode:
ctx->scratch->int1 = wif->dot11n_pure;
break;
case LEAF_wlanIfaceDot11nAmpdu:
ctx->scratch->int1 = wif->ampdu;
break;
case LEAF_wlanIfaceDot11nAmpduDensity:
ctx->scratch->int1 = wif->ampdu_density;
break;
case LEAF_wlanIfaceDot11nAmpduLimit:
ctx->scratch->int1 = wif->ampdu_limit;
break;
case LEAF_wlanIfaceDot11nAmsdu:
ctx->scratch->int1 = wif->amsdu;
break;
case LEAF_wlanIfaceDot11nAmsduLimit:
ctx->scratch->int1 = wif->amsdu_limit;
break;
case LEAF_wlanIfaceDot11nHighThroughput:
ctx->scratch->int1 = wif->ht_enabled;
break;
case LEAF_wlanIfaceDot11nHTCompatible:
ctx->scratch->int1 = wif->ht_compatible;
break;
case LEAF_wlanIfaceDot11nHTProtMode:
ctx->scratch->int1 = wif->ht_prot_mode;
break;
case LEAF_wlanIfaceDot11nRIFS:
ctx->scratch->int1 = wif->rifs;
break;
case LEAF_wlanIfaceDot11nShortGI:
ctx->scratch->int1 = wif->short_gi;
break;
case LEAF_wlanIfaceDot11nSMPSMode:
ctx->scratch->int1 = wif->smps_mode;
break;
case LEAF_wlanIfaceTdmaSlot:
ctx->scratch->int1 = wif->tdma_slot;
break;
case LEAF_wlanIfaceTdmaSlotCount:
ctx->scratch->int1 = wif->tdma_slot_count;
break;
case LEAF_wlanIfaceTdmaSlotLength:
ctx->scratch->int1 = wif->tdma_slot_length;
break;
case LEAF_wlanIfaceTdmaBeaconInterval:
ctx->scratch->int1 = wif->tdma_binterval;
break;
default:
abort();
}
if (val->syntax != SNMP_SYNTAX_OCTETSTRING)
goto set_config;
ctx->scratch->int1 = val->v.octetstring.len;
ctx->scratch->ptr1 = malloc(val->v.octetstring.len + 1);
if (ctx->scratch->ptr1 == NULL)
return (SNMP_ERR_GENERR);
if (val->var.subs[sub - 1] == LEAF_wlanIfaceDesiredSsid)
strlcpy(ctx->scratch->ptr1, val->v.octetstring.octets,
val->v.octetstring.len + 1);
else
memcpy(ctx->scratch->ptr1, val->v.octetstring.octets,
val->v.octetstring.len);
strval = val->v.octetstring.octets;
vlen = val->v.octetstring.len;
goto set_config;
case SNMP_OP_ROLLBACK:
intval = ctx->scratch->int1;
strval = NULL;
vlen = 0;
if ((wif = wlan_get_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanIfaceCountryCode:
case LEAF_wlanIfaceDesiredSsid:
case LEAF_wlanIfaceDesiredBssid:
strval = ctx->scratch->ptr1;
vlen = ctx->scratch->int1;
break;
default:
break;
}
goto set_config;
case SNMP_OP_COMMIT:
switch (val->var.subs[sub - 1]) {
case LEAF_wlanIfaceCountryCode:
case LEAF_wlanIfaceDesiredSsid:
case LEAF_wlanIfaceDesiredBssid:
free(ctx->scratch->ptr1);
default:
return (SNMP_ERR_NOERROR);
}
}
abort();
get_config:
if (wlan_config_get_ioctl(wif, val->var.subs[sub - 1]) < 0)
return (SNMP_ERR_GENERR);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanIfacePacketBurst:
val->v.integer = wif->packet_burst;
break;
case LEAF_wlanIfaceCountryCode:
return (string_get(val, wif->country_code,
WLAN_COUNTRY_CODE_SIZE));
case LEAF_wlanIfaceRegDomain:
val->v.integer = wif->reg_domain;
break;
case LEAF_wlanIfaceDesiredSsid:
return (string_get(val, wif->desired_ssid, -1));
case LEAF_wlanIfaceDesiredChannel:
val->v.integer = wif->desired_channel;
break;
case LEAF_wlanIfaceDynamicFreqSelection:
val->v.integer = wif->dyn_frequency;
break;
case LEAF_wlanIfaceFastFrames:
val->v.integer = wif->fast_frames;
break;
case LEAF_wlanIfaceDturbo:
val->v.integer = wif->dturbo;
break;
case LEAF_wlanIfaceTxPower:
val->v.integer = wif->tx_power;
break;
case LEAF_wlanIfaceFragmentThreshold:
val->v.integer = wif->frag_threshold;
break;
case LEAF_wlanIfaceRTSThreshold:
val->v.integer = wif->rts_threshold;
break;
case LEAF_wlanIfaceWlanPrivacySubscribe:
val->v.integer = wif->priv_subscribe;
break;
case LEAF_wlanIfaceBgScan:
val->v.integer = wif->bg_scan;
break;
case LEAF_wlanIfaceBgScanIdle:
val->v.integer = wif->bg_scan_idle;
break;
case LEAF_wlanIfaceBgScanInterval:
val->v.integer = wif->bg_scan_interval;
break;
case LEAF_wlanIfaceBeaconMissedThreshold:
val->v.integer = wif->beacons_missed;
break;
case LEAF_wlanIfaceDesiredBssid:
return (string_get(val, wif->desired_bssid,
IEEE80211_ADDR_LEN));
case LEAF_wlanIfaceRoamingMode:
val->v.integer = wif->roam_mode;
break;
case LEAF_wlanIfaceDot11d:
val->v.integer = wif->dot11d;
break;
case LEAF_wlanIfaceDot11h:
val->v.integer = wif->dot11h;
break;
case LEAF_wlanIfaceDynamicWds:
val->v.integer = wif->dynamic_wds;
break;
case LEAF_wlanIfacePowerSave:
val->v.integer = wif->power_save;
break;
case LEAF_wlanIfaceApBridge:
val->v.integer = wif->ap_bridge;
break;
case LEAF_wlanIfaceBeaconInterval:
val->v.integer = wif->beacon_interval;
break;
case LEAF_wlanIfaceDtimPeriod:
val->v.integer = wif->dtim_period;
break;
case LEAF_wlanIfaceHideSsid:
val->v.integer = wif->hide_ssid;
break;
case LEAF_wlanIfaceInactivityProccess:
val->v.integer = wif->inact_process;
break;
case LEAF_wlanIfaceDot11gProtMode:
val->v.integer = wif->do11g_protect;
break;
case LEAF_wlanIfaceDot11gPureMode:
val->v.integer = wif->dot11g_pure;
break;
case LEAF_wlanIfaceDot11nPureMode:
val->v.integer = wif->dot11n_pure;
break;
case LEAF_wlanIfaceDot11nAmpdu:
val->v.integer = wif->ampdu;
break;
case LEAF_wlanIfaceDot11nAmpduDensity:
val->v.integer = wif->ampdu_density;
break;
case LEAF_wlanIfaceDot11nAmpduLimit:
val->v.integer = wif->ampdu_limit;
break;
case LEAF_wlanIfaceDot11nAmsdu:
val->v.integer = wif->amsdu;
break;
case LEAF_wlanIfaceDot11nAmsduLimit:
val->v.integer = wif->amsdu_limit;
break;
case LEAF_wlanIfaceDot11nHighThroughput:
val->v.integer = wif->ht_enabled;
break;
case LEAF_wlanIfaceDot11nHTCompatible:
val->v.integer = wif->ht_compatible;
break;
case LEAF_wlanIfaceDot11nHTProtMode:
val->v.integer = wif->ht_prot_mode;
break;
case LEAF_wlanIfaceDot11nRIFS:
val->v.integer = wif->rifs;
break;
case LEAF_wlanIfaceDot11nShortGI:
val->v.integer = wif->short_gi;
break;
case LEAF_wlanIfaceDot11nSMPSMode:
val->v.integer = wif->smps_mode;
break;
case LEAF_wlanIfaceTdmaSlot:
val->v.integer = wif->tdma_slot;
break;
case LEAF_wlanIfaceTdmaSlotCount:
val->v.integer = wif->tdma_slot_count;
break;
case LEAF_wlanIfaceTdmaSlotLength:
val->v.integer = wif->tdma_slot_length;
break;
case LEAF_wlanIfaceTdmaBeaconInterval:
val->v.integer = wif->tdma_binterval;
break;
}
return (SNMP_ERR_NOERROR);
set_config:
rc = wlan_config_set_ioctl(wif, val->var.subs[sub - 1], intval,
strval, vlen);
if (op == SNMP_OP_ROLLBACK) {
switch (val->var.subs[sub - 1]) {
case LEAF_wlanIfaceCountryCode:
case LEAF_wlanIfaceDesiredSsid:
case LEAF_wlanIfaceDesiredBssid:
free(ctx->scratch->ptr1);
default:
break;
}
}
if (rc < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
}
int
op_wlan_if_peer(struct snmp_context *ctx, struct snmp_value *val, uint32_t sub,
uint32_t iidx __unused, enum snmp_op op)
{
struct wlan_peer *wip;
struct wlan_iface *wif;
wlan_update_interface_list();
wlan_update_peers();
switch (op) {
case SNMP_OP_GET:
if ((wip = wlan_get_peer(&val->var, sub, &wif)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
if ((wip = wlan_get_next_peer(&val->var, sub, &wif)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_mac_index(&val->var, sub, wif->wname, wip->pmac);
break;
case SNMP_OP_SET:
if ((wip = wlan_get_peer(&val->var, sub, &wif)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
if (val->var.subs[sub - 1] != LEAF_wlanIfacePeerVlanTag)
return (SNMP_ERR_GENERR);
ctx->scratch->int1 = wip->vlan;
if (wlan_peer_set_vlan(wif, wip, val->v.integer) < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
case SNMP_OP_COMMIT:
return (SNMP_ERR_NOERROR);
case SNMP_OP_ROLLBACK:
if ((wip = wlan_get_peer(&val->var, sub, &wif)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
if (val->var.subs[sub - 1] != LEAF_wlanIfacePeerVlanTag)
return (SNMP_ERR_GENERR);
if (wlan_peer_set_vlan(wif, wip, ctx->scratch->int1) < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
default:
abort();
}
switch (val->var.subs[sub - 1]) {
case LEAF_wlanIfacePeerAddress:
return (string_get(val, wip->pmac, IEEE80211_ADDR_LEN));
case LEAF_wlanIfacePeerAssociationId:
val->v.integer = wip->associd;
break;
case LEAF_wlanIfacePeerVlanTag:
val->v.integer = wip->vlan;
break;
case LEAF_wlanIfacePeerFrequency:
val->v.integer = wip->frequency;
break;
case LEAF_wlanIfacePeerCurrentTXRate:
val->v.integer = wip->txrate;
break;
case LEAF_wlanIfacePeerRxSignalStrength:
val->v.integer = wip->rssi;
break;
case LEAF_wlanIfacePeerIdleTimer:
val->v.integer = wip->idle;
break;
case LEAF_wlanIfacePeerTxSequenceNo:
val->v.integer = wip->txseqs;
break;
case LEAF_wlanIfacePeerRxSequenceNo:
val->v.integer = wip->rxseqs;
break;
case LEAF_wlanIfacePeerTxPower:
val->v.integer = wip->txpower;
break;
case LEAF_wlanIfacePeerCapabilities:
return (bits_get(val, (uint8_t *)&wip->capinfo,
sizeof(wip->capinfo)));
case LEAF_wlanIfacePeerFlags:
return (bits_get(val, (uint8_t *)&wip->state,
sizeof(wip->state)));
default:
abort();
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_channels(struct snmp_context *ctx __unused, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
int32_t bits;
struct ieee80211_channel *channel;
struct wlan_iface *wif;
wlan_update_interface_list();
wlan_update_channels();
switch (op) {
case SNMP_OP_GET:
if ((channel = wlan_get_channel(&val->var, sub, &wif)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
channel = wlan_get_next_channel(&val->var, sub, &wif);
if (channel == NULL || wif == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_channel_index(&val->var, sub, wif, channel);
break;
case SNMP_OP_SET:
return (SNMP_ERR_NOT_WRITEABLE);
case SNMP_OP_COMMIT:
case SNMP_OP_ROLLBACK:
default:
abort();
}
switch (val->var.subs[sub - 1]) {
case LEAF_wlanIfaceChannelIeeeId:
val->v.integer = channel->ic_ieee;
break;
case LEAF_wlanIfaceChannelType:
val->v.integer = wlan_get_channel_type(channel);
break;
case LEAF_wlanIfaceChannelFlags:
bits = wlan_channel_flags_to_snmp(channel->ic_flags);
return (bits_get(val, (uint8_t *)&bits, sizeof(bits)));
case LEAF_wlanIfaceChannelFrequency:
val->v.integer = channel->ic_freq;
break;
case LEAF_wlanIfaceChannelMaxRegPower:
val->v.integer = channel->ic_maxregpower;
break;
case LEAF_wlanIfaceChannelMaxTxPower:
val->v.integer = channel->ic_maxpower;
break;
case LEAF_wlanIfaceChannelMinTxPower:
val->v.integer = channel->ic_minpower;
break;
case LEAF_wlanIfaceChannelState:
bits = wlan_channel_state_to_snmp(channel->ic_state);
return (bits_get(val, (uint8_t *)&bits, sizeof(bits)));
case LEAF_wlanIfaceChannelHTExtension:
val->v.integer = channel->ic_extieee;
break;
case LEAF_wlanIfaceChannelMaxAntennaGain:
val->v.integer = channel->ic_maxantgain;
break;
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_roam_params(struct snmp_context *ctx __unused, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
uint32_t phy;
struct ieee80211_roamparam *rparam;
struct wlan_iface *wif;
wlan_update_interface_list();
wlan_update_roam_params();
switch (op) {
case SNMP_OP_GET:
rparam = wlan_get_roam_param(&val->var, sub, &wif);
if (rparam == NULL)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
rparam = wlan_get_next_roam_param(&val->var, sub, &wif, &phy);
if (rparam == NULL || wif == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_phy_index(&val->var, sub, wif->wname, phy);
break;
case SNMP_OP_SET:
return (SNMP_ERR_NOT_WRITEABLE);
case SNMP_OP_COMMIT:
case SNMP_OP_ROLLBACK:
default:
abort();
}
switch (val->var.subs[sub - 1]) {
case LEAF_wlanIfRoamRxSignalStrength:
val->v.integer = rparam->rssi/2;
break;
case LEAF_wlanIfRoamTxRateThreshold:
val->v.integer = rparam->rate/2;
break;
default:
abort();
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_tx_params(struct snmp_context *ctx, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
uint32_t phy;
struct ieee80211_txparam *txparam;
struct wlan_iface *wif;
wlan_update_interface_list();
wlan_update_tx_params();
switch (op) {
case SNMP_OP_GET:
txparam = wlan_get_tx_param(&val->var, sub, &wif, &phy);
if (txparam == NULL)
return (SNMP_ERR_NOSUCHNAME);
goto get_txparams;
case SNMP_OP_GETNEXT:
txparam = wlan_get_next_tx_param(&val->var, sub, &wif, &phy);
if (txparam == NULL || wif == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_phy_index(&val->var, sub, wif->wname, phy);
goto get_txparams;
case SNMP_OP_SET:
txparam = wlan_get_tx_param(&val->var, sub, &wif, &phy);
if (txparam == NULL || wif == NULL)
return (SNMP_ERR_NOSUCHNAME);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanIfTxUnicastRate:
ctx->scratch->int1 = txparam->ucastrate;
txparam->ucastrate = val->v.integer * 2;
break;
case LEAF_wlanIfTxMcastRate:
ctx->scratch->int1 = txparam->mcastrate;
txparam->mcastrate = val->v.integer * 2;
break;
case LEAF_wlanIfTxMgmtRate:
ctx->scratch->int1 = txparam->mgmtrate;
txparam->mgmtrate = val->v.integer * 2;
break;
case LEAF_wlanIfTxMaxRetryCount:
ctx->scratch->int1 = txparam->maxretry;
txparam->maxretry = val->v.integer;
break;
default:
abort();
}
if (wlan_set_tx_params(wif, phy) < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
case SNMP_OP_COMMIT:
return (SNMP_ERR_NOERROR);
case SNMP_OP_ROLLBACK:
txparam = wlan_get_tx_param(&val->var, sub, &wif, &phy);
if (txparam == NULL || wif == NULL)
return (SNMP_ERR_NOSUCHNAME);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanIfTxUnicastRate:
txparam->ucastrate = ctx->scratch->int1;
break;
case LEAF_wlanIfTxMcastRate:
txparam->mcastrate = ctx->scratch->int1;
break;
case LEAF_wlanIfTxMgmtRate:
txparam->mgmtrate = ctx->scratch->int1;
break;
case LEAF_wlanIfTxMaxRetryCount:
txparam->maxretry = ctx->scratch->int1;
break;
default:
abort();
}
if (wlan_set_tx_params(wif, phy) < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
default:
abort();
}
get_txparams:
switch (val->var.subs[sub - 1]) {
case LEAF_wlanIfTxUnicastRate:
val->v.integer = txparam->ucastrate / 2;
break;
case LEAF_wlanIfTxMcastRate:
val->v.integer = txparam->mcastrate / 2;
break;
case LEAF_wlanIfTxMgmtRate:
val->v.integer = txparam->mgmtrate / 2;
break;
case LEAF_wlanIfTxMaxRetryCount:
val->v.integer = txparam->maxretry;
break;
default:
abort();
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_scan_config(struct snmp_context *ctx, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
struct wlan_iface *wif;
wlan_update_interface_list();
switch (op) {
case SNMP_OP_GET:
if ((wif = wlan_get_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
if ((wif = wlan_get_next_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_ifindex(&val->var, sub, wif);
break;
case SNMP_OP_SET:
if ((wif = wlan_get_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
if (wif->scan_status == wlanScanConfigStatus_running
&& val->var.subs[sub - 1] != LEAF_wlanScanConfigStatus)
return (SNMP_ERR_INCONS_VALUE);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanScanFlags:
ctx->scratch->int1 = wif->scan_flags;
wif->scan_flags = val->v.integer;
break;
case LEAF_wlanScanDuration:
ctx->scratch->int1 = wif->scan_duration;
wif->scan_duration = val->v.integer;
break;
case LEAF_wlanScanMinChannelDwellTime:
ctx->scratch->int1 = wif->scan_mindwell;
wif->scan_mindwell = val->v.integer;
break;
case LEAF_wlanScanMaxChannelDwellTime:
ctx->scratch->int1 = wif->scan_maxdwell;
wif->scan_maxdwell = val->v.integer;
break;
case LEAF_wlanScanConfigStatus:
if (val->v.integer == wlanScanConfigStatus_running ||
val->v.integer == wlanScanConfigStatus_cancel) {
ctx->scratch->int1 = wif->scan_status;
wif->scan_status = val->v.integer;
break;
}
return (SNMP_ERR_INCONS_VALUE);
}
return (SNMP_ERR_NOERROR);
case SNMP_OP_COMMIT:
if ((wif = wlan_get_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
if (val->var.subs[sub - 1] == LEAF_wlanScanConfigStatus)
if (wif->scan_status == wlanScanConfigStatus_running)
(void)wlan_set_scan_config(wif);
return (SNMP_ERR_NOERROR);
case SNMP_OP_ROLLBACK:
if ((wif = wlan_get_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanScanFlags:
wif->scan_flags = ctx->scratch->int1;
break;
case LEAF_wlanScanDuration:
wif->scan_duration = ctx->scratch->int1;
break;
case LEAF_wlanScanMinChannelDwellTime:
wif->scan_mindwell = ctx->scratch->int1;
break;
case LEAF_wlanScanMaxChannelDwellTime:
wif->scan_maxdwell = ctx->scratch->int1;
break;
case LEAF_wlanScanConfigStatus:
wif->scan_status = ctx->scratch->int1;
break;
}
return (SNMP_ERR_NOERROR);
default:
abort();
}
switch (val->var.subs[sub - 1]) {
case LEAF_wlanScanFlags:
val->v.integer = wif->scan_flags;
break;
case LEAF_wlanScanDuration:
val->v.integer = wif->scan_duration;
break;
case LEAF_wlanScanMinChannelDwellTime:
val->v.integer = wif->scan_mindwell;
break;
case LEAF_wlanScanMaxChannelDwellTime:
val->v.integer = wif->scan_maxdwell;
break;
case LEAF_wlanScanConfigStatus:
val->v.integer = wif->scan_status;
break;
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_scan_results(struct snmp_context *ctx __unused, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
struct wlan_scan_result *sr;
struct wlan_iface *wif;
wlan_update_interface_list();
wlan_scan_update_results();
switch (op) {
case SNMP_OP_GET:
if ((sr = wlan_get_scanr(&val->var, sub, &wif)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
if ((sr = wlan_get_next_scanr(&val->var, sub, &wif)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_scanr_index(&val->var, sub, wif->wname, sr->ssid,
sr->bssid);
break;
case SNMP_OP_SET:
return (SNMP_ERR_NOT_WRITEABLE);
case SNMP_OP_COMMIT:
case SNMP_OP_ROLLBACK:
default:
abort();
}
switch (val->var.subs[sub - 1]) {
case LEAF_wlanScanResultID:
return (string_get(val, sr->ssid, -1));
case LEAF_wlanScanResultBssid:
return (string_get(val, sr->bssid, IEEE80211_ADDR_LEN));
case LEAF_wlanScanResultChannel:
val->v.integer = sr->opchannel;
break;
case LEAF_wlanScanResultRate:
val->v.integer = sr->rssi;
break;
case LEAF_wlanScanResultNoise:
val->v.integer = sr->noise;
break;
case LEAF_wlanScanResultBeaconInterval:
val->v.integer = sr->bintval;
break;
case LEAF_wlanScanResultCapabilities:
return (bits_get(val, &sr->capinfo, sizeof(sr->capinfo)));
default:
abort();
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_iface_stats(struct snmp_context *ctx __unused, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
struct wlan_iface *wif;
wlan_update_interface_list();
switch (op) {
case SNMP_OP_GET:
if ((wif = wlan_get_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
if ((wif = wlan_get_next_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_ifindex(&val->var, sub, wif);
break;
case SNMP_OP_SET:
return (SNMP_ERR_NOT_WRITEABLE);
case SNMP_OP_COMMIT:
case SNMP_OP_ROLLBACK:
default:
abort();
}
if (wlan_get_stats(wif) < 0)
return (SNMP_ERR_GENERR);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanStatsRxBadVersion:
val->v.uint32 = wif->stats.is_rx_badversion;
break;
case LEAF_wlanStatsRxTooShort:
val->v.uint32 = wif->stats.is_rx_tooshort;
break;
case LEAF_wlanStatsRxWrongBssid:
val->v.uint32 = wif->stats.is_rx_wrongbss;
break;
case LEAF_wlanStatsRxDiscardedDups:
val->v.uint32 = wif->stats.is_rx_dup;
break;
case LEAF_wlanStatsRxWrongDir:
val->v.uint32 = wif->stats.is_rx_wrongdir;
break;
case LEAF_wlanStatsRxDiscardMcastEcho:
val->v.uint32 = wif->stats.is_rx_mcastecho;
break;
case LEAF_wlanStatsRxDiscardNoAssoc:
val->v.uint32 = wif->stats.is_rx_notassoc;
break;
case LEAF_wlanStatsRxWepNoPrivacy:
val->v.uint32 = wif->stats.is_rx_noprivacy;
break;
case LEAF_wlanStatsRxWepUnencrypted:
val->v.uint32 = wif->stats.is_rx_unencrypted;
break;
case LEAF_wlanStatsRxWepFailed:
val->v.uint32 = wif->stats.is_rx_wepfail;
break;
case LEAF_wlanStatsRxDecapsulationFailed:
val->v.uint32 = wif->stats.is_rx_decap;
break;
case LEAF_wlanStatsRxDiscardMgmt:
val->v.uint32 = wif->stats.is_rx_mgtdiscard;
break;
case LEAF_wlanStatsRxControl:
val->v.uint32 = wif->stats.is_rx_ctl;
break;
case LEAF_wlanStatsRxBeacon:
val->v.uint32 = wif->stats.is_rx_beacon;
break;
case LEAF_wlanStatsRxRateSetTooBig:
val->v.uint32 = wif->stats.is_rx_rstoobig;
break;
case LEAF_wlanStatsRxElemMissing:
val->v.uint32 = wif->stats.is_rx_elem_missing;
break;
case LEAF_wlanStatsRxElemTooBig:
val->v.uint32 = wif->stats.is_rx_elem_toobig;
break;
case LEAF_wlanStatsRxElemTooSmall:
val->v.uint32 = wif->stats.is_rx_elem_toosmall;
break;
case LEAF_wlanStatsRxElemUnknown:
val->v.uint32 = wif->stats.is_rx_elem_unknown;
break;
case LEAF_wlanStatsRxChannelMismatch:
val->v.uint32 = wif->stats.is_rx_chanmismatch;
break;
case LEAF_wlanStatsRxDropped:
val->v.uint32 = wif->stats.is_rx_nodealloc;
break;
case LEAF_wlanStatsRxSsidMismatch:
val->v.uint32 = wif->stats.is_rx_ssidmismatch;
break;
case LEAF_wlanStatsRxAuthNotSupported:
val->v.uint32 = wif->stats.is_rx_auth_unsupported;
break;
case LEAF_wlanStatsRxAuthFailed:
val->v.uint32 = wif->stats.is_rx_auth_fail;
break;
case LEAF_wlanStatsRxAuthCM:
val->v.uint32 = wif->stats.is_rx_auth_countermeasures;
break;
case LEAF_wlanStatsRxAssocWrongBssid:
val->v.uint32 = wif->stats.is_rx_assoc_bss;
break;
case LEAF_wlanStatsRxAssocNoAuth:
val->v.uint32 = wif->stats.is_rx_assoc_notauth;
break;
case LEAF_wlanStatsRxAssocCapMismatch:
val->v.uint32 = wif->stats.is_rx_assoc_capmismatch;
break;
case LEAF_wlanStatsRxAssocNoRateMatch:
val->v.uint32 = wif->stats.is_rx_assoc_norate;
break;
case LEAF_wlanStatsRxBadWpaIE:
val->v.uint32 = wif->stats.is_rx_assoc_badwpaie;
break;
case LEAF_wlanStatsRxDeauthenticate:
val->v.uint32 = wif->stats.is_rx_deauth;
break;
case LEAF_wlanStatsRxDisassociate:
val->v.uint32 = wif->stats.is_rx_disassoc;
break;
case LEAF_wlanStatsRxUnknownSubtype:
val->v.uint32 = wif->stats.is_rx_badsubtype;
break;
case LEAF_wlanStatsRxFailedNoBuf:
val->v.uint32 = wif->stats.is_rx_nobuf;
break;
case LEAF_wlanStatsRxBadAuthRequest:
val->v.uint32 = wif->stats.is_rx_bad_auth;
break;
case LEAF_wlanStatsRxUnAuthorized:
val->v.uint32 = wif->stats.is_rx_unauth;
break;
case LEAF_wlanStatsRxBadKeyId:
val->v.uint32 = wif->stats.is_rx_badkeyid;
break;
case LEAF_wlanStatsRxCCMPSeqViolation:
val->v.uint32 = wif->stats.is_rx_ccmpreplay;
break;
case LEAF_wlanStatsRxCCMPBadFormat:
val->v.uint32 = wif->stats.is_rx_ccmpformat;
break;
case LEAF_wlanStatsRxCCMPFailedMIC:
val->v.uint32 = wif->stats.is_rx_ccmpmic;
break;
case LEAF_wlanStatsRxTKIPSeqViolation:
val->v.uint32 = wif->stats.is_rx_tkipreplay;
break;
case LEAF_wlanStatsRxTKIPBadFormat:
val->v.uint32 = wif->stats.is_rx_tkipformat;
break;
case LEAF_wlanStatsRxTKIPFailedMIC:
val->v.uint32 = wif->stats.is_rx_tkipmic;
break;
case LEAF_wlanStatsRxTKIPFailedICV:
val->v.uint32 = wif->stats.is_rx_tkipicv;
break;
case LEAF_wlanStatsRxDiscardACL:
val->v.uint32 = wif->stats.is_rx_acl;
break;
case LEAF_wlanStatsTxFailedNoBuf:
val->v.uint32 = wif->stats.is_tx_nobuf;
break;
case LEAF_wlanStatsTxFailedNoNode:
val->v.uint32 = wif->stats.is_tx_nonode;
break;
case LEAF_wlanStatsTxUnknownMgmt:
val->v.uint32 = wif->stats.is_tx_unknownmgt;
break;
case LEAF_wlanStatsTxBadCipher:
val->v.uint32 = wif->stats.is_tx_badcipher;
break;
case LEAF_wlanStatsTxNoDefKey:
val->v.uint32 = wif->stats.is_tx_nodefkey;
break;
case LEAF_wlanStatsTxFragmented:
val->v.uint32 = wif->stats.is_tx_fragframes;
break;
case LEAF_wlanStatsTxFragmentsCreated:
val->v.uint32 = wif->stats.is_tx_frags;
break;
case LEAF_wlanStatsActiveScans:
val->v.uint32 = wif->stats.is_scan_active;
break;
case LEAF_wlanStatsPassiveScans:
val->v.uint32 = wif->stats.is_scan_passive;
break;
case LEAF_wlanStatsTimeoutInactivity:
val->v.uint32 = wif->stats.is_node_timeout;
break;
case LEAF_wlanStatsCryptoNoMem:
val->v.uint32 = wif->stats.is_crypto_nomem;
break;
case LEAF_wlanStatsSwCryptoTKIP:
val->v.uint32 = wif->stats.is_crypto_tkip;
break;
case LEAF_wlanStatsSwCryptoTKIPEnMIC:
val->v.uint32 = wif->stats.is_crypto_tkipenmic;
break;
case LEAF_wlanStatsSwCryptoTKIPDeMIC:
val->v.uint32 = wif->stats.is_crypto_tkipdemic;
break;
case LEAF_wlanStatsCryptoTKIPCM:
val->v.uint32 = wif->stats.is_crypto_tkipcm;
break;
case LEAF_wlanStatsSwCryptoCCMP:
val->v.uint32 = wif->stats.is_crypto_ccmp;
break;
case LEAF_wlanStatsSwCryptoWEP:
val->v.uint32 = wif->stats.is_crypto_wep;
break;
case LEAF_wlanStatsCryptoCipherKeyRejected:
val->v.uint32 = wif->stats.is_crypto_setkey_cipher;
break;
case LEAF_wlanStatsCryptoNoKey:
val->v.uint32 = wif->stats.is_crypto_setkey_nokey;
break;
case LEAF_wlanStatsCryptoDeleteKeyFailed:
val->v.uint32 = wif->stats.is_crypto_delkey;
break;
case LEAF_wlanStatsCryptoUnknownCipher:
val->v.uint32 = wif->stats.is_crypto_badcipher;
break;
case LEAF_wlanStatsCryptoAttachFailed:
val->v.uint32 = wif->stats.is_crypto_attachfail;
break;
case LEAF_wlanStatsCryptoKeyFailed:
val->v.uint32 = wif->stats.is_crypto_keyfail;
break;
case LEAF_wlanStatsCryptoEnMICFailed:
val->v.uint32 = wif->stats.is_crypto_enmicfail;
break;
case LEAF_wlanStatsIBSSCapMismatch:
val->v.uint32 = wif->stats.is_ibss_capmismatch;
break;
case LEAF_wlanStatsUnassocStaPSPoll:
val->v.uint32 = wif->stats.is_ps_unassoc;
break;
case LEAF_wlanStatsBadAidPSPoll:
val->v.uint32 = wif->stats.is_ps_badaid;
break;
case LEAF_wlanStatsEmptyPSPoll:
val->v.uint32 = wif->stats.is_ps_qempty;
break;
case LEAF_wlanStatsRxFFBadHdr:
val->v.uint32 = wif->stats.is_ff_badhdr;
break;
case LEAF_wlanStatsRxFFTooShort:
val->v.uint32 = wif->stats.is_ff_tooshort;
break;
case LEAF_wlanStatsRxFFSplitError:
val->v.uint32 = wif->stats.is_ff_split;
break;
case LEAF_wlanStatsRxFFDecap:
val->v.uint32 = wif->stats.is_ff_decap;
break;
case LEAF_wlanStatsTxFFEncap:
val->v.uint32 = wif->stats.is_ff_encap;
break;
case LEAF_wlanStatsRxBadBintval:
val->v.uint32 = wif->stats.is_rx_badbintval;
break;
case LEAF_wlanStatsRxDemicFailed:
val->v.uint32 = wif->stats.is_rx_demicfail;
break;
case LEAF_wlanStatsRxDefragFailed:
val->v.uint32 = wif->stats.is_rx_defrag;
break;
case LEAF_wlanStatsRxMgmt:
val->v.uint32 = wif->stats.is_rx_mgmt;
break;
case LEAF_wlanStatsRxActionMgmt:
val->v.uint32 = wif->stats.is_rx_action;
break;
case LEAF_wlanStatsRxAMSDUTooShort:
val->v.uint32 = wif->stats.is_amsdu_tooshort;
break;
case LEAF_wlanStatsRxAMSDUSplitError:
val->v.uint32 = wif->stats.is_amsdu_split;
break;
case LEAF_wlanStatsRxAMSDUDecap:
val->v.uint32 = wif->stats.is_amsdu_decap;
break;
case LEAF_wlanStatsTxAMSDUEncap:
val->v.uint32 = wif->stats.is_amsdu_encap;
break;
case LEAF_wlanStatsAMPDUBadBAR:
val->v.uint32 = wif->stats.is_ampdu_bar_bad;
break;
case LEAF_wlanStatsAMPDUOowBar:
val->v.uint32 = wif->stats.is_ampdu_bar_oow;
break;
case LEAF_wlanStatsAMPDUMovedBAR:
val->v.uint32 = wif->stats.is_ampdu_bar_move;
break;
case LEAF_wlanStatsAMPDURxBAR:
val->v.uint32 = wif->stats.is_ampdu_bar_rx;
break;
case LEAF_wlanStatsAMPDURxOor:
val->v.uint32 = wif->stats.is_ampdu_rx_oor;
break;
case LEAF_wlanStatsAMPDURxCopied:
val->v.uint32 = wif->stats.is_ampdu_rx_copy;
break;
case LEAF_wlanStatsAMPDURxDropped:
val->v.uint32 = wif->stats.is_ampdu_rx_drop;
break;
case LEAF_wlanStatsTxDiscardBadState:
val->v.uint32 = wif->stats.is_tx_badstate;
break;
case LEAF_wlanStatsTxFailedNoAssoc:
val->v.uint32 = wif->stats.is_tx_notassoc;
break;
case LEAF_wlanStatsTxClassifyFailed:
val->v.uint32 = wif->stats.is_tx_classify;
break;
case LEAF_wlanStatsDwdsMcastDiscard:
val->v.uint32 = wif->stats.is_dwds_mcast;
break;
case LEAF_wlanStatsHTAssocRejectNoHT:
val->v.uint32 = wif->stats.is_ht_assoc_nohtcap;
break;
case LEAF_wlanStatsHTAssocDowngrade:
val->v.uint32 = wif->stats.is_ht_assoc_downgrade;
break;
case LEAF_wlanStatsHTAssocRateMismatch:
val->v.uint32 = wif->stats.is_ht_assoc_norate;
break;
case LEAF_wlanStatsAMPDURxAge:
val->v.uint32 = wif->stats.is_ampdu_rx_age;
break;
case LEAF_wlanStatsAMPDUMoved:
val->v.uint32 = wif->stats.is_ampdu_rx_move;
break;
case LEAF_wlanStatsADDBADisabledReject:
val->v.uint32 = wif->stats.is_addba_reject;
break;
case LEAF_wlanStatsADDBANoRequest:
val->v.uint32 = wif->stats.is_addba_norequest;
break;
case LEAF_wlanStatsADDBABadToken:
val->v.uint32 = wif->stats.is_addba_badtoken;
break;
case LEAF_wlanStatsADDBABadPolicy:
val->v.uint32 = wif->stats.is_addba_badpolicy;
break;
case LEAF_wlanStatsAMPDUStopped:
val->v.uint32 = wif->stats.is_ampdu_stop;
break;
case LEAF_wlanStatsAMPDUStopFailed:
val->v.uint32 = wif->stats.is_ampdu_stop_failed;
break;
case LEAF_wlanStatsAMPDURxReorder:
val->v.uint32 = wif->stats.is_ampdu_rx_reorder;
break;
case LEAF_wlanStatsScansBackground:
val->v.uint32 = wif->stats.is_scan_bg;
break;
case LEAF_wlanLastDeauthReason:
val->v.uint32 = wif->stats.is_rx_deauth_code;
break;
case LEAF_wlanLastDissasocReason:
val->v.uint32 = wif->stats.is_rx_disassoc_code;
break;
case LEAF_wlanLastAuthFailReason:
val->v.uint32 = wif->stats.is_rx_authfail_code;
break;
case LEAF_wlanStatsBeaconMissedEvents:
val->v.uint32 = wif->stats.is_beacon_miss;
break;
case LEAF_wlanStatsRxDiscardBadStates:
val->v.uint32 = wif->stats.is_rx_badstate;
break;
case LEAF_wlanStatsFFFlushed:
val->v.uint32 = wif->stats.is_ff_flush;
break;
case LEAF_wlanStatsTxControlFrames:
val->v.uint32 = wif->stats.is_tx_ctl;
break;
case LEAF_wlanStatsAMPDURexmt:
val->v.uint32 = wif->stats.is_ampdu_rexmt;
break;
case LEAF_wlanStatsAMPDURexmtFailed:
val->v.uint32 = wif->stats.is_ampdu_rexmt_fail;
break;
case LEAF_wlanStatsReset:
val->v.uint32 = wlanStatsReset_no_op;
break;
default:
abort();
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_wep_iface(struct snmp_context *ctx, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
struct wlan_iface *wif;
wlan_update_interface_list();
switch (op) {
case SNMP_OP_GET:
if ((wif = wlan_get_interface(&val->var, sub)) == NULL ||
!wif->wepsupported)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
if ((wif = wlan_get_next_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_ifindex(&val->var, sub, wif);
break;
case SNMP_OP_SET:
if ((wif = wlan_get_interface(&val->var, sub)) == NULL ||
!wif->wepsupported)
return (SNMP_ERR_NOSUCHNAME);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanWepMode:
if (val->v.integer < wlanWepMode_off ||
val->v.integer > wlanWepMode_mixed)
return (SNMP_ERR_INCONS_VALUE);
ctx->scratch->int1 = wif->wepmode;
wif->wepmode = val->v.integer;
if (wlan_set_wepmode(wif) < 0) {
wif->wepmode = ctx->scratch->int1;
return (SNMP_ERR_GENERR);
}
break;
case LEAF_wlanWepDefTxKey:
if (val->v.integer < 0 ||
val->v.integer > IEEE80211_WEP_NKID)
return (SNMP_ERR_INCONS_VALUE);
ctx->scratch->int1 = wif->weptxkey;
wif->weptxkey = val->v.integer;
if (wlan_set_weptxkey(wif) < 0) {
wif->weptxkey = ctx->scratch->int1;
return (SNMP_ERR_GENERR);
}
break;
default:
abort();
}
return (SNMP_ERR_NOERROR);
case SNMP_OP_COMMIT:
return (SNMP_ERR_NOERROR);
case SNMP_OP_ROLLBACK:
if ((wif = wlan_get_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanWepMode:
wif->wepmode = ctx->scratch->int1;
if (wlan_set_wepmode(wif) < 0)
return (SNMP_ERR_GENERR);
break;
case LEAF_wlanWepDefTxKey:
wif->weptxkey = ctx->scratch->int1;
if (wlan_set_weptxkey(wif) < 0)
return (SNMP_ERR_GENERR);
break;
default:
abort();
}
return (SNMP_ERR_NOERROR);
default:
abort();
}
switch (val->var.subs[sub - 1]) {
case LEAF_wlanWepMode:
if (wlan_get_wepmode(wif) < 0)
return (SNMP_ERR_GENERR);
val->v.integer = wif->wepmode;
break;
case LEAF_wlanWepDefTxKey:
if (wlan_get_weptxkey(wif) < 0)
return (SNMP_ERR_GENERR);
val->v.integer = wif->weptxkey;
break;
default:
abort();
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_wep_key(struct snmp_context *ctx __unused,
struct snmp_value *val __unused, uint32_t sub __unused,
uint32_t iidx __unused, enum snmp_op op __unused)
{
return (SNMP_ERR_NOSUCHNAME);
}
int
op_wlan_mac_access_control(struct snmp_context *ctx, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
struct wlan_iface *wif;
wlan_update_interface_list();
switch (op) {
case SNMP_OP_GET:
if ((wif = wlan_get_interface(&val->var, sub)) == NULL ||
!wif->macsupported)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
if ((wif = wlan_get_next_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_ifindex(&val->var, sub, wif);
break;
case SNMP_OP_SET:
if ((wif = wlan_get_interface(&val->var, sub)) == NULL ||
!wif->macsupported)
return (SNMP_ERR_NOSUCHNAME);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMACAccessControlPolicy:
ctx->scratch->int1 = wif->mac_policy;
wif->mac_policy = val->v.integer;
break;
case LEAF_wlanMACAccessControlNacl:
return (SNMP_ERR_NOT_WRITEABLE);
case LEAF_wlanMACAccessControlFlush:
break;
default:
abort();
}
return (SNMP_ERR_NOERROR);
case SNMP_OP_COMMIT:
if ((wif = wlan_get_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMACAccessControlPolicy:
if (wlan_set_mac_policy(wif) < 0) {
wif->mac_policy = ctx->scratch->int1;
return (SNMP_ERR_GENERR);
}
break;
case LEAF_wlanMACAccessControlFlush:
if (wlan_flush_mac_mac(wif) < 0)
return (SNMP_ERR_GENERR);
break;
default:
abort();
}
return (SNMP_ERR_NOERROR);
case SNMP_OP_ROLLBACK:
if ((wif = wlan_get_interface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
if (val->var.subs[sub - 1] == LEAF_wlanMACAccessControlPolicy)
wif->mac_policy = ctx->scratch->int1;
return (SNMP_ERR_NOERROR);
default:
abort();
}
if (wlan_get_mac_policy(wif) < 0)
return (SNMP_ERR_GENERR);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMACAccessControlPolicy:
val->v.integer = wif->mac_policy;
break;
case LEAF_wlanMACAccessControlNacl:
val->v.integer = wif->mac_nacls;
break;
case LEAF_wlanMACAccessControlFlush:
val->v.integer = wlanMACAccessControlFlush_no_op;
break;
default:
abort();
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_mac_acl_mac(struct snmp_context *ctx, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
struct wlan_iface *wif;
struct wlan_mac_mac *macl;
wlan_update_interface_list();
wlan_mac_update_aclmacs();
switch (op) {
case SNMP_OP_GET:
if ((macl = wlan_get_acl_mac(&val->var, sub, &wif)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
if ((macl = wlan_get_next_acl_mac(&val->var, sub, &wif))
== NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_mac_index(&val->var, sub, wif->wname, macl->mac);
break;
case SNMP_OP_SET:
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMACAccessControlMAC:
return (SNMP_ERR_INCONS_NAME);
case LEAF_wlanMACAccessControlMACStatus:
return(wlan_acl_mac_set_status(ctx, val, sub));
default:
abort();
}
case SNMP_OP_COMMIT:
if ((macl = wlan_get_acl_mac(&val->var, sub, &wif)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
if (val->v.integer == RowStatus_destroy &&
wlan_mac_delete_mac(wif, macl) < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
case SNMP_OP_ROLLBACK:
if ((macl = wlan_get_acl_mac(&val->var, sub, &wif)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
if (ctx->scratch->int1 == RowStatus_destroy &&
wlan_mac_delete_mac(wif, macl) < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
default:
abort();
}
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMACAccessControlMAC:
return (string_get(val, macl->mac, IEEE80211_ADDR_LEN));
case LEAF_wlanMACAccessControlMACStatus:
val->v.integer = macl->mac_status;
break;
default:
abort();
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_mesh_config(struct snmp_context *ctx, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
int which;
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMeshMaxRetries:
which = WLAN_MESH_MAX_RETRIES;
break;
case LEAF_wlanMeshHoldingTimeout:
which = WLAN_MESH_HOLDING_TO;
break;
case LEAF_wlanMeshConfirmTimeout:
which = WLAN_MESH_CONFIRM_TO;
break;
case LEAF_wlanMeshRetryTimeout:
which = WLAN_MESH_RETRY_TO;
break;
default:
abort();
}
switch (op) {
case SNMP_OP_GET:
if (wlan_do_sysctl(&wlan_config, which, 0) < 0)
return (SNMP_ERR_GENERR);
break;
case SNMP_OP_GETNEXT:
abort();
case SNMP_OP_SET:
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMeshRetryTimeout :
ctx->scratch->int1 = wlan_config.mesh_retryto;
wlan_config.mesh_retryto = val->v.integer;
break;
case LEAF_wlanMeshHoldingTimeout:
ctx->scratch->int1 = wlan_config.mesh_holdingto;
wlan_config.mesh_holdingto = val->v.integer;
break;
case LEAF_wlanMeshConfirmTimeout:
ctx->scratch->int1 = wlan_config.mesh_confirmto;
wlan_config.mesh_confirmto = val->v.integer;
break;
case LEAF_wlanMeshMaxRetries:
ctx->scratch->int1 = wlan_config.mesh_maxretries;
wlan_config.mesh_maxretries = val->v.integer;
break;
}
if (wlan_do_sysctl(&wlan_config, which, 1) < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
case SNMP_OP_COMMIT:
return (SNMP_ERR_NOERROR);
case SNMP_OP_ROLLBACK:
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMeshRetryTimeout:
wlan_config.mesh_retryto = ctx->scratch->int1;
break;
case LEAF_wlanMeshConfirmTimeout:
wlan_config.mesh_confirmto = ctx->scratch->int1;
break;
case LEAF_wlanMeshHoldingTimeout:
wlan_config.mesh_holdingto= ctx->scratch->int1;
break;
case LEAF_wlanMeshMaxRetries:
wlan_config.mesh_maxretries = ctx->scratch->int1;
break;
}
if (wlan_do_sysctl(&wlan_config, which, 1) < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
default:
abort();
}
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMeshRetryTimeout:
val->v.integer = wlan_config.mesh_retryto;
break;
case LEAF_wlanMeshHoldingTimeout:
val->v.integer = wlan_config.mesh_holdingto;
break;
case LEAF_wlanMeshConfirmTimeout:
val->v.integer = wlan_config.mesh_confirmto;
break;
case LEAF_wlanMeshMaxRetries:
val->v.integer = wlan_config.mesh_maxretries;
break;
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_mesh_iface(struct snmp_context *ctx, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
int rc;
struct wlan_iface *wif;
wlan_update_interface_list();
switch (op) {
case SNMP_OP_GET:
if ((wif = wlan_mesh_get_iface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
if ((wif = wlan_mesh_get_next_iface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_ifindex(&val->var, sub, wif);
break;
case SNMP_OP_SET:
if ((wif = wlan_mesh_get_iface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMeshId:
if (val->v.octetstring.len > IEEE80211_NWID_LEN)
return (SNMP_ERR_INCONS_VALUE);
ctx->scratch->ptr1 = malloc(val->v.octetstring.len + 1);
if (ctx->scratch->ptr1 == NULL)
return (SNMP_ERR_GENERR);
strlcpy(ctx->scratch->ptr1, wif->desired_ssid,
val->v.octetstring.len + 1);
ctx->scratch->int1 = strlen(wif->desired_ssid);
memcpy(wif->desired_ssid, val->v.octetstring.octets,
val->v.octetstring.len);
wif->desired_ssid[val->v.octetstring.len] = '\0';
break;
case LEAF_wlanMeshTTL:
ctx->scratch->int1 = wif->mesh_ttl;
wif->mesh_ttl = val->v.integer;
break;
case LEAF_wlanMeshPeeringEnabled:
ctx->scratch->int1 = wif->mesh_peering;
wif->mesh_peering = val->v.integer;
break;
case LEAF_wlanMeshForwardingEnabled:
ctx->scratch->int1 = wif->mesh_forwarding;
wif->mesh_forwarding = val->v.integer;
break;
case LEAF_wlanMeshMetric:
ctx->scratch->int1 = wif->mesh_metric;
wif->mesh_metric = val->v.integer;
break;
case LEAF_wlanMeshPath:
ctx->scratch->int1 = wif->mesh_path;
wif->mesh_path = val->v.integer;
break;
case LEAF_wlanMeshRoutesFlush:
if (val->v.integer != wlanMeshRoutesFlush_flush)
return (SNMP_ERR_INCONS_VALUE);
return (SNMP_ERR_NOERROR);
default:
abort();
}
if (val->var.subs[sub - 1] == LEAF_wlanMeshId)
rc = wlan_config_set_dssid(wif,
val->v.octetstring.octets, val->v.octetstring.len);
else
rc = wlan_mesh_config_set(wif, val->var.subs[sub - 1]);
if (rc < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
case SNMP_OP_COMMIT:
if ((wif = wlan_mesh_get_iface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
if (val->var.subs[sub - 1] == LEAF_wlanMeshRoutesFlush &&
wlan_mesh_flush_routes(wif) < 0)
return (SNMP_ERR_GENERR);
if (val->var.subs[sub - 1] == LEAF_wlanMeshId)
free(ctx->scratch->ptr1);
return (SNMP_ERR_NOERROR);
case SNMP_OP_ROLLBACK:
if ((wif = wlan_mesh_get_iface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMeshId:
strlcpy(wif->desired_ssid, ctx->scratch->ptr1,
IEEE80211_NWID_LEN);
free(ctx->scratch->ptr1);
break;
case LEAF_wlanMeshTTL:
wif->mesh_ttl = ctx->scratch->int1;
break;
case LEAF_wlanMeshPeeringEnabled:
wif->mesh_peering = ctx->scratch->int1;
break;
case LEAF_wlanMeshForwardingEnabled:
wif->mesh_forwarding = ctx->scratch->int1;
break;
case LEAF_wlanMeshMetric:
wif->mesh_metric = ctx->scratch->int1;
break;
case LEAF_wlanMeshPath:
wif->mesh_path = ctx->scratch->int1;
break;
case LEAF_wlanMeshRoutesFlush:
return (SNMP_ERR_NOERROR);
default:
abort();
}
if (val->var.subs[sub - 1] == LEAF_wlanMeshId)
rc = wlan_config_set_dssid(wif, wif->desired_ssid,
strlen(wif->desired_ssid));
else
rc = wlan_mesh_config_set(wif, val->var.subs[sub - 1]);
if (rc < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
default:
abort();
}
if (val->var.subs[sub - 1] == LEAF_wlanMeshId)
rc = wlan_config_get_dssid(wif);
else
rc = wlan_mesh_config_get(wif, val->var.subs[sub - 1]);
if (rc < 0)
return (SNMP_ERR_GENERR);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMeshId:
return (string_get(val, wif->desired_ssid, -1));
case LEAF_wlanMeshTTL:
val->v.integer = wif->mesh_ttl;
break;
case LEAF_wlanMeshPeeringEnabled:
val->v.integer = wif->mesh_peering;
break;
case LEAF_wlanMeshForwardingEnabled:
val->v.integer = wif->mesh_forwarding;
break;
case LEAF_wlanMeshMetric:
val->v.integer = wif->mesh_metric;
break;
case LEAF_wlanMeshPath:
val->v.integer = wif->mesh_path;
break;
case LEAF_wlanMeshRoutesFlush:
val->v.integer = wlanMeshRoutesFlush_no_op;
break;
default:
abort();
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_mesh_neighbor(struct snmp_context *ctx __unused, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
struct wlan_peer *wip;
struct wlan_iface *wif;
wlan_update_interface_list();
wlan_update_peers();
switch (op) {
case SNMP_OP_GET:
if ((wip = wlan_mesh_get_peer(&val->var, sub, &wif)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
wip = wlan_mesh_get_next_peer(&val->var, sub, &wif);
if (wip == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_mac_index(&val->var, sub, wif->wname,
wip->pmac);
break;
case SNMP_OP_SET:
return (SNMP_ERR_NOT_WRITEABLE);
case SNMP_OP_COMMIT:
case SNMP_OP_ROLLBACK:
default:
abort();
}
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMeshNeighborAddress:
return (string_get(val, wip->pmac, IEEE80211_ADDR_LEN));
case LEAF_wlanMeshNeighborFrequency:
val->v.integer = wip->frequency;
break;
case LEAF_wlanMeshNeighborLocalId:
val->v.integer = wip->local_id;
break;
case LEAF_wlanMeshNeighborPeerId:
val->v.integer = wip->peer_id;
break;
case LEAF_wlanMeshNeighborPeerState:
return (bits_get(val, (uint8_t *)&wip->state,
sizeof(wip->state)));
case LEAF_wlanMeshNeighborCurrentTXRate:
val->v.integer = wip->txrate;
break;
case LEAF_wlanMeshNeighborRxSignalStrength:
val->v.integer = wip->rssi;
break;
case LEAF_wlanMeshNeighborIdleTimer:
val->v.integer = wip->idle;
break;
case LEAF_wlanMeshNeighborTxSequenceNo:
val->v.integer = wip->txseqs;
break;
case LEAF_wlanMeshNeighborRxSequenceNo:
val->v.integer = wip->rxseqs;
break;
default:
abort();
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_mesh_route(struct snmp_context *ctx, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
struct wlan_mesh_route *wmr;
struct wlan_iface *wif;
wlan_update_interface_list();
wlan_mesh_update_routes();
switch (op) {
case SNMP_OP_GET:
if ((wmr = wlan_mesh_get_route(&val->var, sub, &wif)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
wmr = wlan_mesh_get_next_route(&val->var, sub, &wif);
if (wmr == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_mac_index(&val->var, sub, wif->wname,
wmr->imroute.imr_dest);
break;
case SNMP_OP_SET:
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMeshRouteDestination:
return (SNMP_ERR_INCONS_NAME);
case LEAF_wlanMeshRouteStatus:
return(wlan_mesh_route_set_status(ctx, val, sub));
default:
return (SNMP_ERR_NOT_WRITEABLE);
}
abort();
case SNMP_OP_COMMIT:
if ((wmr = wlan_mesh_get_route(&val->var, sub, &wif)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
if (val->v.integer == RowStatus_destroy &&
wlan_mesh_delete_route(wif, wmr) < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
case SNMP_OP_ROLLBACK:
if ((wmr = wlan_mesh_get_route(&val->var, sub, &wif)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
if (ctx->scratch->int1 == RowStatus_destroy &&
wlan_mesh_delete_route(wif, wmr) < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
default:
abort();
}
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMeshRouteDestination:
return (string_get(val, wmr->imroute.imr_dest,
IEEE80211_ADDR_LEN));
case LEAF_wlanMeshRouteNextHop:
return (string_get(val, wmr->imroute.imr_nexthop,
IEEE80211_ADDR_LEN));
case LEAF_wlanMeshRouteHops:
val->v.integer = wmr->imroute.imr_nhops;
break;
case LEAF_wlanMeshRouteMetric:
val->v.integer = wmr->imroute.imr_metric;
break;
case LEAF_wlanMeshRouteLifeTime:
val->v.integer = wmr->imroute.imr_lifetime;
break;
case LEAF_wlanMeshRouteLastMseq:
val->v.integer = wmr->imroute.imr_lastmseq;
break;
case LEAF_wlanMeshRouteFlags:
val->v.integer = 0;
if ((wmr->imroute.imr_flags &
IEEE80211_MESHRT_FLAGS_VALID) != 0)
val->v.integer |= (0x1 << wlanMeshRouteFlags_valid);
if ((wmr->imroute.imr_flags &
IEEE80211_MESHRT_FLAGS_PROXY) != 0)
val->v.integer |= (0x1 << wlanMeshRouteFlags_proxy);
return (bits_get(val, (uint8_t *)&val->v.integer,
sizeof(val->v.integer)));
case LEAF_wlanMeshRouteStatus:
val->v.integer = wmr->mroute_status;
break;
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_mesh_stats(struct snmp_context *ctx __unused, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
struct wlan_iface *wif;
wlan_update_interface_list();
switch (op) {
case SNMP_OP_GET:
if ((wif = wlan_mesh_get_iface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
if ((wif = wlan_mesh_get_next_iface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_ifindex(&val->var, sub, wif);
break;
case SNMP_OP_SET:
return (SNMP_ERR_NOT_WRITEABLE);
case SNMP_OP_COMMIT:
case SNMP_OP_ROLLBACK:
default:
abort();
}
if (wlan_get_stats(wif) < 0)
return (SNMP_ERR_GENERR);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMeshDroppedBadSta:
val->v.uint32 = wif->stats.is_mesh_wrongmesh;
break;
case LEAF_wlanMeshDroppedNoLink:
val->v.uint32 = wif->stats.is_mesh_nolink;
break;
case LEAF_wlanMeshNoFwdTtl:
val->v.uint32 = wif->stats.is_mesh_fwd_ttl;
break;
case LEAF_wlanMeshNoFwdBuf:
val->v.uint32 = wif->stats.is_mesh_fwd_nobuf;
break;
case LEAF_wlanMeshNoFwdTooShort:
val->v.uint32 = wif->stats.is_mesh_fwd_tooshort;
break;
case LEAF_wlanMeshNoFwdDisabled:
val->v.uint32 = wif->stats.is_mesh_fwd_disabled;
break;
case LEAF_wlanMeshNoFwdPathUnknown:
val->v.uint32 = wif->stats.is_mesh_fwd_nopath;
break;
case LEAF_wlanMeshDroppedBadAE:
val->v.uint32 = wif->stats.is_mesh_badae;
break;
case LEAF_wlanMeshRouteAddFailed:
val->v.uint32 = wif->stats.is_mesh_rtaddfailed;
break;
case LEAF_wlanMeshDroppedNoProxy:
val->v.uint32 = wif->stats.is_mesh_notproxy;
break;
case LEAF_wlanMeshDroppedMisaligned:
val->v.uint32 = wif->stats.is_rx_badalign;
break;
default:
abort();
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_hwmp_config(struct snmp_context *ctx, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
int which;
switch (val->var.subs[sub - 1]) {
case LEAF_wlanHWMPRouteInactiveTimeout:
which = WLAN_HWMP_INACTIVITY_TO;
break;
case LEAF_wlanHWMPRootAnnounceInterval:
which = WLAN_HWMP_RANN_INT;
break;
case LEAF_wlanHWMPRootInterval:
which = WLAN_HWMP_ROOT_INT;
break;
case LEAF_wlanHWMPRootTimeout:
which = WLAN_HWMP_ROOT_TO;
break;
case LEAF_wlanHWMPPathLifetime:
which = WLAN_HWMP_PATH_LIFETIME;
break;
case LEAF_wlanHWMPReplyForwardBit:
which = WLAN_HWMP_REPLY_FORWARD;
break;
case LEAF_wlanHWMPTargetOnlyBit:
which = WLAN_HWMP_TARGET_ONLY;
break;
default:
abort();
}
switch (op) {
case SNMP_OP_GET:
if (wlan_do_sysctl(&wlan_config, which, 0) < 0)
return (SNMP_ERR_GENERR);
break;
case SNMP_OP_GETNEXT:
abort();
case SNMP_OP_SET:
switch (val->var.subs[sub - 1]) {
case LEAF_wlanHWMPRouteInactiveTimeout:
ctx->scratch->int1 = wlan_config.hwmp_inact;
wlan_config.hwmp_inact = val->v.integer;
break;
case LEAF_wlanHWMPRootAnnounceInterval:
ctx->scratch->int1 = wlan_config.hwmp_rannint;
wlan_config.hwmp_rannint = val->v.integer;
break;
case LEAF_wlanHWMPRootInterval:
ctx->scratch->int1 = wlan_config.hwmp_rootint;
wlan_config.hwmp_rootint = val->v.integer;
break;
case LEAF_wlanHWMPRootTimeout:
ctx->scratch->int1 = wlan_config.hwmp_roottimeout;
wlan_config.hwmp_roottimeout = val->v.integer;
break;
case LEAF_wlanHWMPPathLifetime:
ctx->scratch->int1 = wlan_config.hwmp_pathlifetime;
wlan_config.hwmp_pathlifetime = val->v.integer;
break;
case LEAF_wlanHWMPReplyForwardBit:
ctx->scratch->int1 = wlan_config.hwmp_replyforward;
wlan_config.hwmp_replyforward = val->v.integer;
break;
case LEAF_wlanHWMPTargetOnlyBit:
ctx->scratch->int1 = wlan_config.hwmp_targetonly;
wlan_config.hwmp_targetonly = val->v.integer;
break;
}
if (wlan_do_sysctl(&wlan_config, which, 1) < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
case SNMP_OP_COMMIT:
return (SNMP_ERR_NOERROR);
case SNMP_OP_ROLLBACK:
switch (val->var.subs[sub - 1]) {
case LEAF_wlanHWMPRouteInactiveTimeout:
wlan_config.hwmp_inact = ctx->scratch->int1;
break;
case LEAF_wlanHWMPRootAnnounceInterval:
wlan_config.hwmp_rannint = ctx->scratch->int1;
break;
case LEAF_wlanHWMPRootInterval:
wlan_config.hwmp_rootint = ctx->scratch->int1;
break;
case LEAF_wlanHWMPRootTimeout:
wlan_config.hwmp_roottimeout = ctx->scratch->int1;
break;
case LEAF_wlanHWMPPathLifetime:
wlan_config.hwmp_pathlifetime = ctx->scratch->int1;
break;
case LEAF_wlanHWMPReplyForwardBit:
wlan_config.hwmp_replyforward = ctx->scratch->int1;
break;
case LEAF_wlanHWMPTargetOnlyBit:
wlan_config.hwmp_targetonly = ctx->scratch->int1;
break;
}
if (wlan_do_sysctl(&wlan_config, which, 1) < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
default:
abort();
}
switch (val->var.subs[sub - 1]) {
case LEAF_wlanHWMPRouteInactiveTimeout:
val->v.integer = wlan_config.hwmp_inact;
break;
case LEAF_wlanHWMPRootAnnounceInterval:
val->v.integer = wlan_config.hwmp_rannint;
break;
case LEAF_wlanHWMPRootInterval:
val->v.integer = wlan_config.hwmp_rootint;
break;
case LEAF_wlanHWMPRootTimeout:
val->v.integer = wlan_config.hwmp_roottimeout;
break;
case LEAF_wlanHWMPPathLifetime:
val->v.integer = wlan_config.hwmp_pathlifetime;
break;
case LEAF_wlanHWMPReplyForwardBit:
val->v.integer = wlan_config.hwmp_replyforward;
break;
case LEAF_wlanHWMPTargetOnlyBit:
val->v.integer = wlan_config.hwmp_targetonly;
break;
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_hwmp_iface(struct snmp_context *ctx, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
struct wlan_iface *wif;
wlan_update_interface_list();
switch (op) {
case SNMP_OP_GET:
if ((wif = wlan_mesh_get_iface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
if ((wif = wlan_mesh_get_next_iface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_ifindex(&val->var, sub, wif);
break;
case SNMP_OP_SET:
if ((wif = wlan_mesh_get_iface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanHWMPRootMode:
ctx->scratch->int1 = wif->hwmp_root_mode;
wif->hwmp_root_mode = val->v.integer;
break;
case LEAF_wlanHWMPMaxHops:
ctx->scratch->int1 = wif->hwmp_max_hops;
wif->hwmp_max_hops = val->v.integer;
break;
default:
abort();
}
if (wlan_hwmp_config_set(wif, val->var.subs[sub - 1]) < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
case SNMP_OP_COMMIT:
return (SNMP_ERR_NOERROR);
case SNMP_OP_ROLLBACK:
if ((wif = wlan_mesh_get_iface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanHWMPRootMode:
wif->hwmp_root_mode = ctx->scratch->int1;
break;
case LEAF_wlanHWMPMaxHops:
wif->hwmp_max_hops = ctx->scratch->int1;
break;
default:
abort();
}
if (wlan_hwmp_config_set(wif, val->var.subs[sub - 1]) < 0)
return (SNMP_ERR_GENERR);
return (SNMP_ERR_NOERROR);
default:
abort();
}
if (wlan_hwmp_config_get(wif, val->var.subs[sub - 1]) < 0)
return (SNMP_ERR_GENERR);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanHWMPRootMode:
val->v.integer = wif->hwmp_root_mode;
break;
case LEAF_wlanHWMPMaxHops:
val->v.integer = wif->hwmp_max_hops;
break;
default:
abort();
}
return (SNMP_ERR_NOERROR);
}
int
op_wlan_hwmp_stats(struct snmp_context *ctx __unused, struct snmp_value *val,
uint32_t sub, uint32_t iidx __unused, enum snmp_op op)
{
struct wlan_iface *wif;
wlan_update_interface_list();
switch (op) {
case SNMP_OP_GET:
if ((wif = wlan_mesh_get_iface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
break;
case SNMP_OP_GETNEXT:
if ((wif = wlan_mesh_get_next_iface(&val->var, sub)) == NULL)
return (SNMP_ERR_NOSUCHNAME);
wlan_append_ifindex(&val->var, sub, wif);
break;
case SNMP_OP_SET:
return (SNMP_ERR_NOT_WRITEABLE);
case SNMP_OP_COMMIT:
case SNMP_OP_ROLLBACK:
default:
abort();
}
if (wlan_get_stats(wif) < 0)
return (SNMP_ERR_GENERR);
switch (val->var.subs[sub - 1]) {
case LEAF_wlanMeshHWMPWrongSeqNo:
val->v.uint32 = wif->stats.is_hwmp_wrongseq;
break;
case LEAF_wlanMeshHWMPTxRootPREQ:
val->v.uint32 = wif->stats.is_hwmp_rootreqs;
break;
case LEAF_wlanMeshHWMPTxRootRANN:
val->v.uint32 = wif->stats.is_hwmp_rootrann;
break;
case LEAF_wlanMeshHWMPProxy:
val->v.uint32 = wif->stats.is_hwmp_proxy;
break;
default:
abort();
}
return (SNMP_ERR_NOERROR);
}
static int
bits_get(struct snmp_value *value, const u_char *ptr, ssize_t len)
{
int size;
if (ptr == NULL) {
value->v.octetstring.len = 0;
value->v.octetstring.octets = NULL;
return (SNMP_ERR_NOERROR);
}
for (size = len; size > 0; size--)
if (ptr[size - 1] != 0)
break;
if (size == 0)
size = 1;
value->v.octetstring.len = (u_long)size;
if ((value->v.octetstring.octets = malloc((size_t)size)) == NULL)
return (SNMP_ERR_RES_UNAVAIL);
memcpy(value->v.octetstring.octets, ptr, (size_t)size);
return (SNMP_ERR_NOERROR);
}
static void
wlan_free_interface(struct wlan_iface *wif)
{
wlan_free_peerlist(wif);
free(wif->chanlist);
wlan_scan_free_results(wif);
wlan_mac_free_maclist(wif);
wlan_mesh_free_routes(wif);
free(wif);
}
static void
wlan_free_iflist(void)
{
struct wlan_iface *w;
while ((w = SLIST_FIRST(&wlan_ifaces)) != NULL) {
SLIST_REMOVE_HEAD(&wlan_ifaces, w_if);
wlan_free_interface(w);
}
}
static struct wlan_iface *
wlan_find_interface(const char *wname)
{
struct wlan_iface *wif;
SLIST_FOREACH(wif, &wlan_ifaces, w_if)
if (strcmp(wif->wname, wname) == 0) {
if (wif->status != RowStatus_active)
return (NULL);
break;
}
return (wif);
}
static struct wlan_iface *
wlan_first_interface(void)
{
return (SLIST_FIRST(&wlan_ifaces));
}
static struct wlan_iface *
wlan_next_interface(struct wlan_iface *wif)
{
if (wif == NULL)
return (NULL);
return (SLIST_NEXT(wif, w_if));
}
static int
wlan_add_wif(struct wlan_iface *wif)
{
int cmp;
struct wlan_iface *temp, *prev;
if ((prev = SLIST_FIRST(&wlan_ifaces)) == NULL ||
strcmp(wif->wname, prev->wname) < 0) {
SLIST_INSERT_HEAD(&wlan_ifaces, wif, w_if);
return (0);
}
SLIST_FOREACH(temp, &wlan_ifaces, w_if) {
if ((cmp = strcmp(wif->wname, temp->wname)) <= 0)
break;
prev = temp;
}
if (temp == NULL)
SLIST_INSERT_AFTER(prev, wif, w_if);
else if (cmp > 0)
SLIST_INSERT_AFTER(temp, wif, w_if);
else {
syslog(LOG_ERR, "Wlan iface %s already in list", wif->wname);
return (-1);
}
return (0);
}
static struct wlan_iface *
wlan_new_wif(char *wname)
{
struct wlan_iface *wif;
for (wif = wlan_first_interface(); wif != NULL;
wif = wlan_next_interface(wif))
if (strcmp(wname, wif->wname) == 0) {
wif->internal = 0;
return (wif);
}
if ((wif = (struct wlan_iface *)malloc(sizeof(*wif))) == NULL)
return (NULL);
memset(wif, 0, sizeof(struct wlan_iface));
strlcpy(wif->wname, wname, IFNAMSIZ);
wif->status = RowStatus_notReady;
wif->state = wlanIfaceState_down;
wif->mode = WlanIfaceOperatingModeType_station;
if (wlan_add_wif(wif) < 0) {
free(wif);
return (NULL);
}
return (wif);
}
static void
wlan_delete_wif(struct wlan_iface *wif)
{
SLIST_REMOVE(&wlan_ifaces, wif, wlan_iface, w_if);
wlan_free_interface(wif);
}
static int
wlan_attach_newif(struct mibif *mif)
{
struct wlan_iface *wif;
if (mif->mib.ifmd_data.ifi_type != IFT_ETHER ||
wlan_check_media(mif->name) != IFM_IEEE80211)
return (0);
if ((wif = wlan_new_wif(mif->name)) == NULL)
return (-1);
(void)wlan_get_opmode(wif);
wif->index = mif->index;
wif->status = RowStatus_active;
(void)wlan_update_interface(wif);
return (0);
}
static int
wlan_iface_create(struct wlan_iface *wif)
{
int rc;
if ((rc = wlan_clone_create(wif)) == SNMP_ERR_NOERROR) {
wif->status = RowStatus_active;
if (wif->state == wlanIfaceState_up)
(void)wlan_config_state(wif, 1);
}
return (rc);
}
static int
wlan_iface_destroy(struct wlan_iface *wif)
{
int rc = SNMP_ERR_NOERROR;
if (wif->internal == 0)
rc = wlan_clone_destroy(wif);
if (rc == SNMP_ERR_NOERROR)
wlan_delete_wif(wif);
return (rc);
}
static int
wlan_update_interface(struct wlan_iface *wif)
{
int i;
(void)wlan_config_state(wif, 0);
(void)wlan_get_driver_caps(wif);
for (i = LEAF_wlanIfacePacketBurst;
i <= LEAF_wlanIfaceTdmaBeaconInterval; i++)
(void)wlan_config_get_ioctl(wif, i);
(void)wlan_get_stats(wif);
(void)wlan_get_channel_list(wif);
(void)wlan_get_roam_params(wif);
(void)wlan_get_tx_params(wif);
(void)wlan_get_scan_results(wif);
(void)wlan_get_wepmode(wif);
(void)wlan_get_weptxkey(wif);
(void)wlan_get_mac_policy(wif);
(void)wlan_get_mac_acl_macs(wif);
(void)wlan_get_peerinfo(wif);
if (wif->mode == WlanIfaceOperatingModeType_meshPoint) {
for (i = LEAF_wlanMeshTTL; i <= LEAF_wlanMeshPath; i++)
(void)wlan_mesh_config_get(wif, i);
(void)wlan_mesh_get_routelist(wif);
for (i = LEAF_wlanHWMPRootMode; i <= LEAF_wlanHWMPMaxHops; i++)
(void)wlan_hwmp_config_get(wif, i);
}
return (0);
}
static void
wlan_update_interface_list(void)
{
struct wlan_iface *wif, *twif;
if ((time(NULL) - wlan_iflist_age) <= WLAN_LIST_MAXAGE)
return;
SLIST_FOREACH_SAFE(wif, &wlan_ifaces, w_if, twif)
if (wif->status == RowStatus_active && wlan_get_opmode(wif) < 0)
wlan_delete_wif(wif);
wlan_iflist_age = time(NULL);
}
static void
wlan_append_ifindex(struct asn_oid *oid, uint sub, const struct wlan_iface *w)
{
uint32_t i;
oid->len = sub + strlen(w->wname) + 1;
oid->subs[sub] = strlen(w->wname);
for (i = 1; i <= strlen(w->wname); i++)
oid->subs[sub + i] = w->wname[i - 1];
}
static uint8_t *
wlan_get_ifname(const struct asn_oid *oid, uint sub, uint8_t *wname)
{
uint32_t i;
memset(wname, 0, IFNAMSIZ);
if (oid->len - sub != oid->subs[sub] + 1 || oid->subs[sub] >= IFNAMSIZ)
return (NULL);
for (i = 0; i < oid->subs[sub]; i++)
wname[i] = oid->subs[sub + i + 1];
wname[i] = '\0';
return (wname);
}
static struct wlan_iface *
wlan_get_interface(const struct asn_oid *oid, uint sub)
{
uint8_t wname[IFNAMSIZ];
if (wlan_get_ifname(oid, sub, wname) == NULL)
return (NULL);
return (wlan_find_interface(wname));
}
static struct wlan_iface *
wlan_get_next_interface(const struct asn_oid *oid, uint sub)
{
uint32_t i;
uint8_t wname[IFNAMSIZ];
struct wlan_iface *wif;
if (oid->len - sub == 0) {
for (wif = wlan_first_interface(); wif != NULL;
wif = wlan_next_interface(wif))
if (wif->status == RowStatus_active)
break;
return (wif);
}
if (oid->len - sub != oid->subs[sub] + 1 || oid->subs[sub] >= IFNAMSIZ)
return (NULL);
memset(wname, 0, IFNAMSIZ);
for (i = 0; i < oid->subs[sub]; i++)
wname[i] = oid->subs[sub + i + 1];
wname[i] = '\0';
if ((wif = wlan_find_interface(wname)) == NULL)
return (NULL);
while ((wif = wlan_next_interface(wif)) != NULL)
if (wif->status == RowStatus_active)
break;
return (wif);
}
static struct wlan_iface *
wlan_get_snmp_interface(const struct asn_oid *oid, uint sub)
{
uint8_t wname[IFNAMSIZ];
struct wlan_iface *wif;
if (wlan_get_ifname(oid, sub, wname) == NULL)
return (NULL);
for (wif = wlan_first_interface(); wif != NULL;
wif = wlan_next_interface(wif))
if (strcmp(wif->wname, wname) == 0)
break;
return (wif);
}
static struct wlan_iface *
wlan_get_next_snmp_interface(const struct asn_oid *oid, uint sub)
{
uint32_t i;
uint8_t wname[IFNAMSIZ];
struct wlan_iface *wif;
if (oid->len - sub == 0)
return (wlan_first_interface());
if (oid->len - sub != oid->subs[sub] + 1 || oid->subs[sub] >= IFNAMSIZ)
return (NULL);
memset(wname, 0, IFNAMSIZ);
for (i = 0; i < oid->subs[sub]; i++)
wname[i] = oid->subs[sub + i + 1];
wname[i] = '\0';
for (wif = wlan_first_interface(); wif != NULL;
wif = wlan_next_interface(wif))
if (strcmp(wif->wname, wname) == 0)
break;
return (wlan_next_interface(wif));
}
static int
wlan_mac_index_decode(const struct asn_oid *oid, uint sub,
char *wname, uint8_t *mac)
{
uint32_t i;
int mac_off;
if (oid->len - sub != oid->subs[sub] + 2 + IEEE80211_ADDR_LEN
|| oid->subs[sub] >= IFNAMSIZ)
return (-1);
for (i = 0; i < oid->subs[sub]; i++)
wname[i] = oid->subs[sub + i + 1];
wname[i] = '\0';
mac_off = sub + oid->subs[sub] + 1;
if (oid->subs[mac_off] != IEEE80211_ADDR_LEN)
return (-1);
for (i = 0; i < IEEE80211_ADDR_LEN; i++)
mac[i] = oid->subs[mac_off + i + 1];
return (0);
}
static void
wlan_append_mac_index(struct asn_oid *oid, uint sub, char *wname, uint8_t *mac)
{
uint32_t i;
oid->len = sub + strlen(wname) + IEEE80211_ADDR_LEN + 2;
oid->subs[sub] = strlen(wname);
for (i = 1; i <= strlen(wname); i++)
oid->subs[sub + i] = wname[i - 1];
sub += strlen(wname) + 1;
oid->subs[sub] = IEEE80211_ADDR_LEN;
for (i = 1; i <= IEEE80211_ADDR_LEN; i++)
oid->subs[sub + i] = mac[i - 1];
}
static int
wlan_phy_index_decode(const struct asn_oid *oid, uint sub, char *wname,
uint32_t *phy)
{
uint32_t i;
if (oid->len - sub != oid->subs[sub] + 2 || oid->subs[sub] >= IFNAMSIZ)
return (-1);
for (i = 0; i < oid->subs[sub]; i++)
wname[i] = oid->subs[sub + i + 1];
wname[i] = '\0';
*phy = oid->subs[sub + oid->subs[sub] + 1];
return (0);
}
static void
wlan_append_phy_index(struct asn_oid *oid, uint sub, char *wname, uint32_t phy)
{
uint32_t i;
oid->len = sub + strlen(wname) + 2;
oid->subs[sub] = strlen(wname);
for (i = 1; i <= strlen(wname); i++)
oid->subs[sub + i] = wname[i - 1];
oid->subs[sub + strlen(wname) + 1] = phy;
}
static void
wlan_free_peerlist(struct wlan_iface *wif)
{
struct wlan_peer *wip;
while ((wip = SLIST_FIRST(&wif->peerlist)) != NULL) {
SLIST_REMOVE_HEAD(&wif->peerlist, wp);
free(wip);
}
SLIST_INIT(&wif->peerlist);
}
static struct wlan_peer *
wlan_find_peer(struct wlan_iface *wif, uint8_t *peermac)
{
struct wlan_peer *wip;
SLIST_FOREACH(wip, &wif->peerlist, wp)
if (memcmp(wip->pmac, peermac, IEEE80211_ADDR_LEN) == 0)
break;
return (wip);
}
struct wlan_peer *
wlan_new_peer(const uint8_t *pmac)
{
struct wlan_peer *wip;
if ((wip = (struct wlan_peer *)malloc(sizeof(*wip))) == NULL)
return (NULL);
memset(wip, 0, sizeof(struct wlan_peer));
memcpy(wip->pmac, pmac, IEEE80211_ADDR_LEN);
return (wip);
}
void
wlan_free_peer(struct wlan_peer *wip)
{
free(wip);
}
int
wlan_add_peer(struct wlan_iface *wif, struct wlan_peer *wip)
{
struct wlan_peer *temp, *prev;
SLIST_FOREACH(temp, &wif->peerlist, wp)
if (memcmp(temp->pmac, wip->pmac, IEEE80211_ADDR_LEN) == 0)
return (-1);
if ((prev = SLIST_FIRST(&wif->peerlist)) == NULL ||
memcmp(wip->pmac, prev->pmac, IEEE80211_ADDR_LEN) < 0) {
SLIST_INSERT_HEAD(&wif->peerlist, wip, wp);
return (0);
}
SLIST_FOREACH(temp, &wif->peerlist, wp) {
if (memcmp(wip->pmac, temp->pmac, IEEE80211_ADDR_LEN) < 0)
break;
prev = temp;
}
SLIST_INSERT_AFTER(prev, wip, wp);
return (0);
}
static void
wlan_update_peers(void)
{
struct wlan_iface *wif;
if ((time(NULL) - wlan_peerlist_age) <= WLAN_LIST_MAXAGE)
return;
for (wif = wlan_first_interface(); wif != NULL;
wif = wlan_next_interface(wif)) {
if (wif->status != RowStatus_active)
continue;
wlan_free_peerlist(wif);
(void)wlan_get_peerinfo(wif);
}
wlan_peerlist_age = time(NULL);
}
static struct wlan_peer *
wlan_get_peer(const struct asn_oid *oid, uint sub, struct wlan_iface **wif)
{
char wname[IFNAMSIZ];
uint8_t pmac[IEEE80211_ADDR_LEN];
if (wlan_mac_index_decode(oid, sub, wname, pmac) < 0)
return (NULL);
if ((*wif = wlan_find_interface(wname)) == NULL)
return (NULL);
return (wlan_find_peer(*wif, pmac));
}
static struct wlan_peer *
wlan_get_next_peer(const struct asn_oid *oid, uint sub, struct wlan_iface **wif)
{
char wname[IFNAMSIZ];
char pmac[IEEE80211_ADDR_LEN];
struct wlan_peer *wip;
if (oid->len - sub == 0) {
for (*wif = wlan_first_interface(); *wif != NULL;
*wif = wlan_next_interface(*wif)) {
if ((*wif)->mode ==
WlanIfaceOperatingModeType_meshPoint)
continue;
wip = SLIST_FIRST(&(*wif)->peerlist);
if (wip != NULL)
return (wip);
}
return (NULL);
}
if (wlan_mac_index_decode(oid, sub, wname, pmac) < 0 ||
(*wif = wlan_find_interface(wname)) == NULL ||
(wip = wlan_find_peer(*wif, pmac)) == NULL)
return (NULL);
if ((wip = SLIST_NEXT(wip, wp)) != NULL)
return (wip);
while ((*wif = wlan_next_interface(*wif)) != NULL) {
if ((*wif)->mode == WlanIfaceOperatingModeType_meshPoint)
continue;
if ((wip = SLIST_FIRST(&(*wif)->peerlist)) != NULL)
break;
}
return (wip);
}
static void
wlan_update_channels(void)
{
struct wlan_iface *wif;
if ((time(NULL) - wlan_chanlist_age) <= WLAN_LIST_MAXAGE)
return;
for (wif = wlan_first_interface(); wif != NULL;
wif = wlan_next_interface(wif)) {
if (wif->status != RowStatus_active)
continue;
(void)wlan_get_channel_list(wif);
}
wlan_chanlist_age = time(NULL);
}
static int
wlan_channel_index_decode(const struct asn_oid *oid, uint sub, char *wname,
uint32_t *cindex)
{
uint32_t i;
if (oid->len - sub != oid->subs[sub] + 2 || oid->subs[sub] >= IFNAMSIZ)
return (-1);
for (i = 0; i < oid->subs[sub]; i++)
wname[i] = oid->subs[sub + i + 1];
wname[i] = '\0';
*cindex = oid->subs[sub + oid->subs[sub] + 1];
return (0);
}
static void
wlan_append_channel_index(struct asn_oid *oid, uint sub,
const struct wlan_iface *wif, const struct ieee80211_channel *channel)
{
uint32_t i;
oid->len = sub + strlen(wif->wname) + 2;
oid->subs[sub] = strlen(wif->wname);
for (i = 1; i <= strlen(wif->wname); i++)
oid->subs[sub + i] = wif->wname[i - 1];
oid->subs[sub + strlen(wif->wname) + 1] = (channel - wif->chanlist) + 1;
}
static int32_t
wlan_get_channel_type(struct ieee80211_channel *c)
{
if (IEEE80211_IS_CHAN_FHSS(c))
return (WlanChannelType_fhss);
if (IEEE80211_IS_CHAN_A(c))
return (WlanChannelType_dot11a);
if (IEEE80211_IS_CHAN_B(c))
return (WlanChannelType_dot11b);
if (IEEE80211_IS_CHAN_ANYG(c))
return (WlanChannelType_dot11g);
if (IEEE80211_IS_CHAN_HALF(c))
return (WlanChannelType_tenMHz);
if (IEEE80211_IS_CHAN_QUARTER(c))
return (WlanChannelType_fiveMHz);
if (IEEE80211_IS_CHAN_TURBO(c))
return (WlanChannelType_turbo);
if (IEEE80211_IS_CHAN_HT(c))
return (WlanChannelType_ht);
return (-1);
}
static struct ieee80211_channel *
wlan_find_channel(struct wlan_iface *wif, uint32_t cindex)
{
if (wif->chanlist == NULL || cindex > wif->nchannels)
return (NULL);
return (wif->chanlist + cindex - 1);
}
static struct ieee80211_channel *
wlan_get_channel(const struct asn_oid *oid, uint sub, struct wlan_iface **wif)
{
uint32_t cindex;
char wname[IFNAMSIZ];
if (wlan_channel_index_decode(oid, sub, wname, &cindex) < 0)
return (NULL);
if ((*wif = wlan_find_interface(wname)) == NULL)
return (NULL);
return (wlan_find_channel(*wif, cindex));
}
static struct ieee80211_channel *
wlan_get_next_channel(const struct asn_oid *oid, uint sub,
struct wlan_iface **wif)
{
uint32_t cindex;
char wname[IFNAMSIZ];
if (oid->len - sub == 0) {
for (*wif = wlan_first_interface(); *wif != NULL;
*wif = wlan_next_interface(*wif)) {
if ((*wif)->status != RowStatus_active)
continue;
if ((*wif)->nchannels != 0 && (*wif)->chanlist != NULL)
return ((*wif)->chanlist);
}
return (NULL);
}
if (wlan_channel_index_decode(oid, sub, wname, &cindex) < 0)
return (NULL);
if ((*wif = wlan_find_interface(wname)) == NULL)
return (NULL);
if (cindex < (*wif)->nchannels)
return ((*wif)->chanlist + cindex);
while ((*wif = wlan_next_interface(*wif)) != NULL)
if ((*wif)->status == RowStatus_active)
if ((*wif)->nchannels != 0 && (*wif)->chanlist != NULL)
return ((*wif)->chanlist);
return (NULL);
}
static void
wlan_update_roam_params(void)
{
struct wlan_iface *wif;
if ((time(NULL) - wlan_roamlist_age) <= WLAN_LIST_MAXAGE)
return;
for (wif = wlan_first_interface(); wif != NULL;
wif = wlan_next_interface(wif)) {
if (wif->status != RowStatus_active)
continue;
(void)wlan_get_roam_params(wif);
}
wlan_roamlist_age = time(NULL);
}
static struct ieee80211_roamparam *
wlan_get_roam_param(const struct asn_oid *oid, uint sub, struct wlan_iface **wif)
{
uint32_t phy;
char wname[IFNAMSIZ];
if (wlan_phy_index_decode(oid, sub, wname, &phy) < 0)
return (NULL);
if ((*wif = wlan_find_interface(wname)) == NULL)
return (NULL);
if (phy == 0 || phy > IEEE80211_MODE_MAX)
return (NULL);
return ((*wif)->roamparams.params + phy - 1);
}
static struct ieee80211_roamparam *
wlan_get_next_roam_param(const struct asn_oid *oid, uint sub,
struct wlan_iface **wif, uint32_t *phy)
{
char wname[IFNAMSIZ];
if (oid->len - sub == 0) {
for (*wif = wlan_first_interface(); *wif != NULL;
*wif = wlan_next_interface(*wif)) {
if ((*wif)->status != RowStatus_active)
continue;
*phy = 1;
return ((*wif)->roamparams.params);
}
return (NULL);
}
if (wlan_phy_index_decode(oid, sub, wname, phy) < 0)
return (NULL);
if (*phy == 0 || (*wif = wlan_find_interface(wname)) == NULL)
return (NULL);
if (++(*phy) <= IEEE80211_MODE_MAX)
return ((*wif)->roamparams.params + *phy - 1);
*phy = 1;
while ((*wif = wlan_next_interface(*wif)) != NULL)
if ((*wif)->status == RowStatus_active)
return ((*wif)->roamparams.params);
return (NULL);
}
static void
wlan_update_tx_params(void)
{
struct wlan_iface *wif;
if ((time(NULL) - wlan_tx_paramlist_age) <= WLAN_LIST_MAXAGE)
return;
for (wif = wlan_first_interface(); wif != NULL;
wif = wlan_next_interface(wif)) {
if (wif->status != RowStatus_active)
continue;
(void)wlan_get_tx_params(wif);
}
wlan_tx_paramlist_age = time(NULL);
}
static struct ieee80211_txparam *
wlan_get_tx_param(const struct asn_oid *oid, uint sub, struct wlan_iface **wif,
uint32_t *phy)
{
char wname[IFNAMSIZ];
if (wlan_phy_index_decode(oid, sub, wname, phy) < 0)
return (NULL);
if ((*wif = wlan_find_interface(wname)) == NULL)
return (NULL);
if (*phy == 0 || *phy > IEEE80211_MODE_MAX)
return (NULL);
return ((*wif)->txparams.params + *phy - 1);
}
static struct ieee80211_txparam *
wlan_get_next_tx_param(const struct asn_oid *oid, uint sub,
struct wlan_iface **wif, uint32_t *phy)
{
char wname[IFNAMSIZ];
if (oid->len - sub == 0) {
for (*wif = wlan_first_interface(); *wif != NULL;
*wif = wlan_next_interface(*wif)) {
if ((*wif)->status != RowStatus_active)
continue;
*phy = 1;
return ((*wif)->txparams.params);
}
return (NULL);
}
if (wlan_phy_index_decode(oid, sub, wname, phy) < 0)
return (NULL);
if (*phy == 0 || (*wif = wlan_find_interface(wname)) == NULL)
return (NULL);
if (++(*phy) <= IEEE80211_MODE_MAX)
return ((*wif)->txparams.params + *phy - 1);
*phy = 1;
while ((*wif = wlan_next_interface(*wif)) != NULL)
if ((*wif)->status == RowStatus_active)
return ((*wif)->txparams.params);
return (NULL);
}
static void
wlan_scan_free_results(struct wlan_iface *wif)
{
struct wlan_scan_result *sr;
while ((sr = SLIST_FIRST(&wif->scanlist)) != NULL) {
SLIST_REMOVE_HEAD(&wif->scanlist, wsr);
free(sr);
}
SLIST_INIT(&wif->scanlist);
}
static struct wlan_scan_result *
wlan_scan_find_result(struct wlan_iface *wif, uint8_t *ssid, uint8_t *bssid)
{
struct wlan_scan_result *sr;
SLIST_FOREACH(sr, &wif->scanlist, wsr)
if (strlen(ssid) == strlen(sr->ssid) &&
strcmp(sr->ssid, ssid) == 0 &&
memcmp(sr->bssid, bssid, IEEE80211_ADDR_LEN) == 0)
break;
return (sr);
}
struct wlan_scan_result *
wlan_scan_new_result(const uint8_t *ssid, const uint8_t *bssid)
{
struct wlan_scan_result *sr;
sr = (struct wlan_scan_result *)malloc(sizeof(*sr));
if (sr == NULL)
return (NULL);
memset(sr, 0, sizeof(*sr));
if (ssid[0] != '\0')
strlcpy(sr->ssid, ssid, IEEE80211_NWID_LEN + 1);
memcpy(sr->bssid, bssid, IEEE80211_ADDR_LEN);
return (sr);
}
void
wlan_scan_free_result(struct wlan_scan_result *sr)
{
free(sr);
}
static int
wlan_scan_compare_result(struct wlan_scan_result *sr1,
struct wlan_scan_result *sr2)
{
uint32_t i;
if (strlen(sr1->ssid) < strlen(sr2->ssid))
return (-1);
if (strlen(sr1->ssid) > strlen(sr2->ssid))
return (1);
for (i = 0; i < strlen(sr1->ssid) && i < strlen(sr2->ssid); i++) {
if (sr1->ssid[i] < sr2->ssid[i])
return (-1);
if (sr1->ssid[i] > sr2->ssid[i])
return (1);
}
for (i = 0; i < IEEE80211_ADDR_LEN; i++) {
if (sr1->bssid[i] < sr2->bssid[i])
return (-1);
if (sr1->bssid[i] > sr2->bssid[i])
return (1);
}
return (0);
}
int
wlan_scan_add_result(struct wlan_iface *wif, struct wlan_scan_result *sr)
{
struct wlan_scan_result *prev, *temp;
SLIST_FOREACH(temp, &wif->scanlist, wsr)
if (strlen(temp->ssid) == strlen(sr->ssid) &&
strcmp(sr->ssid, temp->ssid) == 0 &&
memcmp(sr->bssid, temp->bssid, IEEE80211_ADDR_LEN) == 0)
return (-1);
if ((prev = SLIST_FIRST(&wif->scanlist)) == NULL ||
wlan_scan_compare_result(sr, prev) < 0) {
SLIST_INSERT_HEAD(&wif->scanlist, sr, wsr);
return (0);
}
SLIST_FOREACH(temp, &wif->scanlist, wsr) {
if (wlan_scan_compare_result(sr, temp) < 0)
break;
prev = temp;
}
SLIST_INSERT_AFTER(prev, sr, wsr);
return (0);
}
static void
wlan_scan_update_results(void)
{
struct wlan_iface *wif;
if ((time(NULL) - wlan_scanlist_age) <= WLAN_LIST_MAXAGE)
return;
for (wif = wlan_first_interface(); wif != NULL;
wif = wlan_next_interface(wif)) {
if (wif->status != RowStatus_active)
continue;
wlan_scan_free_results(wif);
(void)wlan_get_scan_results(wif);
}
wlan_scanlist_age = time(NULL);
}
static int
wlan_scanr_index_decode(const struct asn_oid *oid, uint sub,
char *wname, uint8_t *ssid, uint8_t *bssid)
{
uint32_t i;
int offset;
if (oid->subs[sub] >= IFNAMSIZ)
return (-1);
for (i = 0; i < oid->subs[sub]; i++)
wname[i] = oid->subs[sub + i + 1];
wname[oid->subs[sub]] = '\0';
offset = sub + oid->subs[sub] + 1;
if (oid->subs[offset] > IEEE80211_NWID_LEN)
return (-1);
for (i = 0; i < oid->subs[offset]; i++)
ssid[i] = oid->subs[offset + i + 1];
ssid[i] = '\0';
offset = sub + oid->subs[sub] + oid->subs[offset] + 2;
if (oid->subs[offset] != IEEE80211_ADDR_LEN)
return (-1);
for (i = 0; i < IEEE80211_ADDR_LEN; i++)
bssid[i] = oid->subs[offset + i + 1];
return (0);
}
static void
wlan_append_scanr_index(struct asn_oid *oid, uint sub, char *wname,
uint8_t *ssid, uint8_t *bssid)
{
uint32_t i;
oid->len = sub + strlen(wname) + strlen(ssid) + IEEE80211_ADDR_LEN + 3;
oid->subs[sub] = strlen(wname);
for (i = 1; i <= strlen(wname); i++)
oid->subs[sub + i] = wname[i - 1];
sub += strlen(wname) + 1;
oid->subs[sub] = strlen(ssid);
for (i = 1; i <= strlen(ssid); i++)
oid->subs[sub + i] = ssid[i - 1];
sub += strlen(ssid) + 1;
oid->subs[sub] = IEEE80211_ADDR_LEN;
for (i = 1; i <= IEEE80211_ADDR_LEN; i++)
oid->subs[sub + i] = bssid[i - 1];
}
static struct wlan_scan_result *
wlan_get_scanr(const struct asn_oid *oid, uint sub, struct wlan_iface **wif)
{
char wname[IFNAMSIZ];
uint8_t ssid[IEEE80211_NWID_LEN + 1];
uint8_t bssid[IEEE80211_ADDR_LEN];
if (wlan_scanr_index_decode(oid, sub, wname, ssid, bssid) < 0)
return (NULL);
if ((*wif = wlan_find_interface(wname)) == NULL)
return (NULL);
return (wlan_scan_find_result(*wif, ssid, bssid));
}
static struct wlan_scan_result *
wlan_get_next_scanr(const struct asn_oid *oid, uint sub,
struct wlan_iface **wif)
{
char wname[IFNAMSIZ];
uint8_t ssid[IEEE80211_NWID_LEN + 1];
uint8_t bssid[IEEE80211_ADDR_LEN];
struct wlan_scan_result *sr;
if (oid->len - sub == 0) {
for (*wif = wlan_first_interface(); *wif != NULL;
*wif = wlan_next_interface(*wif)) {
sr = SLIST_FIRST(&(*wif)->scanlist);
if (sr != NULL)
return (sr);
}
return (NULL);
}
if (wlan_scanr_index_decode(oid, sub, wname, ssid, bssid) < 0 ||
(*wif = wlan_find_interface(wname)) == NULL ||
(sr = wlan_scan_find_result(*wif, ssid, bssid)) == NULL)
return (NULL);
if ((sr = SLIST_NEXT(sr, wsr)) != NULL)
return (sr);
while ((*wif = wlan_next_interface(*wif)) != NULL)
if ((sr = SLIST_FIRST(&(*wif)->scanlist)) != NULL)
break;
return (sr);
}
static void
wlan_mac_free_maclist(struct wlan_iface *wif)
{
struct wlan_mac_mac *wmm;
while ((wmm = SLIST_FIRST(&wif->mac_maclist)) != NULL) {
SLIST_REMOVE_HEAD(&wif->mac_maclist, wm);
free(wmm);
}
SLIST_INIT(&wif->mac_maclist);
}
static struct wlan_mac_mac *
wlan_mac_find_mac(struct wlan_iface *wif, uint8_t *mac)
{
struct wlan_mac_mac *wmm;
SLIST_FOREACH(wmm, &wif->mac_maclist, wm)
if (memcmp(wmm->mac, mac, IEEE80211_ADDR_LEN) == 0)
break;
return (wmm);
}
struct wlan_mac_mac *
wlan_mac_new_mac(const uint8_t *mac)
{
struct wlan_mac_mac *wmm;
if ((wmm = (struct wlan_mac_mac *)malloc(sizeof(*wmm))) == NULL)
return (NULL);
memset(wmm, 0, sizeof(*wmm));
memcpy(wmm->mac, mac, IEEE80211_ADDR_LEN);
wmm->mac_status = RowStatus_notReady;
return (wmm);
}
void
wlan_mac_free_mac(struct wlan_mac_mac *wmm)
{
free(wmm);
}
int
wlan_mac_add_mac(struct wlan_iface *wif, struct wlan_mac_mac *wmm)
{
struct wlan_mac_mac *temp, *prev;
SLIST_FOREACH(temp, &wif->mac_maclist, wm)
if (memcmp(temp->mac, wmm->mac, IEEE80211_ADDR_LEN) == 0)
return (-1);
if ((prev = SLIST_FIRST(&wif->mac_maclist)) == NULL ||
memcmp(wmm->mac, prev->mac,IEEE80211_ADDR_LEN) < 0) {
SLIST_INSERT_HEAD(&wif->mac_maclist, wmm, wm);
return (0);
}
SLIST_FOREACH(temp, &wif->mac_maclist, wm) {
if (memcmp(wmm->mac, temp->mac, IEEE80211_ADDR_LEN) < 0)
break;
prev = temp;
}
SLIST_INSERT_AFTER(prev, wmm, wm);
return (0);
}
static int
wlan_mac_delete_mac(struct wlan_iface *wif, struct wlan_mac_mac *wmm)
{
if (wmm->mac_status == RowStatus_active &&
wlan_del_mac_acl_mac(wif, wmm) < 0)
return (-1);
SLIST_REMOVE(&wif->mac_maclist, wmm, wlan_mac_mac, wm);
free(wmm);
return (0);
}
static void
wlan_mac_update_aclmacs(void)
{
struct wlan_iface *wif;
struct wlan_mac_mac *wmm, *twmm;
if ((time(NULL) - wlan_maclist_age) <= WLAN_LIST_MAXAGE)
return;
for (wif = wlan_first_interface(); wif != NULL;
wif = wlan_next_interface(wif)) {
if (wif->status != RowStatus_active)
continue;
SLIST_FOREACH_SAFE(wmm, &wif->mac_maclist, wm, twmm)
if (wmm->mac_status == RowStatus_active) {
SLIST_REMOVE(&wif->mac_maclist, wmm,
wlan_mac_mac, wm);
wlan_mac_free_mac(wmm);
}
(void)wlan_get_mac_acl_macs(wif);
}
wlan_maclist_age = time(NULL);
}
static struct wlan_mac_mac *
wlan_get_acl_mac(const struct asn_oid *oid, uint sub, struct wlan_iface **wif)
{
char wname[IFNAMSIZ];
char mac[IEEE80211_ADDR_LEN];
if (wlan_mac_index_decode(oid, sub, wname, mac) < 0)
return (NULL);
if ((*wif = wlan_find_interface(wname)) == NULL)
return (NULL);
return (wlan_mac_find_mac(*wif, mac));
}
static struct wlan_mac_mac *
wlan_get_next_acl_mac(const struct asn_oid *oid, uint sub,
struct wlan_iface **wif)
{
char wname[IFNAMSIZ];
char mac[IEEE80211_ADDR_LEN];
struct wlan_mac_mac *wmm;
if (oid->len - sub == 0) {
for (*wif = wlan_first_interface(); *wif != NULL;
*wif = wlan_next_interface(*wif)) {
wmm = SLIST_FIRST(&(*wif)->mac_maclist);
if (wmm != NULL)
return (wmm);
}
return (NULL);
}
if (wlan_mac_index_decode(oid, sub, wname, mac) < 0 ||
(*wif = wlan_find_interface(wname)) == NULL ||
(wmm = wlan_mac_find_mac(*wif, mac)) == NULL)
return (NULL);
if ((wmm = SLIST_NEXT(wmm, wm)) != NULL)
return (wmm);
while ((*wif = wlan_next_interface(*wif)) != NULL)
if ((wmm = SLIST_FIRST(&(*wif)->mac_maclist)) != NULL)
break;
return (wmm);
}
static int
wlan_acl_mac_set_status(struct snmp_context *ctx, struct snmp_value *val,
uint sub)
{
char wname[IFNAMSIZ];
uint8_t mac[IEEE80211_ADDR_LEN];
struct wlan_iface *wif;
struct wlan_mac_mac *macl;
if (wlan_mac_index_decode(&val->var, sub, wname, mac) < 0)
return (SNMP_ERR_GENERR);
macl = wlan_get_acl_mac(&val->var, sub, &wif);
switch (val->v.integer) {
case RowStatus_createAndGo:
if (macl != NULL)
return (SNMP_ERR_INCONS_NAME);
break;
case RowStatus_destroy:
if (macl == NULL)
return (SNMP_ERR_NOSUCHNAME);
ctx->scratch->int1 = RowStatus_active;
return (SNMP_ERR_NOERROR);
default:
return (SNMP_ERR_INCONS_VALUE);
}
if (wif == NULL || !wif->macsupported)
return (SNMP_ERR_INCONS_VALUE);
if ((macl = wlan_mac_new_mac((const uint8_t *)mac)) == NULL)
return (SNMP_ERR_GENERR);
ctx->scratch->int1 = RowStatus_destroy;
if (wlan_mac_add_mac(wif, macl) < 0) {
wlan_mac_free_mac(macl);
return (SNMP_ERR_GENERR);
}
ctx->scratch->int1 = RowStatus_destroy;
if (wlan_add_mac_acl_mac(wif, macl) < 0) {
(void)wlan_mac_delete_mac(wif, macl);
return (SNMP_ERR_GENERR);
}
return (SNMP_ERR_NOERROR);
}
static struct wlan_iface *
wlan_mesh_first_interface(void)
{
struct wlan_iface *wif;
SLIST_FOREACH(wif, &wlan_ifaces, w_if)
if (wif->mode == WlanIfaceOperatingModeType_meshPoint &&
wif->status == RowStatus_active)
break;
return (wif);
}
static struct wlan_iface *
wlan_mesh_next_interface(struct wlan_iface *wif)
{
struct wlan_iface *nwif;
while ((nwif = wlan_next_interface(wif)) != NULL) {
if (nwif->mode == WlanIfaceOperatingModeType_meshPoint &&
nwif->status == RowStatus_active)
break;
wif = nwif;
}
return (nwif);
}
static struct wlan_iface *
wlan_mesh_get_iface(const struct asn_oid *oid, uint sub)
{
struct wlan_iface *wif;
if ((wif = wlan_get_interface(oid, sub)) == NULL)
return (NULL);
if (wif->mode != WlanIfaceOperatingModeType_meshPoint)
return (NULL);
return (wif);
}
static struct wlan_iface *
wlan_mesh_get_next_iface(const struct asn_oid *oid, uint sub)
{
uint32_t i;
uint8_t wname[IFNAMSIZ];
struct wlan_iface *wif;
if (oid->len - sub == 0)
return (wlan_mesh_first_interface());
if (oid->len - sub != oid->subs[sub] + 1 || oid->subs[sub] >= IFNAMSIZ)
return (NULL);
memset(wname, 0, IFNAMSIZ);
for (i = 0; i < oid->subs[sub]; i++)
wname[i] = oid->subs[sub + i + 1];
wname[i] = '\0';
if ((wif = wlan_find_interface(wname)) == NULL)
return (NULL);
return (wlan_mesh_next_interface(wif));
}
static struct wlan_peer *
wlan_mesh_get_peer(const struct asn_oid *oid, uint sub, struct wlan_iface **wif)
{
char wname[IFNAMSIZ];
uint8_t pmac[IEEE80211_ADDR_LEN];
if (wlan_mac_index_decode(oid, sub, wname, pmac) < 0)
return (NULL);
if ((*wif = wlan_find_interface(wname)) == NULL ||
(*wif)->mode != WlanIfaceOperatingModeType_meshPoint)
return (NULL);
return (wlan_find_peer(*wif, pmac));
}
static struct wlan_peer *
wlan_mesh_get_next_peer(const struct asn_oid *oid, uint sub, struct wlan_iface **wif)
{
char wname[IFNAMSIZ];
char pmac[IEEE80211_ADDR_LEN];
struct wlan_peer *wip;
if (oid->len - sub == 0) {
for (*wif = wlan_mesh_first_interface(); *wif != NULL;
*wif = wlan_mesh_next_interface(*wif)) {
wip = SLIST_FIRST(&(*wif)->peerlist);
if (wip != NULL)
return (wip);
}
return (NULL);
}
if (wlan_mac_index_decode(oid, sub, wname, pmac) < 0 ||
(*wif = wlan_find_interface(wname)) == NULL ||
(*wif)->mode != WlanIfaceOperatingModeType_meshPoint ||
(wip = wlan_find_peer(*wif, pmac)) == NULL)
return (NULL);
if ((wip = SLIST_NEXT(wip, wp)) != NULL)
return (wip);
while ((*wif = wlan_mesh_next_interface(*wif)) != NULL)
if ((wip = SLIST_FIRST(&(*wif)->peerlist)) != NULL)
break;
return (wip);
}
static void
wlan_mesh_free_routes(struct wlan_iface *wif)
{
struct wlan_mesh_route *wmr;
while ((wmr = SLIST_FIRST(&wif->mesh_routelist)) != NULL) {
SLIST_REMOVE_HEAD(&wif->mesh_routelist, wr);
free(wmr);
}
SLIST_INIT(&wif->mesh_routelist);
}
static struct wlan_mesh_route *
wlan_mesh_find_route(struct wlan_iface *wif, uint8_t *dstmac)
{
struct wlan_mesh_route *wmr;
if (wif->mode != WlanIfaceOperatingModeType_meshPoint)
return (NULL);
SLIST_FOREACH(wmr, &wif->mesh_routelist, wr)
if (memcmp(wmr->imroute.imr_dest, dstmac,
IEEE80211_ADDR_LEN) == 0)
break;
return (wmr);
}
struct wlan_mesh_route *
wlan_mesh_new_route(const uint8_t *dstmac)
{
struct wlan_mesh_route *wmr;
if ((wmr = (struct wlan_mesh_route *)malloc(sizeof(*wmr))) == NULL)
return (NULL);
memset(wmr, 0, sizeof(*wmr));
memcpy(wmr->imroute.imr_dest, dstmac, IEEE80211_ADDR_LEN);
wmr->mroute_status = RowStatus_notReady;
return (wmr);
}
void
wlan_mesh_free_route(struct wlan_mesh_route *wmr)
{
free(wmr);
}
int
wlan_mesh_add_rtentry(struct wlan_iface *wif, struct wlan_mesh_route *wmr)
{
struct wlan_mesh_route *temp, *prev;
SLIST_FOREACH(temp, &wif->mesh_routelist, wr)
if (memcmp(temp->imroute.imr_dest, wmr->imroute.imr_dest,
IEEE80211_ADDR_LEN) == 0)
return (-1);
if ((prev = SLIST_FIRST(&wif->mesh_routelist)) == NULL ||
memcmp(wmr->imroute.imr_dest, prev->imroute.imr_dest,
IEEE80211_ADDR_LEN) < 0) {
SLIST_INSERT_HEAD(&wif->mesh_routelist, wmr, wr);
return (0);
}
SLIST_FOREACH(temp, &wif->mesh_routelist, wr) {
if (memcmp(wmr->imroute.imr_dest, temp->imroute.imr_dest,
IEEE80211_ADDR_LEN) < 0)
break;
prev = temp;
}
SLIST_INSERT_AFTER(prev, wmr, wr);
return (0);
}
static int
wlan_mesh_delete_route(struct wlan_iface *wif, struct wlan_mesh_route *wmr)
{
if (wmr->mroute_status == RowStatus_active &&
wlan_mesh_del_route(wif, wmr) < 0)
return (-1);
SLIST_REMOVE(&wif->mesh_routelist, wmr, wlan_mesh_route, wr);
free(wmr);
return (0);
}
static void
wlan_mesh_update_routes(void)
{
struct wlan_iface *wif;
struct wlan_mesh_route *wmr, *twmr;
if ((time(NULL) - wlan_mrlist_age) <= WLAN_LIST_MAXAGE)
return;
for (wif = wlan_mesh_first_interface(); wif != NULL;
wif = wlan_mesh_next_interface(wif)) {
SLIST_FOREACH_SAFE(wmr, &wif->mesh_routelist, wr, twmr)
if (wmr->mroute_status == RowStatus_active) {
SLIST_REMOVE(&wif->mesh_routelist, wmr,
wlan_mesh_route, wr);
wlan_mesh_free_route(wmr);
}
(void)wlan_mesh_get_routelist(wif);
}
wlan_mrlist_age = time(NULL);
}
static struct wlan_mesh_route *
wlan_mesh_get_route(const struct asn_oid *oid, uint sub, struct wlan_iface **wif)
{
char wname[IFNAMSIZ];
char dstmac[IEEE80211_ADDR_LEN];
if (wlan_mac_index_decode(oid, sub, wname, dstmac) < 0)
return (NULL);
if ((*wif = wlan_find_interface(wname)) == NULL)
return (NULL);
return (wlan_mesh_find_route(*wif, dstmac));
}
static struct wlan_mesh_route *
wlan_mesh_get_next_route(const struct asn_oid *oid, uint sub,
struct wlan_iface **wif)
{
char wname[IFNAMSIZ];
char dstmac[IEEE80211_ADDR_LEN];
struct wlan_mesh_route *wmr;
if (oid->len - sub == 0) {
for (*wif = wlan_mesh_first_interface(); *wif != NULL;
*wif = wlan_mesh_next_interface(*wif)) {
wmr = SLIST_FIRST(&(*wif)->mesh_routelist);
if (wmr != NULL)
return (wmr);
}
return (NULL);
}
if (wlan_mac_index_decode(oid, sub, wname, dstmac) < 0 ||
(*wif = wlan_find_interface(wname)) == NULL ||
(wmr = wlan_mesh_find_route(*wif, dstmac)) == NULL)
return (NULL);
if ((wmr = SLIST_NEXT(wmr, wr)) != NULL)
return (wmr);
while ((*wif = wlan_mesh_next_interface(*wif)) != NULL)
if ((wmr = SLIST_FIRST(&(*wif)->mesh_routelist)) != NULL)
break;
return (wmr);
}
static int
wlan_mesh_route_set_status(struct snmp_context *ctx, struct snmp_value *val,
uint sub)
{
char wname[IFNAMSIZ];
char mac[IEEE80211_ADDR_LEN];
struct wlan_mesh_route *wmr;
struct wlan_iface *wif;
if (wlan_mac_index_decode(&val->var, sub, wname, mac) < 0)
return (SNMP_ERR_GENERR);
wmr = wlan_mesh_get_route(&val->var, sub, &wif);
switch (val->v.integer) {
case RowStatus_createAndGo:
if (wmr != NULL)
return (SNMP_ERR_INCONS_NAME);
break;
case RowStatus_destroy:
if (wmr == NULL)
return (SNMP_ERR_NOSUCHNAME);
ctx->scratch->int1 = RowStatus_active;
return (SNMP_ERR_NOERROR);
default:
return (SNMP_ERR_INCONS_VALUE);
}
if ((wif = wlan_find_interface(wname)) == NULL)
return (SNMP_ERR_INCONS_NAME);
if ((wmr = wlan_mesh_new_route(mac)) == NULL)
return (SNMP_ERR_GENERR);
if (wlan_mesh_add_rtentry(wif, wmr) < 0) {
wlan_mesh_free_route(wmr);
return (SNMP_ERR_GENERR);
}
ctx->scratch->int1 = RowStatus_destroy;
if (wlan_mesh_add_route(wif, wmr) < 0) {
(void)wlan_mesh_delete_route(wif, wmr);
return (SNMP_ERR_GENERR);
}
return (SNMP_ERR_NOERROR);
}
static int
wlan_init(struct lmodule * mod __unused, int argc __unused,
char *argv[] __unused)
{
if (wlan_kmodules_load() < 0)
return (-1);
if (wlan_ioctl_init() < 0)
return (-1);
if (mib_register_newif(wlan_attach_newif, wlan_module)) {
syslog(LOG_ERR, "Cannot register newif function: %s",
strerror(errno));
return (-1);
}
return (0);
}
static int
wlan_fini(void)
{
mib_unregister_newif(wlan_module);
or_unregister(reg_wlan);
wlan_free_iflist();
return (0);
}
static void
wlan_update_data(void *arg __unused)
{
}
static void
wlan_start(void)
{
struct mibif *ifp;
reg_wlan = or_register(&oid_wlan,
"The MIB module for managing wireless networking.", wlan_module);
for (ifp = mib_first_if(); ifp != NULL; ifp = mib_next_if(ifp))
wlan_attach_newif(ifp);
wlan_data_timer = timer_start_repeat(wlan_poll_ticks,
wlan_poll_ticks, wlan_update_data, NULL, wlan_module);
}
static void
wlan_dump(void)
{
struct wlan_iface *wif;
for (wif = wlan_first_interface(); wif != NULL;
wif = wlan_next_interface(wif))
syslog(LOG_ERR, "wlan iface %s", wif->wname);
}
const char wlan_comment[] = \
"This module implements the BEGEMOT MIB for wireless networking.";
const struct snmp_module config = {
.comment = wlan_comment,
.init = wlan_init,
.fini = wlan_fini,
.start = wlan_start,
.tree = wlan_ctree,
.dump = wlan_dump,
.tree_size = wlan_CTREE_SIZE,
};
