示例#1
0
    def dhcp_acquire(self, device):
        if device not in self.quering:
            self.quering.append(device)
        else:
            return

        if device != "":
            def reply(_obj, result, _user_data):
                logging.info(result)
                Notification(_("Bluetooth Network"),
                             _("Interface %(0)s bound to IP address %(1)s") % {"0": device, "1": result},
                             icon_name="network-workgroup", pos_hint=self.Applet.Plugins.StatusIcon.geometry).show()

                self.quering.remove(device)

            def err(_obj, result, _user_data):
                logging.warning(result)
                Notification(_("Bluetooth Network"), _("Failed to obtain an IP address on %s") % (device),
                             icon_name="network-workgroup", pos_hint=self.Applet.Plugins.StatusIcon.geometry).show()

                self.quering.remove(device)

            Notification(_("Bluetooth Network"), _("Trying to obtain an IP address on %s\nPlease wait..." % device),
                         icon_name="network-workgroup", pos_hint=self.Applet.Plugins.StatusIcon.geometry).show()

            m = Mechanism()
            m.DhcpClient(str('(s)'), device, result_handler=reply, error_handler=err, timeout=120)
示例#2
0
    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()
示例#3
0
    def __init__(self):
        GObject.GObject.__init__(self)
        self.state = True
        self.hardblocked = False

        self.switches = {}

        mode = os.stat("/dev/rfkill").st_mode

        flags = 0
        if os.getuid() == 0:
            flags = os.O_RDWR
        else:
            if (mode & stat.S_IWOTH) == 0:
                flags = os.O_RDONLY
            else:
                flags = os.O_RDWR

            if (mode & stat.S_IROTH) == 0:
                m = Mechanism()
                m.DevRfkillChmod()

        flags |= os.O_NONBLOCK

        self.fd = os.open("/dev/rfkill", flags)

        ref = weakref.ref(self)
        self.iom = GObject.io_add_watch(self.fd, GObject.IO_IN | GObject.IO_ERR | GObject.IO_HUP,
                                        lambda *args: ref() and ref().io_event(*args))
示例#4
0
    def RegisterModem(self, device_path, rfcomm_device):
        dev = Bluez.Device(device_path)
        props = dev.get_properties()

        m = Mechanism()

        def reply():
            dprint("Registered modem")

        def err(excp):
            d = Gtk.MessageDialog(None, type=Gtk.MessageType.WARNING)
            d.props.icon_name = "blueman"
            d.props.text = _("CDMA or GSM not supported")
            d.props.secondary_text = _(
                "The device %s does not appear to support GSM/CDMA.\nThis connection will not work."
            ) % props["Alias"]

            d.add_button(Gtk.STOCK_OK, Gtk.ResponseType.NO)
            resp = d.run()
            d.destroy()

        m.HalRegisterModemPort(rfcomm_device,
                               props["Address"],
                               reply_handler=reply,
                               error_handler=err)
示例#5
0
 def SetGlobalState(self, state, **kwargs):
     dprint("set", state)
     # if we have permission, we just send an event, else we use the dbus interface
     if os.getuid() == 0:
         event = struct.pack("IBBBB", 0, RFKillType.BLUETOOTH, RFKillOp.CHANGE_ALL, (0 if state else 1), 0)
         os.write(self.fd, event)
     else:
         m = Mechanism()
         m.SetRfkillState(state, **kwargs)
示例#6
0
	def connect(self):
		c = Config("gsm_settings/" + self.device.Address)
		if c.props.apn == None:
			c.props.apn = ""
			
		if c.props.number == None:
			c.props.number = "*99#"	
		
		m = Mechanism()
		m.PPPConnect(self.port, c.props.number, c.props.apn, reply_handler=self.on_connected, error_handler=self.on_error, timeout=200)	
示例#7
0
    def connect(self):
        c = Config(
            "org.blueman.gsmsettings",
            "/org/blueman/gsmsettings/%s/" % self.service.device.Address)

        m = Mechanism()
        m.PPPConnect(self.port,
                     c["number"],
                     c["apn"],
                     reply_handler=self.on_connected,
                     error_handler=self.on_error,
                     timeout=200)
示例#8
0
    def connect(self, reply_handler=None, error_handler=None):
        channel = get_rfcomm_channel(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
示例#9
0
文件: Audio.py 项目: posophe/blueman
	def on_apply(self):
		if self.get_options() != []:
			vals = ["Sink"]
			if self.cb_a2dp.props.active:
				vals.append("Source")
			if self.cb_hsp.props.active:
				vals.append("Gateway")
			try:
				m = Mechanism()
				m.SetBluezConfig("audio.conf", "General", "Enable", ",".join(vals))
				m.SaveBluezConfig("audio.conf")
				m.RestartBluez()
			except dbus.DBusException, e:
				dprint(e)
			else:
				self.clear_options()
示例#10
0
    def load_nap_settings(self):
        logging.info("Loading NAP settings")

        def reply(*_):
            pass

        def err(_obj, result, _user_data):
            d = NetworkErrorDialog(
                result,
                "You might not be able to connect to the Bluetooth network via this machine"
            )
            d.expander.props.margin_left = 9

            d.run()
            d.destroy()

        m = Mechanism()
        m.ReloadNetwork(result_handler=reply, error_handler=err)
示例#11
0
    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)
示例#12
0
    def load_nap_settings(self):
        dprint("Loading NAP settings")

        def reply():
            pass

        def err(excp):
            d = NetworkErrorDialog(
                excp,
                "You might not be able to connect to the Bluetooth network via this machine"
            )
            d.expander.props.margin_left = 9

            d.run()
            d.destroy()

        m = Mechanism()
        m.ReloadNetwork(reply_handler=reply, error_handler=err)
