def dhcp_acquire(self, device: str) -> None:
if device not in self.quering:
self.quering.append(device)
else:
return
if device != "":
def reply(_obj: Mechanism, result: str, _user_data: None) -> None:
logging.info(result)
Notification(_("Bluetooth Network"),
_("Interface %(0)s bound to IP address %(1)s") % {"0": device, "1": result},
icon_name="network-workgroup").show()
self.quering.remove(device)
def err(_obj: Mechanism, result: GLib.Error, _user_data: None) -> None:
logging.warning(result)
Notification(_("Bluetooth Network"), _("Failed to obtain an IP address on %s") % device,
icon_name="network-workgroup").show()
self.quering.remove(device)
Notification(_("Bluetooth Network"), _("Trying to obtain an IP address on %s\nPlease wait…" % device),
icon_name="network-workgroup").show()
m = Mechanism()
m.DhcpClient('(s)', device, result_handler=reply, error_handler=err, timeout=120 * 1000)
def on_apply(self):
if self.on_query_apply_state():
logging.info("network apply")
m = Mechanism()
nap_enable = self.Builder.get_object("nap-enable")
if nap_enable.props.active:
if self.Builder.get_object("r_dhcpd").props.active:
stype = "DhcpdHandler"
elif self.Builder.get_object("r_dnsmasq").props.active:
stype = "DnsMasqHandler"
elif self.Builder.get_object("r_udhcpd").props.active:
stype = "UdhcpdHandler"
net_ip = self.Builder.get_object("net_ip")
try:
m.EnableNetwork('(ayays)', inet_aton(net_ip.props.text), inet_aton("255.255.255.0"), stype)
if not self.Config["nap-enable"]:
self.Config["nap-enable"] = True
except Exception as e:
d = ErrorDialog("<b>Failed to apply network settings</b>",
excp=e, parent=self.widget.get_toplevel())
d.run()
d.destroy()
return
else:
self.Config["nap-enable"] = False
m.DisableNetwork()
self.clear_options()
def connect(self) -> bool:
c = Config("org.blueman.gsmsetting", f"/org/blueman/gsmsettings/{self.service.device['Address']}/")
m = Mechanism()
m.PPPConnect('(uss)', self.port, c["number"], c["apn"], result_handler=self.on_connected,
error_handler=self.on_error)
return False
def connect(self):
c = Config(
"org.blueman.gsmsetting",
"/org/blueman/gsmsettings/%s/" % self.service.device['Address'])
m = Mechanism()
m.PPPConnect('(sss)',
self.port,
c["number"],
c["apn"],
result_handler=self.on_connected,
error_handler=self.on_error)
def connect(self, reply_handler=None, error_handler=None):
channel = get_rfcomm_channel(self.short_uuid, self.device['Address'])
if channel == 0:
error = RFCOMMError("Failed to get rfcomm channel")
if error_handler:
error_handler(error)
return True
else:
raise error
try:
port_id = create_rfcomm_device(
Adapter(self.device["Adapter"])['Address'],
self.device["Address"], channel)
filename = '/dev/rfcomm%d' % port_id
logging.info('Starting rfcomm watcher as root')
Mechanism().open_rfcomm('(d)', port_id)
mon = Gio.File.new_for_path(filename).monitor_file(
Gio.FileMonitorFlags.NONE)
self.file_changed_handler = mon.connect('changed',
self.on_file_changed,
port_id)
self.try_replace_root_watcher(mon, filename, port_id)
if reply_handler:
reply_handler(filename)
except RFCOMMError as e:
if error_handler:
error_handler(e)
else:
raise e
return True
def connect(
self,
reply_handler: Optional[Callable[[int], None]] = None,
error_handler: Optional[Callable[[RFCOMMError], None]] = None
) -> bool:
# We expect this service to have a reserved UUID
uuid = self.short_uuid
assert uuid
channel = get_rfcomm_channel(uuid, self.device['Address'])
if channel is None or channel == 0:
error = RFCOMMError("Failed to get rfcomm channel")
if error_handler:
error_handler(error)
return True
else:
raise error
try:
port_id = create_rfcomm_device(Adapter(obj_path=self.device["Adapter"])['Address'], self.device["Address"],
channel)
filename = '/dev/rfcomm%d' % port_id
logging.info('Starting rfcomm watcher as root')
Mechanism().OpenRFCOMM('(d)', port_id)
mon = Gio.File.new_for_path(filename).monitor_file(Gio.FileMonitorFlags.NONE)
self._handlerids[port_id] = mon.connect('changed', self.on_file_changed, port_id)
self.try_replace_root_watcher(mon, filename, port_id)
if reply_handler:
reply_handler(port_id)
except RFCOMMError as e:
if error_handler:
error_handler(e)
else:
raise e
return True
def load_nap_settings(self):
logging.info("Loading NAP settings")
def reply(*_):
pass
def err(_obj, result, _user_data):
d = ErrorDialog("<b>Failed to apply network settings</b>",
"You might not be able to connect to the Bluetooth network via this machine",
result,
margin_left=9)
d.run()
d.destroy()
m = Mechanism()
m.ReloadNetwork(result_handler=reply, error_handler=err)
def try_replace_root_watcher(self, monitor, path, port):
if not os.access(path, os.R_OK | os.W_OK):
return
logging.info('User was granted access to %s' % path)
logging.info('Replacing root watcher')
Mechanism().close_rfcomm('(d)', port)
subprocess.Popen([RFCOMM_WATCHER_PATH, path])
monitor.disconnect(self.file_changed_handler)
def try_replace_root_watcher(self, monitor: Gio.FileMonitor, path: str,
port: int) -> None:
if not os.access(path, os.R_OK | os.W_OK):
return
logging.info('User was granted access to %s' % path)
logging.info('Replacing root watcher')
Mechanism().CloseRFCOMM('(d)', port)
subprocess.Popen([RFCOMM_WATCHER_PATH, path])
monitor.disconnect_by_func(self.on_file_changed, port)
def on_apply(self) -> None:
if self.on_query_apply_state():
logging.info("network apply")
m = Mechanism()
nap_enable = self._builder.get_widget("nap-enable",
Gtk.CheckButton)
if nap_enable.props.active:
if self._builder.get_widget("r_dhcpd",
Gtk.RadioButton).props.active:
stype = "DhcpdHandler"
elif self._builder.get_widget("r_dnsmasq",
Gtk.RadioButton).props.active:
stype = "DnsMasqHandler"
elif self._builder.get_widget("r_udhcpd",
Gtk.RadioButton).props.active:
stype = "UdhcpdHandler"
net_ip = self._builder.get_widget("net_ip", Gtk.Entry)
try:
m.EnableNetwork('(sss)', net_ip.props.text,
"255.255.255.0", stype)
if not self.Config["nap-enable"]:
self.Config["nap-enable"] = True
except Exception as e:
parent = self.widget.get_toplevel()
assert isinstance(parent, Gtk.Container)
d = ErrorDialog("<b>Failed to apply network settings</b>",
excp=e,
parent=parent)
d.run()
d.destroy()
return
else:
self.Config["nap-enable"] = False
m.DisableNetwork()
self.clear_options()
def disconnect(self, port_id, reply_handler=None, error_handler=None):
try:
Mechanism().close_rfcomm('(d)', port_id)
except GLib.Error as e:
if error_handler:
error_handler(e.message)
else:
raise
if reply_handler:
reply_handler()
def try_replace_root_watcher(self, monitor: Gio.FileMonitor, path: str, port: int) -> None:
if not os.access(path, os.R_OK | os.W_OK):
return
logging.info(f'User was granted access to {path}')
logging.info('Replacing root watcher')
Mechanism().CloseRFCOMM('(d)', port)
subprocess.Popen([RFCOMM_WATCHER_PATH, path])
if port in self._handlerids:
handler_id = self._handlerids.pop(port)
monitor.disconnect(handler_id)
else:
logging.warning(f"No handler id for {port}")
def disconnect(
self,
port_id: int,
reply_handler: Optional[Callable[[], None]] = None,
error_handler: Optional[Callable[[str], None]] = None) -> None:
try:
Mechanism().CloseRFCOMM('(d)', port_id)
except GLib.Error as e:
if error_handler:
error_handler(e.message)
else:
raise
if reply_handler:
reply_handler()
def on_power_state_change_requested(self, _, state, cb):
logging.info(state)
def reply(*_):
cb(True)
def error(*_):
cb(False)
if self._connman_proxy:
logging.debug("Using connman to set state: %s" % state)
self._connman_proxy.SetProperty('(sv)', 'Powered', GLib.Variant.new_boolean(state),
result_handler=reply, error_handler=error)
else:
logging.debug("Using mechanism to set state: %s" % state)
Mechanism().SetRfkillState('(b)', state, result_handler=reply, error_handler=error)
def on_power_state_change_requested(self, _: PowerManager, state: bool, cb: Callable[[bool], None]) -> None:
logging.info(state)
def reply(*_: Any) -> None:
cb(True)
def error(*_: Any) -> None:
cb(False)
if self._connman_proxy:
logging.debug(f"Using connman to set state: {state}")
self._connman_proxy.SetProperty('(sv)', 'Powered', GLib.Variant.new_boolean(state),
result_handler=reply, error_handler=error)
else:
logging.debug(f"Using mechanism to set state: {state}")
Mechanism().SetRfkillState('(b)', state, result_handler=reply, error_handler=error)
