def on_apply(self):
if self.on_query_apply_state() == True:
dprint("network apply")
m = Mechanism()
nap_enable = self.Builder.get_object("nap-enable")
if nap_enable.props.active:
r_dnsmasq = self.Builder.get_object("r_dnsmasq")
if r_dnsmasq.props.active:
stype = "DnsMasqHandler"
else:
stype = "DhcpdHandler"
net_ip = self.Builder.get_object("net_ip")
net_nat = self.Builder.get_object("net_nat")
try:
m.EnableNetwork(inet_aton(net_ip.props.text),
inet_aton("255.255.255.0"), stype)
except Exception as e:
d = NetworkErrorDialog(e)
d.run()
d.destroy()
return
else:
m.DisableNetwork()
self.clear_options()
def add_device(self, device, append=True):
#device belongs to another adapter
if not device['Adapter'] == self.Adapter.get_object_path():
return
dprint("adding new device")
if append:
tree_iter = self.liststore.append()
else:
tree_iter = self.liststore.prepend()
self.set(tree_iter, device=device)
self.row_setup_event(tree_iter, device)
object_path = device.get_object_path()
try:
self.set(tree_iter, dbus_path=object_path)
except:
pass
sig = device.connect_signal('property-changed', self._on_device_property_changed)
self.__signals[object_path] = sig
if device["Connected"]:
self.monitor_power_levels(device)
def _on_device_state_changed(self, device, new_state, old_state, reason):
new = NM.DeviceState(new_state)
old = NM.DeviceState(old_state)
state_reason = NM.DeviceStateReason(reason)
dprint('New: %s Old: %s Reason: %s' %
(new.value_nick, old.value_nick, state_reason.value_nick))
error_msg = None
reply_msg = None
if new == NM.DeviceState.FAILED:
error_msg = 'Connection failed with reason: %s' % state_reason.value_nick
elif new == NM.DeviceState.ACTIVATED:
reply_msg = 'Connection sucesfully activated'
elif (new <= NM.DeviceState.DISCONNECTED or new == NM.DeviceState.DEACTIVATING) and \
(NM.DeviceState.DISCONNECTED < old <= NM.DeviceState.ACTIVATED):
error_msg = 'Connection disconnected with reason %s' % state_reason.value_nick
else:
return # Keep checking the state changes
# We are done with state changes
device.disconnect_by_func(self._on_device_state_changed)
if error_msg is None:
self._return_or_reply_handler(reply_msg)
else:
dprint(error_msg)
self._raise_or_error_handler(NMConnectionError(error_msg))
def _on_interfaces_removed(self, object_path, interfaces):
if 'org.bluez.Adapter1' in interfaces:
dprint(object_path)
self.emit('adapter-removed', object_path)
elif 'org.bluez.Device1' in interfaces:
dprint(object_path)
self.emit('device-removed', object_path)
def on_adapter_changed(self, list, adapter_path):
dprint("toolbar adapter", adapter_path)
if adapter_path == None:
self.b_search.props.sensitive = False
self.update_send_browse(None)
else:
self.b_search.props.sensitive = True
def _return_or_reply_handler(self, msg):
dprint(msg)
if not self.reply_handler:
return msg
else:
self.reply_handler(msg)
return
def on_property_changed(self, key, value):
dprint("adapter propery changed", key, value)
if key == "Discovering":
if not value and self.discovering:
self.StopDiscovery()
self.emit("adapter-property-changed", self.Adapter, (key, value))
def on_property_changed(self, netconf, key, value):
dprint(self.ignored_keys)
if key in self.ignored_keys:
self.ignored_keys.remove(key)
return
if key == "rb_blueman" or key == "dhcp_client":
if value:
self.Builder.get_object("rb_blueman").props.active = True
else:
self.Builder.get_object("rb_nm").props.active = True
return
if key == "rb_nm":
return
if key == "gn_enable":
self.Builder.get_object(key).props.active = value
return
if key == "nap_enable":
dprint("nap_enable", value)
self.Builder.get_object(key).props.active = value
nap_frame = self.Builder.get_object("nap_frame")
if value:
nap_frame.props.sensitive = True
else:
nap_frame.props.sensitive = False
if key == "ip":
self.option_changed_notify(key, False)
else:
self.option_changed_notify(key)
def on_mm_device_added(self, path):
dprint(path)
props = self.parent.bus.call_blocking(
"org.freedesktop.ModemManager", path,
"org.freedesktop.DBus.Properties", "GetAll", "s",
["org.freedesktop.ModemManager.Modem"])
if self.rfcomm_dev and props["Driver"] == "bluetooth" and props[
"Device"] in self.rfcomm_dev:
dprint("It's our bluetooth modem!")
modem = get_icon("modem", 24)
blueman = get_icon("blueman", 48)
icon = composite_icon(blueman, [(modem, 24, 24, 255)])
Notification(
_("Bluetooth Dialup"),
_("DUN connection on %s will now be available in Network Manager"
) % self.device.Alias,
pixbuf=icon,
status_icon=self.parent.Applet.Plugins.StatusIcon)
self.reply(self.rfcomm_dev)
self.cleanup()
def on_property_changed(self, key, value):
dprint("adapter propery changed", key, value)
if key == "Discovering":
if not value and self.discovering:
self.StopDiscovery()
self.emit("adapter-property-changed", self.Adapter, (key, value))
def RequestPinCode(self, device, ok, err):
dprint("Agent.RequestPinCode")
dialog_msg = _("Enter PIN code for authentication:")
notify_msg = _("Enter PIN code")
self.ask_passkey(device, dialog_msg, notify_msg, False, False, ok, err)
if self.dialog:
self.dialog.present_with_time(self.time)
def add_device(self, device, append=True):
#device belongs to another adapter
if not device['Adapter'] == self.Adapter.get_object_path():
return
dprint("adding new device")
if append:
tree_iter = self.liststore.append()
else:
tree_iter = self.liststore.prepend()
self.set(tree_iter, device=device)
self.row_setup_event(tree_iter, device)
object_path = device.get_object_path()
try:
self.set(tree_iter, dbus_path=object_path)
except:
pass
sig = device.connect_signal('property-changed',
self._on_device_property_changed)
self.__signals[object_path] = sig
if device["Connected"]:
self.monitor_power_levels(device)
def on_property_changed(self, netconf, key, value):
dprint(self.ignored_keys)
if key in self.ignored_keys:
self.ignored_keys.remove(key)
return
if key == "rb_blueman" or key == "dhcp_client":
if value:
self.Builder.get_object("rb_blueman").props.active = True
else:
self.Builder.get_object("rb_nm").props.active = True
return
if key == "rb_nm":
return
if key == "gn_enable":
self.Builder.get_object(key).props.active = value
return
if key == "nap_enable":
dprint("nap_enable", value)
self.Builder.get_object(key).props.active = value
nap_frame = self.Builder.get_object("nap_frame")
if value:
nap_frame.props.sensitive = True
else:
nap_frame.props.sensitive = False
if key == "ip":
self.option_changed_notify(key, False)
else:
self.option_changed_notify(key)
def on_apply(self):
if self.on_query_apply_state() == True:
dprint("network apply")
m = Mechanism()
nap_enable = self.Builder.get_object("nap-enable")
if nap_enable.props.active:
r_dnsmasq = self.Builder.get_object("r_dnsmasq")
if r_dnsmasq.props.active:
stype = "DnsMasqHandler"
else:
stype = "DhcpdHandler"
net_ip = self.Builder.get_object("net_ip")
net_nat = self.Builder.get_object("net_nat")
try:
m.EnableNetwork(inet_aton(net_ip.props.text), inet_aton("255.255.255.0"), stype)
except Exception as e:
d = NetworkErrorDialog(e)
d.run()
d.destroy()
return
else:
m.DisableNetwork()
self.clear_options()
def _on_request_confirmation(self, parameters, invocation):
def on_confirm_action(n, action):
if action == "confirm":
invocation.return_value(GLib.Variant('()', ()))
else:
invocation.return_dbus_error('org.bluez.Error.Canceled',
"User canceled pairing")
params = parameters.unpack()
if len(params) < 2:
device_path = params[0]
passkey = None
else:
device_path, passkey = params
dprint("Agent.RequestConfirmation")
alias = self.get_device_alias(device_path)
notify_message = _("Pairing request for:") + "\n%s" % alias
if passkey:
notify_message += "\n" + _(
"Confirm value for authentication:") + " <b>%s</b>" % passkey
actions = [["confirm", _("Confirm")], ["deny", _("Deny")]]
self.n = Notification("Bluetooth",
notify_message,
0,
actions,
on_confirm_action,
pixbuf=get_icon("blueman", 48),
status_icon=self.status_icon)
def on_load(self, applet):
self._config = Config("org.blueman.transfer")
if not self._config["shared-path"]:
d = GLib.get_user_special_dir(GLib.UserDirectory.DIRECTORY_DOWNLOAD)
if not d:
self._config["shared-path"] = os.path.expanduser("~")
else:
self._config["shared-path"] = d
if not os.path.isdir(self._config["shared-path"]):
dprint("Configured share directory %s does not exist" % self._config["shared-path"])
dlg = Gtk.MessageDialog(None, buttons=Gtk.ButtonsType.OK, type=Gtk.MessageType.ERROR)
text = _("Configured directory for incoming files does not exist")
secondary_text = _(
'Please make sure that directory "<b>%s</b>" exists or configure it with blueman-services'
)
dlg.props.text = text
dlg.format_secondary_markup(secondary_text % self._config["shared-path"])
dlg.run()
dlg.destroy()
self._manager = obex.Manager()
self._manager.connect("transfer-started", self._on_transfer_started)
self._manager.connect("transfer-completed", self._on_transfer_completed)
self._manager.connect("session-removed", self._on_session_removed)
self._watch = dbus.SessionBus().watch_name_owner("org.bluez.obex", self._on_obex_owner_changed)
def RemoveDevice(self, device, iter=None, force=False):
dprint(device)
if iter == None:
iter = self.find_device(device)
if not device.Temp and self.compare(self.selected(), iter):
self.emit("device-selected", None, None)
try:
props = device.GetProperties()
except:
self.device_signals.Disconnect(device.get_object_path())
else:
if not "Fake" in props:
self.device_signals.Disconnect(device.GetObjectPath())
if device.Temp and not force:
dprint("converting to fake")
props = copy.deepcopy(props)
props["Fake"] = True
dev = FakeDevice(props)
device = Device(dev)
self.device_add_event(device)
else:
#device.Destroy()
self.delete(iter)
def on_adapter_changed(self, lst, adapter_path):
dprint("toolbar adapter", adapter_path)
if adapter_path is None:
self.b_search.props.sensitive = False
self.b_send.props.sensitive = False
else:
self.b_search.props.sensitive = True
def SetAdapter(self, adapter=None):
self.clear()
if self.discovering:
self.emit("adapter-property-changed", self.Adapter,
("Discovering", False))
self.StopDiscovery()
if adapter is not None and adapter != "" and not re.match(
"hci[0-9]*", adapter):
adapter = adapter_path_to_name(adapter)
dprint(adapter)
try:
self.Adapter = self.manager.get_adapter(adapter)
self.Adapter.connect_signal('property-changed',
self._on_property_changed)
self.manager.connect_signal('device-created',
self._on_device_created)
self.manager.connect_signal('device-removed',
self._on_device_removed)
self.__adapter_path = self.Adapter.get_object_path()
self.emit("adapter-changed", self.__adapter_path)
except Bluez.errors.DBusNoSuchAdapterError as e:
dprint(e)
#try loading default adapter
if len(self.manager.list_adapters()) > 0 and adapter is not None:
self.SetAdapter()
else:
self.Adapter = None
self.emit("adapter-changed", None)
def _on_interfaces_removed(self, object_path, interfaces):
if 'org.bluez.Adapter1' in interfaces:
dprint(object_path)
self.emit('adapter-removed', object_path)
elif 'org.bluez.Device1' in interfaces:
dprint(object_path)
self.emit('device-removed', object_path)
def add_device(self, device):
#device belongs to another adapter
if not device['Adapter'] == self.Adapter.get_object_path():
return
dprint("adding new device")
tree_iter = self.liststore.append()
self.set(tree_iter, device=device)
self.row_setup_event(tree_iter, device)
object_path = device.get_object_path()
timestamp = datetime.strftime(datetime.now(), '%Y%m%d%H%M%S%f')
try:
self.set(tree_iter,
dbus_path=object_path,
timestamp=float(timestamp))
except:
pass
sig = device.connect_signal('property-changed',
self._on_device_property_changed)
self.__signals[object_path] = sig
if device["Connected"]:
self.monitor_power_levels(device)
def _raise_or_error_handler(self, error):
dprint(error)
if not self.error_handler:
raise error
else:
self.error_handler(error)
return
def on_activate():
dprint("adapter powered", path)
if self.Adapter is None:
self.SetAdapter(path)
self.emit("adapter-added", path)
def on_adapter_changed(self, devlist, adapter_path):
dprint("changed")
if adapter_path is None:
self.update_adapters_list()
else:
if self.List.Adapter:
self.List.DisplayKnownDevices()
def SetAdapter(self, adapter=None):
self.clear()
if self.discovering:
self.emit("adapter-property-changed", self.Adapter, ("Discovering", False))
self.StopDiscovery()
if adapter != None and not re.match("hci[0-9]*", adapter):
adapter = adapter_path_to_name(adapter)
dprint(adapter)
if self.Adapter != None:
self.adapter_signals.DisconnectAll()
try:
self.Adapter = self.Manager.GetAdapter(adapter)
self.adapter_signals.Handle(self.Adapter, self.on_device_found, "DeviceFound")
self.adapter_signals.Handle(self.Adapter, self.on_property_changed, "PropertyChanged")
self.adapter_signals.Handle(self.Adapter, self.on_device_created, "DeviceCreated")
self.adapter_signals.Handle(self.Adapter, self.on_device_removed, "DeviceRemoved")
self.__adapter_path = self.Adapter.GetObjectPath()
self.emit("adapter-changed", self.__adapter_path)
except Bluez.errors.DBusNoSuchAdapterError, e:
dprint(e)
#try loading default adapter
if len(self.Manager.ListAdapters()) > 0 and adapter != None:
self.SetAdapter()
else:
self.Adapter = None
self.emit("adapter-changed", None)
def on_adapter_changed(self, list, adapter_path):
dprint("toolbar adapter", adapter_path)
if adapter_path == None:
self.b_search.props.sensitive = False
self.update_send_browse(None)
else:
self.b_search.props.sensitive = True
def RemoveDevice(self, device, iter=None, force=False):
dprint(device)
if iter == None:
iter = self.find_device(device)
if not device.Temp and self.compare(self.selected(), iter):
self.emit("device-selected", None, None)
try:
props = device.GetProperties()
except:
self.device_signals.Disconnect(device.get_object_path())
else:
if not "Fake" in props:
self.device_signals.Disconnect(device.GetObjectPath())
if device.Temp and not force:
dprint("converting to fake")
props = copy.deepcopy(props)
props["Fake"] = True
dev = FakeDevice(props)
device = Device(dev)
self.device_add_event(device)
else:
#device.Destroy()
self.delete(iter)
def on_mm_device_added(self, path, name="org.freedesktop.ModemManager"):
dprint(path)
interface = "%s.Modem" % name
props = self.parent.bus.call_blocking(name, path, "org.freedesktop.DBus.Properties", "GetAll", "s", [interface])
try:
drivers = props["Drivers"]
except KeyError:
drivers = [props["Driver"]]
if self.rfcomm_dev and "bluetooth" in drivers and props["Device"] in self.rfcomm_dev:
dprint("It's our bluetooth modem!")
modem = get_icon("modem", 24)
blueman = get_icon("blueman", 48)
icon = composite_icon(blueman, [(modem, 24, 24, 255)])
Notification(_("Bluetooth Dialup"),
_("DUN connection on %s will now be available in Network Manager") % self.service.device.Alias,
pixbuf=icon,
status_icon=self.parent.Applet.Plugins.StatusIcon)
self.reply(self.rfcomm_dev)
self.cleanup()
def _on_request_passkey(self, parameters, invocation):
dprint("Agent.RequestPasskey")
dialog_msg = _("Enter passkey for authentication:")
notify_msg = _("Enter passkey")
self.ask_passkey(dialog_msg, notify_msg, True, True, parameters, invocation)
if self.dialog:
self.dialog.present_with_time(self.time_func())
def on_mm_device_added(self, path, name="org.freedesktop.ModemManager"):
dprint(path)
interface = "%s.Modem" % name
props = self.parent.bus.call_blocking(
name, path, "org.freedesktop.DBus.Properties", "GetAll", "s",
[interface])
try:
drivers = props["Drivers"]
except KeyError:
drivers = [props["Driver"]]
if self.rfcomm_dev and "bluetooth" in drivers and props[
"Device"] in self.rfcomm_dev:
dprint("It's our bluetooth modem!")
modem = get_icon("modem", 24)
blueman = get_icon("blueman", 48)
icon = composite_icon(blueman, [(modem, 24, 24, 255)])
Notification(
_("Bluetooth Dialup"),
_("DUN connection on %s will now be available in Network Manager"
) % self.service.device['Alias'],
pixbuf=icon,
status_icon=self.parent.Applet.Plugins.StatusIcon)
self.reply(self.rfcomm_dev)
self.cleanup()
def do_apply(self):
if not self.netconf.locked("dhcp") or self.netconf.ip4_changed:
if self.netconf.ip4_changed:
self.do_remove()
dhcp_config, existing_subnet = self._read_dhcp_config()
subnet = self._generate_subnet_config()
# if subnet != self.existing_subnet:
f = open(DHCP_CONFIG_FILE, "w")
f.write(dhcp_config)
f.write(subnet)
f.close()
cmd = [
have("dhcpd3") or have("dhcpd"), "-pf",
"/var/run/dhcpd.pan1.pid", "pan1"
]
p = Popen(cmd)
ret = p.wait()
if ret == 0:
dprint("dhcpd started correctly")
f = open("/var/run/dhcpd.pan1.pid", "r")
self.pid = int(f.read())
f.close()
dprint("pid", self.pid)
self.netconf.lock("dhcp")
else:
raise NetworkSetupError(
"dhcpd failed to start. Check the system log for errors")
def _on_object_removed(self, object_manager, dbus_object):
session_proxy = dbus_object.get_interface('org.bluez.obex.Session1')
if session_proxy:
session_path = session_proxy.get_object_path()
dprint(session_path)
self.emit('session-removed', session_path)
def Authorize(self, device, uuid, ok, err):
def on_auth_action(n, action):
dprint(action)
#self.applet.status_icon.set_blinking(False)
if action == "always":
device = Bluez.Device(n._device)
device.set("Trusted", True)
if action == "always" or action == "accept":
ok()
else:
err(AgentErrorRejected())
self.n = None
dprint("Agent.Authorize")
alias = self.get_device_alias(device)
uuid16 = uuid128_to_uuid16(uuid)
service = uuid16_to_name(uuid16)
notify_message = (_("Authorization request for:") + "\n%s\n" +
_("Service:") + " <b>%s</b>") % (alias, service)
actions = [["always", _("Always accept")], ["accept",
_("Accept")],
["deny", _("Deny")]]
n = Notification(_("Bluetooth Authentication"),
notify_message,
0,
actions,
on_auth_action,
pixbuf=get_icon("blueman", 48),
status_icon=self.status_icon)
n._device = device
def on_adapter_changed(self, devlist, adapter_path):
dprint("changed")
if adapter_path is None:
self.update_adapters_list()
else:
if self.List.Adapter:
self.List.DisplayKnownDevices()
def _on_authorize(self, _agent, transfer_path):
transfer = obex.Transfer(transfer_path)
session = obex.Session(transfer.session)
root = session.root
address = session.address
filename = transfer.name
size = transfer.size
try:
device = self._applet.Manager.get_adapter().find_device(address)
name = device["Alias"]
trusted = device["Trusted"]
except Exception as e:
dprint(e)
name = address
trusted = False
self._pending_transfer = {
'transfer_path': transfer_path,
'address': address,
'root': root,
'filename': filename,
'size': size,
'name': name
}
try:
status_icon = self._applet.Plugins.StatusIcon
except:
status_icon = None
# This device was neither allowed nor is it trusted -> ask for confirmation
if address not in self._allowed_devices and not (
self._config['opp-accept'] and trusted):
self._notification = Notification(
_("Incoming file over Bluetooth"),
_("Incoming file %(0)s from %(1)s") % {
"0": "<b>" + filename + "</b>",
"1": "<b>" + name + "</b>"
},
30000, [["accept", _("Accept"), "help-about"],
["reject", _("Reject"), "help-about"]],
self._on_action,
pixbuf=get_icon("blueman", 48),
status_icon=status_icon)
# Device is trusted or was already allowed, larger file -> display a notification, but auto-accept
elif size > 350000:
self._notification = Notification(
_("Receiving file"),
_("Receiving file %(0)s from %(1)s") % {
"0": "<b>" + filename + "</b>",
"1": "<b>" + name + "</b>"
},
pixbuf=get_icon("blueman", 48),
status_icon=status_icon)
self._on_action(self._notification, 'accept')
# Device is trusted or was already allowed. very small file -> auto-accept and transfer silently
else:
self._notification = None
self._on_action(self._notification, "accept")
def __init__(self, instance):
GObject.GObject.__init__(self)
self.Properties = {}
self.Temp = False
if hasattr(instance, "format") and hasattr(instance, "upper"):
self.Device = BluezDevice(instance)
else:
self.Device = instance
#set fallback icon, fixes lp:#327718
self.Device.Icon = "blueman"
self.Device.Class = "unknown"
self.Valid = True
dprint("caching initial properties")
self.Properties = self.Device.get_properties()
w = weakref.ref(self)
self._obj_path = self.Device.get_object_path()
self.Device.connect_signal('property-changed',
lambda _device, key, value: w() and w().property_changed(key, value))
self._any_adapter = Adapter()
self._any_adapter.connect_signal('device-removed',
lambda _adapter, path: w() and w().on_device_removed(path))
def io_event(self, source, condition):
if condition & GObject.IO_ERR or condition & GObject.IO_HUP:
return False
data = os.read(self.fd, RFKILL_EVENT_SIZE_V1)
if len(data) != RFKILL_EVENT_SIZE_V1:
dprint("Bad rfkill event size")
else:
(idx, type, op, soft, hard) = struct.unpack("IBBBB", data)
if op == RFKillOp.ADD:
self.switches[idx] = Switch(idx, type, soft, hard)
self.emit("switch-added", self.switches[idx])
elif op == RFKillOp.DEL:
sw = self.switches[idx]
del self.switches[idx]
self.emit("switch-removed", sw)
elif op == RFKillOp.CHANGE:
orig_soft = self.switches[idx].soft
orig_hard = self.switches[idx].hard
if orig_soft != soft or orig_hard != hard:
self.switches[idx].type = type
self.switches[idx].soft = soft
self.switches[idx].hard = hard
self.emit("switch-changed", self.switches[idx])
return True
def RequestPasskey(self, device, ok, err):
dprint("Agent.RequestPasskey")
dialog_msg = _("Enter passkey for authentication:")
notify_msg = _("Enter passkey")
self.ask_passkey(device, dialog_msg, notify_msg, True, False, ok, err)
if self.dialog:
self.dialog.present_with_time(self.time)
def io_event(self, source, condition):
if condition & GObject.IO_ERR or condition & GObject.IO_HUP:
return False
data = os.read(self.fd, RFKILL_EVENT_SIZE_V1)
if len(data) != RFKILL_EVENT_SIZE_V1:
dprint("Bad rfkill event size")
else:
(idx, type, op, soft, hard) = struct.unpack("IBBBB", data)
if op == RFKillOp.ADD:
self.switches[idx] = Switch(idx, type, soft, hard)
self.emit("switch-added", self.switches[idx])
elif op == RFKillOp.DEL:
sw = self.switches[idx]
del self.switches[idx]
self.emit("switch-removed", sw)
elif op == RFKillOp.CHANGE:
orig_soft = self.switches[idx].soft
orig_hard = self.switches[idx].hard
if orig_soft != soft or orig_hard != hard:
self.switches[idx].type = type
self.switches[idx].soft = soft
self.switches[idx].hard = hard
self.emit("switch-changed", self.switches[idx])
return True
def SetAdapter(self, adapter=None):
self.clear()
if self.discovering:
self.emit("adapter-property-changed", self.Adapter, ("Discovering", False))
self.StopDiscovery()
if adapter is not None and adapter != "" and not re.match("hci[0-9]*", adapter):
adapter = adapter_path_to_name(adapter)
dprint(adapter)
try:
self.Adapter = self.manager.get_adapter(adapter)
self.Adapter.connect_signal('property-changed', self._on_property_changed)
self.manager.connect_signal('device-created', self._on_device_created)
self.manager.connect_signal('device-removed', self._on_device_removed)
self.__adapter_path = self.Adapter.get_object_path()
self.emit("adapter-changed", self.__adapter_path)
except Bluez.errors.DBusNoSuchAdapterError as e:
dprint(e)
#try loading default adapter
if len(self.manager.list_adapters()) > 0 and adapter is not None:
self.SetAdapter()
else:
self.Adapter = None
self.emit("adapter-changed", None)
def Authorize(self, device, uuid, ok, err):
def on_auth_action(n, action):
dprint(action)
#self.applet.status_icon.set_blinking(False)
if action == "always":
device = Bluez.Device(n._device)
device.set("Trusted", True)
if action == "always" or action == "accept":
ok()
else:
err(AgentErrorRejected())
self.n = None
dprint("Agent.Authorize")
alias = self.get_device_alias(device)
uuid16 = uuid128_to_uuid16(uuid)
service = uuid16_to_name(uuid16)
notify_message = (_("Authorization request for:") + "\n%s\n" + _("Service:") + " <b>%s</b>") % (alias, service)
actions = [["always", _("Always accept"), "blueman-trust"],
["accept", _("Accept"), "help-about"],
["deny", _("Deny"), "help-about"]]
n = Notification(_("Bluetooth Authentication"), notify_message, 0,
actions, on_auth_action,
pixbuf=get_icon("blueman", 48), status_icon=self.status_icon)
n._device = device
def RequestPasskey(self, device, ok, err):
dprint("Agent.RequestPasskey")
dialog_msg = _("Enter passkey for authentication:")
notify_msg = _("Enter passkey")
self.ask_passkey(device, dialog_msg, notify_msg, True, True, ok, err)
if self.dialog:
self.dialog.present_with_time(self.time_func())
def _on_authorize_service(self, parameters, invocation):
def on_auth_action(n, action):
dprint(action)
#self.applet.status_icon.set_blinking(False)
if action == "always":
device = Bluez.Device(n._device)
device.set("Trusted", True)
if action == "always" or action == "accept":
invocation.return_value(GLib.Variant('()', ()))
else:
invocation.return_dbus_error('org.bluez.Error.Rejected', 'Rejected')
self.n = None
device, uuid = parameters.unpack()
dprint("Agent.Authorize")
alias = self.get_device_alias(device)
uuid16 = uuid128_to_uuid16(uuid)
service = uuid16_to_name(uuid16)
notify_message = (_("Authorization request for:") + "\n%s\n" + _("Service:") + " <b>%s</b>") % (alias, service)
actions = [["always", _("Always accept")],
["accept", _("Accept")],
["deny", _("Deny")]]
n = Notification(_("Bluetooth Authentication"), notify_message, 0,
actions, on_auth_action,
pixbuf=get_icon("blueman", 48), status_icon=self.status_icon)
n._device = device
def do_apply(self):
if not self.netconf.locked("dhcp") or self.netconf.ip4_changed:
if self.netconf.ip4_changed:
self.do_remove()
dhcp_config, existing_subnet = self._read_dhcp_config()
subnet = self._generate_subnet_config()
# if subnet != self.existing_subnet:
f = open(DHCP_CONFIG_FILE, "w")
f.write(dhcp_config)
f.write(subnet)
f.close()
cmd = [have("dhcpd3") or have("dhcpd"), "-pf", "/var/run/dhcpd-server/dhcp.pan1.pid", "pan1"]
p = Popen(cmd)
ret = p.wait()
if ret == 0:
dprint("dhcpd started correctly")
f = open("/var/run/dhcp-server/dhcpd.pan1.pid", "r")
self.pid = int(f.read())
f.close()
dprint("pid", self.pid)
self.netconf.lock("dhcp")
else:
raise Exception("dhcpd failed to start. Check the system log for errors")
def on_adapter_changed(self, lst, adapter_path):
dprint("toolbar adapter", adapter_path)
if adapter_path is None:
self.b_search.props.sensitive = False
self.b_send.props.sensitive = False
else:
self.b_search.props.sensitive = True
def on_apply(self):
if self.on_query_apply_state():
dprint("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 = NetworkErrorDialog(e, parent=self.widget.get_toplevel())
d.run()
d.destroy()
return
else:
self.Config["nap-enable"] = False
m.DisableNetwork()
self.clear_options()
def on_activate():
dprint("adapter powered", path)
if self.Adapter is None:
self.SetAdapter(path)
self.emit("adapter-added", path)
def RequestPinCode(self, device, ok, err):
dprint("Agent.RequestPinCode")
dialog_msg = _("Enter PIN code for authentication:")
notify_msg = _("Enter PIN code")
self.ask_passkey(device, dialog_msg, notify_msg, False, True, ok, err)
if self.dialog:
self.dialog.present_with_time(self.time_func())
def __setattr__(self, key, value):
if not key in self.__dict__ and "Properties" in self.__dict__ and key in self.__dict__["Properties"]:
if not self.Valid:
raise Exception("Attempted to set properties for an invalidated device")
dprint("Setting property", key, value)
self.__dict__["Device"].set(key, value)
else:
self.__dict__[key] = value
def Cancel(self):
dprint("Agent.Cancel")
if self.dialog:
self.dialog.response(Gtk.ResponseType.REJECT)
try:
self.n.close()
except:
pass
def __getattr__(self, name):
if name in self.__dict__["Properties"]:
if not self.Valid:
#traceback.print_stack()
dprint("Warning: Attempted to get %s property for an invalidated device" % name)
return self.__dict__["Properties"][name]
else:
return getattr(self.Device, name)
def Cancel(self):
dprint("Agent.Cancel")
if self.dialog:
self.dialog.response(Gtk.ResponseType.REJECT)
try:
self.n.close()
except:
pass
def _on_transfer_completed(self, transfer, success):
transfer_path = transfer.get_object_path()
signals = self.__transfers.pop(transfer_path)
for sig in signals:
transfer.disconnect_signal(sig)
dprint(transfer_path, success)
self.emit('transfer-completed', transfer_path, success)
def on_device_created(self, path):
dprint("created", path)
iter = self.find_device_by_path(path)
if iter == None:
dev = Bluez.Device(path)
dev = Device(dev)
dev.Temp = True
self.device_add_event(dev)
def on_adapter_selected(self, cb_adapters):
dprint("selected")
iter = cb_adapters.get_active_iter()
if iter:
adapter_path = cb_adapters.get_model().get_value(iter, 1)
if self.List.Adapter:
if self.List.Adapter.get_object_path() != adapter_path:
self.List.SetAdapter(os.path.basename(adapter_path))
