def connected_timeout(dummy: int) -> None:
active_ssid: Optional[str]
active_ssid = nm.get_active_ssid(modemgr.get_state_device("CONNECTED"))
log.debug("connected_timeout comparing {} to {}".format(
connection, active_ssid))
if connection != active_ssid:
log.warning("Connection lost on timeout")
dev = modemgr.get_state_device("CONNECTED")
set_state("CONNECTING", candidate_connections(dev))
if modemgr.get_mode() == modemgr.MULTI_MODE:
wpa.check_wpa(modemgr.get_ap_device().Interface)
active_ssid = nm.get_active_ssid(modemgr.get_state_device("HOTSPOT"))
if not active_ssid:
log.warning("Hotspot lost on timeout")
set_state("HOTSPOT")
defroute_devname: Optional[str] = routemgr.defroute_dev()
ap_dev: NetworkManager.Device = modemgr.get_ap_device()
link_dev: NetworkManager.Device = modemgr.get_link_device()
if defroute_devname == nm.device_name(ap_dev):
# default route is bad. Disconnect link and count on state
# processing to restore
log.error("AP is holding default route while CONNECTED, kicking")
nm.disconnect(link_dev)
def hotspot_pass(reason: int) -> None:
global startup
dev: NetworkManager.Device = modemgr.get_state_device("CONNECTED")
conn_list = candidate_connections(dev)
active_ssid = nm.get_active_ssid(modemgr.get_state_device("CONNECTED"))
if startup or active_ssid in conn_list:
set_state("CONNECTING", conn_list)
startup = False
def set_state(state, connections=None, timeout=180):
global com_state, conn_list, state_id, points
log.info('Setting state to %s' % state)
state_info = state_matrix(state)
log.info("get statematrix")
nmmon.init_nmmon()
log.info("enable")
nmmon.enable(modemgr.get_state_device(state), state_info.pass_fn,
state_info.fail_fn)
log.info("nmmon enabled")
if connections:
conn_list = connections
state_id += 1
com_state = state
timeout_add(timeout * 1000, state_info.timeout_fn, state_id)
log.info("state_info.start_fn()")
state_info.start_fn()
def set_state_to(state, connections=None, timeout=180):
global com_state, conn_list, state_id, points
log.info('Setting state to %s' % state)
state_info = state_matrix(state)
nmmon.init_nmmon()
state_id += 1
nmmon.enable(
modemgr.get_state_device(state),
state_info.pass_fn,
state_info.fail_fn,
state_id,
)
if connections:
if type(conn_list) == str:
conn_list = [connections]
else:
conn_list = connections
com_state = state
timeout_add(timeout * 1000, state_info.timeout_fn, state_id)
state_info.start_fn()
return False
def connected_timeout():
log.debug("states: Calling nm.get_active_ssid()")
if connection != nm.get_active_ssid(modemgr.get_state_device('CONNECTED')):
log.warning("Connection lost on timeout")
set_state('HOTSPOT')
if modemgr.get_mode() == modemgr.MULTI_MODE:
wpa.check_wpa(modemgr.get_ap_device().Interface)
def check_device_listener(force=False):
global device_path
current_path = nm.get_device_path(modemgr.get_state_device(comstate))
if force or (current_path and current_path != device_path):
device_path = current_path
set_device_listener(device_path)
def activate_connection(name: str, state: str) -> None:
global connection
connection = name
log.debug("Connecting to %s" % connection)
path = "/"
nm.activate_connection_by_ssid(connection,
modemgr.get_state_device(state),
path=path)
def connecting_start(dummy: int) -> None:
global conn_list, connection
dev = modemgr.get_state_device("CONNECTED")
full_conn_list = candidate_connections(dev)
active_ssid = nm.get_active_ssid(modemgr.get_state_device("CONNECTED"))
if active_ssid in full_conn_list:
log.debug("Didn't need to connect - already connected")
connection = active_ssid
# the connect callback won't happen - let's 'pass' manually
timeout_add(100, fake_cg_pass, state_id)
else:
if conn_list:
log.debug("states: Calling nm.disconnect()")
nm.disconnect(modemgr.get_state_device("CONNECTING"))
conn = conn_list.pop(0)
log.info("Attempting connection to %s" % conn)
activate_connection(conn, "CONNECTING")
else:
set_state("HOTSPOT")
def set_state(state, connections=None, timeout=180):
global com_state, conn_list, state_id, points
log.info('Setting state to %s' % state)
if com_state != 'HOTSPOT':
log.debug("states: Calling nm.get_points_ext()")
points = nm.get_points_ext(modemgr.get_state_device(com_state))
state_info = state_matrix(state)
nmmon.enable(modemgr.get_state_device(state), state_info.pass_fn,
state_info.fail_fn)
if connections:
conn_list = connections
state_id += 1
com_state = state
timeout_add(timeout * 1000, state_info.timeout_fn, state_id)
state_info.start_fn()
def hotspot_pass():
log.debug("Activating mdns")
# IP tolerance for PI 2
for _ in range(5):
log.debug("states: Calling nm.get_active_ip()")
ip = nm.get_active_ip(modemgr.get_state_device('HOTSPOT'))
if ip:
mdns.clear_entries()
mdns.add_hosts(dns_names)
break
time.sleep(1)
def connecting_start():
global conn_list
if conn_list:
log.debug("states: Calling nm.disconnect()")
nm.disconnect(modemgr.get_state_device('CONNECTING'))
conn = conn_list.pop(0)
log.info('Attempting connection to %s' % conn)
activate_connection(conn, 'CONNECTING')
else:
set_state('HOTSPOT')
def connected_fail(reason: int) -> None:
global startup
log.warning("Connection lost")
active_ssid: Optional[str]
active_ssid = nm.get_active_ssid(modemgr.get_state_device("HOTSPOT"))
if modemgr.get_mode() == modemgr.MULTI_MODE and not active_ssid:
log.warning("Hotspot lost while CONNECTED")
set_state("HOTSPOT")
else:
startup = True
set_state("HOTSPOT")
def connecting_start():
global conn_list
mdns.clear_entries()
if conn_list:
log.debug("states: Calling nm.disconnect()")
nm.disconnect(modemgr.get_state_device('CONNECTING'))
conn = conn_list.pop(0)
log.info('Attempting connection to %s' % conn)
activate_connection(conn, 'CONNECTING')
else:
# Give NetworkManager a chance to update the access point list
try:
# todo - clean this up
log.debug("states: Calling nm.deactivate_connection()")
nm.deactivate_connection(modemgr.get_state_device('CONNECTING'))
except DBusException:
pass
time.sleep(5)
set_state('HOTSPOT')
def activate_connection(name, state):
global connection
connection = name
log.debug('Connecting to %s' % connection)
try:
path = [x['nmpath'] for x in points if x['ssid'] == name][0]
except IndexError:
path = '/'
log.debug("states: Calling nm.activate_connection_by_ssid()")
nm.activate_connection_by_ssid(connection,
modemgr.get_state_device(state),
path=path)
def connected_start():
global conn_list
# IP tolerance for PI 2
for _ in range(5):
log.debug("states: Calling nm.get_active_ip()")
ip = nm.get_active_ip(modemgr.get_state_device('CONNECTED'))
if ip:
mdns.clear_entries()
mdns.add_hosts(dns_names)
break
time.sleep(1)
conn_list = []
def hotspot_timeout():
if iwscan.ap_conn_count() == 0 or modemgr.get_mode() != 'single':
log.debug('Periodic connection attempt')
dev = modemgr.get_state_device('CONNECTED')
conn_list = candidate_connections(dev)
if conn_list:
set_state('CONNECTING', conn_list)
else:
log.info('No candidates - skipping CONNECTING scan')
else:
log.info('AP active - skipping CONNECTING scan')
wpa.check_wpa(modemgr.get_ap_device().Interface)
def hotspot_timeout(dummy: int) -> None:
if iwscan.ap_conn_count() == 0 or modemgr.get_mode() != "single":
log.debug("Periodic connection attempt")
dev = modemgr.get_state_device("CONNECTED")
conn_list: List[str] = candidate_connections(dev)
if conn_list:
set_state("CONNECTING", conn_list)
else:
log.info("No candidates - skipping CONNECTING scan")
else:
log.info("AP active - skipping CONNECTING scan")
wpa.check_wpa(modemgr.get_ap_device().Interface)
def hotspot_timeout():
if iwscan.ap_conn_count() == 0 or modemgr.get_mode() != 'single':
log.debug('Periodic connection attempt')
dev = modemgr.get_state_device('CONNECTED')
conn_list = candidate_connections(dev)
if conn_list:
# bug - try the first connection twice
set_state('CONNECTING', [conn_list[0], conn_list[0]] + conn_list)
else:
set_state('CONNECTING')
else:
log.info('AP active - skipping CONNECTING scan')
def state_monitor():
# NetworkManager is crashing on the first call to attach. In two
# interface mode, this leaves the hotspot interface with no IP
# configuration. Detect this and recover
if com_state != 'HOTSPOT':
if modemgr.get_mode() == modemgr.MULTI_MODE:
log.debug("state_monitor: Calling nm.get_active_ip()")
ip = nm.get_active_ip(modemgr.get_state_device('HOTSPOT'))
if not ip:
log.warn("Hotspot lost IP configuration - resetting")
hs_ssid = dns_to_conn(dns_names[0])
activate_connection(hs_ssid, 'HOTSPOT')
# Keep this periodic task running
return True
def hotspot_start():
global conn_list
log.info("Activating hotspot")
hs_ssid = dns_to_conn(dns_names[0])
log.debug("states: Calling nm.get_active_ssid()")
if hs_ssid != nm.get_active_ssid(modemgr.get_state_device('HOTSPOT')):
conn_list = []
activate_connection(hs_ssid, 'HOTSPOT')
else:
log.debug("Didn't need to reactivate - already running")
# the connect callback won't happen - let's 'pass' manually
timeout_add(100, fake_hs_pass, state_id)
def set_state_to(
state: str,
connections: List[str],
timeout: int,
force: bool,
curr_state_id: int,
):
global com_state, conn_list, state_id
if state == com_state and not force:
return False
if curr_state_id < state_id:
return False
log.info("Setting state to %s" % state)
state_info: state_matrix = state_matrix(state)
nmmon.init_nmmon()
state_id += 1
nmmon.enable(
modemgr.get_state_device(state),
state_info.pass_fn,
state_info.fail_fn,
state_id,
)
if state in ["CONNECTED", "HOTSPOT"]:
nmmon.enhance_fail_states()
if connections:
conn_list = connections
com_state = state
timeout_add(timeout * 1000, state_info.timeout_fn, state_id, 0)
state_info.start_fn(0)
return False
def hotspot_start(dummy: int) -> None:
global conn_list
log.info("Activating hotspot")
if startup:
mdns.clear_entries()
mdns.add_hosts(dns_names)
hs_ssid: str = dns_to_conn(dns_names[0])
if startup and modemgr.get_mode() == modemgr.SINGLE_MODE:
log.debug("Passing on hotspot connection for now")
timeout_add(100, fake_hs_pass, state_id)
elif hs_ssid != nm.get_active_ssid(modemgr.get_state_device("HOTSPOT")):
conn_list = []
log.debug("Activating connection {}".format(hs_ssid))
activate_connection(hs_ssid, "HOTSPOT")
else:
log.debug("Didn't need to reactivate - already running")
# the connect callback won't happen - let's 'pass' manually
timeout_add(100, fake_hs_pass, state_id)
def hotspot_start():
global conn_list
log.info("Activating hotspot")
hs_ssid = dns_to_conn(dns_names[0])
# if we are in two-wifi device mode, skip the reconnect if possible,
# to avoid kicking some clients off
log.debug("states: Calling nm.get_active_ssid()")
if hs_ssid != nm.get_active_ssid(modemgr.get_state_device('HOTSPOT')):
mdns.clear_entries()
conn_list = []
# tolerate Raspberry Pi 2
try:
activate_connection(hs_ssid, 'HOTSPOT')
except DBusException:
log.warn("Error connecting hotspot")
else:
log.debug("Didn't need to reactivate - already running")
# the connect callback won't happen - let's 'pass' manually
timeout_add(100, fake_hs_pass)
def connected_timeout():
log.debug("states: Calling nm.get_active_ssid()")
if connection != nm.get_active_ssid(modemgr.get_state_device('CONNECTED')):
log.warn("Connection lost on timeout")
set_state('HOTSPOT')
