def _handle_auth_request(self, wtp, request):
"""Handle an incoming AUTH_REQUEST message.
Args:
request, a AUTH_REQUEST message
Returns:
None
"""
if not wtp.connection:
LOG.info("Auth request from disconnected WTP %s", wtp.addr)
return
sta = EtherAddress(request.sta)
bssid = EtherAddress(request.bssid)
if sta not in RUNTIME.lvaps:
LOG.info("Auth request from unknown LVAP %s", sta)
return
lvap = RUNTIME.lvaps[sta]
if not RUNTIME.is_allowed(sta):
LOG.info("Auth request from %s ignored (white list)", sta)
return
if RUNTIME.is_denied(sta):
LOG.info("Auth request from %s ignored (black list)", sta)
return
lvap_bssid = None
# the request bssid is the lvap's unique bssid
if lvap.net_bssid == bssid:
lvap_bssid = lvap.net_bssid
# else if is a shared bssid
else:
shared_tenants = [x for x in RUNTIME.tenants.values()
if x.bssid_type == T_TYPE_SHARED]
wtp = RUNTIME.wtps[wtp.addr]
# look for bssid in shared tenants
for tenant in shared_tenants:
if bssid in tenant.vaps and tenant.vaps[bssid].wtp == wtp:
lvap_bssid = bssid
break
# invalid bssid, ignore request
if not lvap_bssid:
return
# this will trigger an add lvap message to update the bssid
lvap.lvap_bssid = lvap_bssid
LOG.info("Auth request from %s for BSSID %s, replying", sta, bssid)
self.send_auth_response(lvap)
def _handle_auth_request(self, wtp, request):
"""Handle an incoming AUTH_REQUEST message.
Args:
request, a AUTH_REQUEST message
Returns:
None
"""
if not wtp.connection:
LOG.info("Auth request from disconnected WTP %s", wtp.addr)
return
sta = EtherAddress(request.sta)
bssid = EtherAddress(request.bssid)
if sta not in RUNTIME.lvaps:
LOG.info("Auth request from unknown LVAP %s", sta)
return
lvap = RUNTIME.lvaps[sta]
if not RUNTIME.is_allowed(sta):
LOG.info("Auth request from %s ignored (white list)", sta)
return
if RUNTIME.is_denied(sta):
LOG.info("Auth request from %s ignored (black list)", sta)
return
lvap_bssid = None
# the request bssid is the lvap's unique bssid
if lvap.net_bssid == bssid:
lvap_bssid = lvap.net_bssid
# else if is a shared bssid
else:
shared_tenants = [x for x in RUNTIME.tenants.values()
if x.bssid_type == T_TYPE_SHARED]
wtp = RUNTIME.wtps[wtp.addr]
# look for bssid in shared tenants
for tenant in shared_tenants:
if bssid in tenant.vaps and tenant.vaps[bssid].wtp == wtp:
lvap_bssid = bssid
break
# invalid bssid, ignore request
if not lvap_bssid:
return
# this will trigger an add lvap message to update the bssid
lvap.lvap_bssid = lvap_bssid
LOG.info("Auth request from %s for BSSID %s, replying", sta, bssid)
self.send_auth_response(lvap)
def _handle_assoc_request(self, request):
"""Handle an incoming ASSOC_REQUEST message.
Args:
request, a ASSOC_REQUEST message
Returns:
None
"""
wtp_addr = EtherAddress(request.wtp)
try:
wtp = RUNTIME.wtps[wtp_addr]
except KeyError:
LOG.info("Assoc request from unknown WTP %s", wtp_addr)
return
if not wtp.connection:
LOG.info("Assoc request from disconnected WTP %s", wtp_addr)
return
sta = EtherAddress(request.sta)
if sta not in RUNTIME.lvaps:
LOG.info("Assoc request from unknown LVAP %s", sta)
return
lvap = RUNTIME.lvaps[sta]
if not RUNTIME.is_allowed(sta):
LOG.info("Assoc request from %s ignored (white list)", sta)
return
if RUNTIME.is_denied(sta):
LOG.info("Assoc request from %s ignored (black list)", sta)
return
ssid = SSID(request.ssid.decode('UTF-8'))
matches = [x for x in RUNTIME.tenants.values()
if SSID(x.tenant_name) == ssid]
if not matches:
LOG.info("Assoc request to unknown SSID: %s ", request.ssid)
return
# this will trigger an add lvap message to update the ssid
lvap.ssid = ssid
# this will trigger an add lvap message to update the assoc id
lvap.assoc_id = self.server.assoc_id
LOG.info("Assoc request sta %s assoc id %u ssid %s, sending response",
lvap.addr,
lvap.assoc_id,
lvap.ssid)
self.send_assoc_response(lvap)
def _handle_auth_request(self, request):
"""Handle an incoming AUTH_REQUEST message.
Args:
request, a AUTH_REQUEST message
Returns:
None
"""
wtp_addr = EtherAddress(request.wtp)
try:
wtp = RUNTIME.wtps[wtp_addr]
except KeyError:
LOG.info("Auth request from unknown WTP %s", wtp_addr)
return
if not wtp.connection:
LOG.info("Auth request from disconnected WTP %s", wtp_addr)
return
sta = EtherAddress(request.sta)
if sta not in RUNTIME.lvaps:
LOG.info("Auth request from unknown LVAP %s", sta)
return
lvap = RUNTIME.lvaps[sta]
if not RUNTIME.is_allowed(sta):
LOG.info("Auth request from %s ignored (white list)", sta)
return
if RUNTIME.is_denied(sta):
LOG.info("Auth request from %s ignored (black list)", sta)
return
LOG.info("Auth request from %s, sending auth response", sta)
self.send_auth_response(lvap)
def _handle_assoc_request(self, request):
"""Handle an incoming ASSOC_REQUEST message.
Args:
request, a ASSOC_REQUEST message
Returns:
None
"""
wtp_addr = EtherAddress(request.wtp)
try:
wtp = RUNTIME.wtps[wtp_addr]
except KeyError:
LOG.info("Assoc request from unknown WTP %s", wtp_addr)
return
if not wtp.connection:
LOG.info("Assoc request from disconnected WTP %s", wtp_addr)
return
sta = EtherAddress(request.sta)
if sta not in RUNTIME.lvaps:
LOG.info("Assoc request from unknown LVAP %s", sta)
return
lvap = RUNTIME.lvaps[sta]
if not RUNTIME.is_allowed(sta):
LOG.info("Assoc request from %s ignored (white list)", sta)
return
if RUNTIME.is_denied(sta):
LOG.info("Assoc request from %s ignored (black list)", sta)
return
ssid = SSID(request.ssid.decode('UTF-8'))
bssid = EtherAddress(request.bssid)
tenant_name = None
# look for ssid in shared tenants
for tenant_id in RUNTIME.tenants:
tenant = RUNTIME.tenants[tenant_id]
if tenant.bssid_type == T_TYPE_UNIQUE:
continue
if bssid in tenant.vaps and ssid == tenant.tenant_name:
tenant_name = tenant.tenant_name
# otherwise this must be the lvap unique bssid
if lvap.net_bssid == bssid and ssid in lvap.ssids:
tenant_name = ssid
if not tenant_name:
LOG.info("Assoc request sta %s for ssid %s bssid %s, ignoring",
lvap.addr, lvap.ssid, lvap.lvap_bssid)
return
# this will trigger an add lvap message to update the ssid
lvap.tenant = RUNTIME.load_tenant(tenant_name)
# this will trigger an add lvap message to update the assoc id
lvap.assoc_id = self.server.assoc_id
LOG.info("Assoc request sta %s ssid %s bssid %s assoc id %u, replying",
lvap.addr, lvap.ssid, lvap.lvap_bssid, lvap.assoc_id)
self.send_assoc_response(lvap)
def _handle_probe_request(self, request):
"""Handle an incoming PROBE_REQUEST message.
Args:
request, a PROBE_REQUEST message
Returns:
None
"""
wtp_addr = EtherAddress(request.wtp)
try:
wtp = RUNTIME.wtps[wtp_addr]
except KeyError:
LOG.info("Probe request from unknown WTP (%s)", wtp_addr)
return
if not wtp.connection:
LOG.info("Probe request from disconnected WTP %s", wtp_addr)
return
sta = EtherAddress(request.sta)
if sta in RUNTIME.lvaps:
return
if not RUNTIME.is_allowed(sta):
return
if RUNTIME.is_denied(sta):
return
ssid = SSID(request.ssid)
if request.ssid == b'':
LOG.info("Probe request from %s ssid %s", sta, "Broadcast")
else:
LOG.info("Probe request from %s ssid %s", sta, ssid)
# generate list of available SSIDs
ssids = set()
for tenant in RUNTIME.tenants.values():
if tenant.bssid_type == T_TYPE_SHARED:
continue
for wtp_in_tenant in tenant.wtps.values():
if wtp_addr == wtp_in_tenant.addr:
ssids.add(tenant.tenant_name)
if not ssids:
LOG.info("No SSIDs available at this WTP")
return
# spawn new LVAP
LOG.info("Spawning new LVAP %s on %s", sta, wtp.addr)
net_bssid = generate_bssid(BASE_MAC, sta)
lvap = LVAP(sta, net_bssid, net_bssid)
lvap._ssids = ssids
RUNTIME.lvaps[sta] = lvap
# TODO: This should be built starting from the probe request
lvap.supports.add(ResourceBlock(lvap, sta, 1, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 2, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 3, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 4, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 5, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 6, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 7, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 8, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 9, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 10, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 11, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 36, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 48, BT_L20))
# This will trigger an LVAP ADD message (and REMOVE if necessary)
requested = ResourcePool()
hwaddr = EtherAddress(request.hwaddr)
channel = request.channel
band = request.band
requested.add(ResourceBlock(wtp, hwaddr, channel, band))
lvap.scheduled_on = wtp.supports & requested
LOG.info("Sending probe response to %s", lvap.addr)
self.send_probe_response(lvap)
def _handle_assoc_request(self, request):
"""Handle an incoming ASSOC_REQUEST message.
Args:
request, a ASSOC_REQUEST message
Returns:
None
"""
wtp_addr = EtherAddress(request.wtp)
try:
wtp = RUNTIME.wtps[wtp_addr]
except KeyError:
LOG.info("Assoc request from unknown WTP %s", wtp_addr)
return
if not wtp.connection:
LOG.info("Assoc request from disconnected WTP %s", wtp_addr)
return
sta = EtherAddress(request.sta)
if sta not in RUNTIME.lvaps:
LOG.info("Assoc request from unknown LVAP %s", sta)
return
lvap = RUNTIME.lvaps[sta]
if not RUNTIME.is_allowed(sta):
LOG.info("Assoc request from %s ignored (white list)", sta)
return
if RUNTIME.is_denied(sta):
LOG.info("Assoc request from %s ignored (black list)", sta)
return
ssid = SSID(request.ssid.decode('UTF-8'))
bssid = EtherAddress(request.bssid)
tenant_name = None
# look for ssid in shared tenants
for tenant_id in RUNTIME.tenants:
tenant = RUNTIME.tenants[tenant_id]
if tenant.bssid_type == T_TYPE_UNIQUE:
continue
if bssid in tenant.vaps and ssid == tenant.tenant_name:
tenant_name = tenant.tenant_name
# otherwise this must be the lvap unique bssid
if lvap.net_bssid == bssid and ssid in lvap.ssids:
tenant_name = ssid
if not tenant_name:
LOG.info("Assoc request sta %s for ssid %s bssid %s, ignoring",
lvap.addr, lvap.ssid, lvap.lvap_bssid)
return
# this will trigger an add lvap message to update the ssid
lvap.tenant = RUNTIME.load_tenant(tenant_name)
# this will trigger an add lvap message to update the assoc id
lvap.assoc_id = self.server.assoc_id
LOG.info("Assoc request sta %s ssid %s bssid %s assoc id %u, replying",
lvap.addr, lvap.ssid, lvap.lvap_bssid, lvap.assoc_id)
self.send_assoc_response(lvap)
def _handle_probe_request(self, request):
"""Handle an incoming PROBE_REQUEST message.
Args:
request, a PROBE_REQUEST message
Returns:
None
"""
wtp_addr = EtherAddress(request.wtp)
try:
wtp = RUNTIME.wtps[wtp_addr]
except KeyError:
LOG.info("Probe request from unknown WTP (%s)", wtp_addr)
return
if not wtp.connection:
LOG.info("Probe request from disconnected WTP %s", wtp_addr)
return
sta = EtherAddress(request.sta)
if sta in RUNTIME.lvaps:
return
if not RUNTIME.is_allowed(sta):
return
if RUNTIME.is_denied(sta):
return
ssid = SSID(request.ssid)
if request.ssid == b'':
LOG.info("Probe request from %s ssid %s", sta, "Broadcast")
else:
LOG.info("Probe request from %s ssid %s", sta, ssid)
# generate list of available SSIDs
ssids = set()
for tenant in RUNTIME.tenants.values():
if tenant.bssid_type == T_TYPE_SHARED:
continue
for wtp_in_tenant in tenant.wtps.values():
if wtp_addr == wtp_in_tenant.addr:
ssids.add(tenant.tenant_name)
if not ssids:
LOG.info("No SSIDs available at this WTP")
return
# spawn new LVAP
LOG.info("Spawning new LVAP %s on %s", sta, wtp.addr)
net_bssid = generate_bssid(BASE_MAC, sta)
lvap = LVAP(sta, net_bssid, net_bssid)
lvap.set_ssids(ssids)
RUNTIME.lvaps[sta] = lvap
# TODO: This should be built starting from the probe request
lvap.supports.add(ResourceBlock(lvap, sta, 1, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 2, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 3, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 4, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 5, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 6, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 7, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 8, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 9, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 10, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 11, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 36, BT_L20))
lvap.supports.add(ResourceBlock(lvap, sta, 48, BT_L20))
# This will trigger an LVAP ADD message (and REMOVE if necessary)
requested = ResourcePool()
hwaddr = EtherAddress(request.hwaddr)
channel = request.channel
band = request.band
requested.add(ResourceBlock(wtp, hwaddr, channel, band))
lvap.scheduled_on = wtp.supports & requested
LOG.info("Sending probe response to %s", lvap.addr)
self.send_probe_response(lvap)
def _handle_probe_request(self, wtp, request):
"""Handle an incoming PROBE_REQUEST message.
Args:
request, a PROBE_REQUEST message
Returns:
None
"""
if not wtp.connection:
LOG.info("Probe request from disconnected WTP %s", wtp.addr)
self.stream.close()
return
if not wtp.port():
LOG.info("WTP %s not ready", wtp.addr)
return
sta = EtherAddress(request.sta)
if sta in RUNTIME.lvaps:
return
if not RUNTIME.is_allowed(sta):
return
if RUNTIME.is_denied(sta):
return
ssid = SSID(request.ssid)
if request.ssid == b'':
LOG.info("Probe request from %s ssid %s", sta, "Broadcast")
else:
LOG.info("Probe request from %s ssid %s", sta, ssid)
# generate list of available SSIDs
ssids = set()
for tenant in RUNTIME.tenants.values():
if tenant.bssid_type == T_TYPE_SHARED:
continue
for wtp_in_tenant in tenant.wtps.values():
if wtp.addr == wtp_in_tenant.addr:
ssids.add(tenant.tenant_name)
if not ssids:
LOG.info("No SSIDs available at this WTP")
return
# spawn new LVAP
LOG.info("Spawning new LVAP %s on %s", sta, wtp.addr)
net_bssid = generate_bssid(BASE_MAC, sta)
lvap = LVAP(sta, net_bssid, net_bssid)
lvap.set_ssids(list(ssids))
# set supported band
lvap.supported_band = request.supported_band
# Check if block is valid
incoming = ResourceBlock(wtp, EtherAddress(request.hwaddr),
request.channel, request.band)
valid = [block for block in wtp.supports if block == incoming]
if not valid:
LOG.warning("No valid intersection found. Ignoring request.")
return
# This will trigger an LVAP ADD message (and REMOVE if necessary)
lvap.blocks = valid[0]
# save LVAP in the runtime
RUNTIME.lvaps[sta] = lvap
LOG.info("Sending probe response to %s", lvap.addr)
self.send_probe_response(lvap, ssid)
def _handle_probe_request(self, wtp, request):
"""Handle an incoming PROBE_REQUEST message.
Args:
request, a PROBE_REQUEST message
Returns:
None
"""
if not wtp.connection:
LOG.info("Probe request from disconnected WTP %s", wtp.addr)
self.stream.close()
return
if not wtp.port():
LOG.info("WTP %s not ready", wtp.addr)
return
sta = EtherAddress(request.sta)
if sta in RUNTIME.lvaps:
return
if not RUNTIME.is_allowed(sta):
return
if RUNTIME.is_denied(sta):
return
ssid = SSID(request.ssid)
if request.ssid == b'':
LOG.info("Probe request from %s ssid %s", sta, "Broadcast")
else:
LOG.info("Probe request from %s ssid %s", sta, ssid)
# generate list of available SSIDs
ssids = set()
for tenant in RUNTIME.tenants.values():
if tenant.bssid_type == T_TYPE_SHARED:
continue
for wtp_in_tenant in tenant.wtps.values():
if wtp.addr == wtp_in_tenant.addr:
ssids.add(tenant.tenant_name)
if not ssids:
LOG.info("No SSIDs available at this WTP")
return
# spawn new LVAP
LOG.info("Spawning new LVAP %s on %s", sta, wtp.addr)
net_bssid = generate_bssid(BASE_MAC, sta)
lvap = LVAP(sta, net_bssid, net_bssid)
lvap.set_ssids(list(ssids))
RUNTIME.lvaps[sta] = lvap
# This will trigger an LVAP ADD message (and REMOVE if necessary)
lvap.supported = ResourcePool()
hwaddr = EtherAddress(request.hwaddr)
channel = request.channel
band = request.band
lvap.supported.add(ResourceBlock(lvap, hwaddr, channel, band))
lvap.scheduled_on = wtp.supports & lvap.supported
LOG.info("Sending probe response to %s", lvap.addr)
self.send_probe_response(lvap)