示例#13
0
    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)

                    if not self.NetConf.props.nap_enable:  # race condition workaround
                        self.ignored_keys.append("nap_enable")
                    self.NetConf.props.nap_enable = True
                except Exception as e:
                    lines = str(e).splitlines()

                    d = Gtk.MessageDialog(None,
                                          buttons=Gtk.ButtonsType.OK,
                                          type=Gtk.MessageType.ERROR)
                    d.props.icon_name = "dialog-error"
                    d.props.text = _("Failed to apply network settings")
                    d.props.secondary_text = lines[-1]
                    d.run()
                    d.destroy()
                    return
            else:
                if self.NetConf.props.nap_enable:  # race condition workaround
                    self.ignored_keys.append("nap_enable")
                self.NetConf.props.nap_enable = False
                m.DisableNetwork()

            self.clear_options()
示例#14
0
    def on_power_state_change_requested(self, _, state, cb):
        dprint(state)

        def reply(*_):
            cb(True)

        def error(*_):
            cb(False)

        Mechanism().SetRfkillState(state, reply_handler=reply, error_handler=error)
示例#15
0
    def dhcp_acquire(self, device):
        if device not in self.quering:
            self.quering.append(device)
        else:
            return

        if device != "":

            def reply(ip_address):

                Notification(_("Bluetooth Network"),
                             _("Interface %(0)s bound to IP address %(1)s") % {
                                 "0": device,
                                 "1": ip_address
                             },
                             pixbuf=get_icon("gtk-network", 48),
                             status_icon=self.Applet.Plugins.StatusIcon)

                self.quering.remove(device)

            def err(msg):
                dprint(msg)
                Notification(_("Bluetooth Network"),
                             _("Failed to obtain an IP address on %s") %
                             (device),
                             pixbuf=get_icon("gtk-network", 48),
                             status_icon=self.Applet.Plugins.StatusIcon)

                self.quering.remove(device)

            Notification(
                _("Bluetooth Network"),
                _("Trying to obtain an IP address on %s\nPlease wait..." %
                  device),
                pixbuf=get_icon("gtk-network", 48),
                status_icon=self.Applet.Plugins.StatusIcon)

            m = Mechanism()
            m.DhcpClient(device,
                         reply_handler=reply,
                         error_handler=err,
                         timeout=120)
示例#16
0
    def load_nap_settings(self):
        dprint("Loading NAP settings")

        def reply():
            pass

        def err(excp):
            lines = str(excp).splitlines()
            d = Gtk.MessageDialog(None,
                                  buttons=Gtk.ButtonsType.OK,
                                  type=Gtk.MessageType.ERROR)
            d.props.text = _("Failed to apply network settings")
            d.props.secondary_text = lines[-1] + "\n\n" + _(
                "You might not be able to connect to the Bluetooth network via this machine"
            )
            d.run()
            d.destroy()

        m = Mechanism()
        m.ReloadNetwork(reply_handler=reply, error_handler=err)
示例#17
0
    def on_power_state_change_requested(self, _, state, cb):
        logging.info(state)

        def reply(*_):
            cb(True)

        def error(*_):
            cb(False)

        Mechanism().SetRfkillState(str('(b)'),
                                   state,
                                   result_handler=reply,
                                   error_handler=error)
示例#18
0
 def connect(self, reply_handler=None, error_handler=None):
     props = self.device.get_properties()
     try:
         # TODO: Channel?
         port_id = create_rfcomm_device(Adapter(props['Adapter']).get_properties()['Address'], props['Address'], 1)
         Mechanism().open_rfcomm(port_id)
         if reply_handler:
             reply_handler('/dev/rfcomm%d' % port_id)
     except Exception as e:
         if error_handler:
             error_handler(e)
         else:
             raise e
     return True
示例#19
0
    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()
示例#20
0
 def connect(self, reply_handler=None, error_handler=None):
     try:
         # TODO: Channel?
         port_id = create_rfcomm_device(
             Adapter(self.device["Adapter"])['Address'],
             self.device["Address"], 1)
         Mechanism().open_rfcomm(str('(d)'), port_id)
         if reply_handler:
             reply_handler('/dev/rfcomm%d' % port_id)
     except Exception as e:
         if error_handler:
             error_handler(e)
         else:
             raise e
     return True
示例#21
0
    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)
示例#22
0
    def connect(self, reply_handler=None, error_handler=None):
        props = self.device.get_properties()
        short_uuid = uuid128_to_uuid16(self.uuid)
        channel = get_rfcomm_channel(short_uuid, props['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(props['Adapter']).get_properties()['Address'], props['Address'], channel)
            Mechanism().open_rfcomm(port_id)

            if reply_handler:
                reply_handler('/dev/rfcomm%d' % port_id)
        except RFCOMMError as e:
            if error_handler:
                error_handler(e)
            else:
                raise e
        return True
示例#23
0
 def disconnect(self, port):
     Mechanism().PPPDisconnect(port)
     super().disconnect(port)
示例#24
0
 def on_network_prop_changed(self, key, value, path):
     if key == "Interface":
         if value != "":
             m = Mechanism()
             m.HalRegisterNetDev(value)
示例#25
0
 def disconnect(self, *args):
     Mechanism().close_rfcomm(args[0])
示例#26
0
 def disconnect(self, *args):
     Mechanism().close_rfcomm(args[0])
     release_rfcomm_device(args[0])
示例#27
0
    def UnregisterModem(self, device):
        m = Mechanism()
        m.HalUnregisterModemPortDev(device)

        dprint("Unregistered modem")