patchler işlenmiş hali.

Author: mthnzbk

comar/__init__.py

@@ -0,0 +1,206 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2006-2009, TUBITAK/UEKAE
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version. Please read the COPYING file.
+#
+
+__version__ = '2.4.9'
+
+import dbus
+import locale
+import os
+import subprocess
+
+class Call:
+    def __init__(self, link, group, class_=None, package=None, method=None):
+        self.link = link
+        self.group = group
+        self.class_ = class_
+        self.package = package
+        self.method = method
+        self.async = None
+        self.quiet = False
+
+        if self.package:
+            self.package = self.package.replace("-", "_")
+
+    def __getitem__(self, key):
+        if not self.class_:
+            raise KeyError, "Package should be selected after class"
+        if not isinstance(key, basestring):
+            raise KeyError
+        return Call(self.link, self.group, self.class_, key)
+
+    def __getattr__(self, name):
+        if self.class_:
+            c = Call(self.link, self.group, self.class_, self.package, name)
+            return c.call
+        else:
+            if name[0] < 'A' or name[0] > 'Z':
+                raise AttributeError
+
+            return Call(self.link, self.group, name)
+
+    def __iter__(self):
+        if self.class_:
+            obj = self.link.bus.get_object(self.link.address, "/", introspect=False)
+            packages = obj.listModelApplications("%s.%s" % (self.group, self.class_), dbus_interface=self.link.interface)
+            for package in packages:
+                yield unicode(package)
+
+    def call(self, *args, **kwargs):
+        self.async = kwargs.get("async", None)
+        self.quiet = kwargs.get("quiet", False)
+        self.timeout = kwargs.get("timeout", 120)
+        if self.async and self.quiet:
+            raise Exception, "async and quiet arguments can't be used together"
+        if self.async or self.quiet:
+            if self.package:
+                obj = self.link.bus.get_object(self.link.address, "/package/%s" % self.package)
+                met = getattr(obj, self.method)
+
+                def handleResult(*result):
+                    self.async(self.package, None, result)
+                def handleError(exception):
+                    if "policy.auth" in exception._dbus_error_name or "Comar.PolicyKit" in exception._dbus_error_name:
+                        action = exception.get_dbus_message()
+                        if self.queryPolicyKit(action):
+                            return self.call(*args, **kwargs)
+                    self.async(self.package, exception, None)
+
+                if self.quiet:
+                    met(dbus_interface="%s.%s.%s" % (self.link.interface, self.group, self.class_), *args)
+                else:
+                    met(dbus_interface="%s.%s.%s" % (self.link.interface, self.group, self.class_), reply_handler=handleResult, error_handler=handleError, timeout=self.timeout, *args)
+            else:
+                def handlePackages(packages):
+                    if self.quiet:
+                        for package in packages:
+                            obj = self.link.bus.get_object(self.link.address, "/package/%s" % package)
+                            met = getattr(obj, self.method)
+                            met(dbus_interface="%s.%s.%s" % (self.link.interface, self.group, self.class_), *args)
+                    else:
+                        def handleResult(package):
+                            def handler(*result):
+                                return self.async(package, None, result)
+                            return handler
+                        def handleError(package):
+                            def handler(exception):
+                                return self.async(package, exception, None)
+                            return handler
+
+                        for package in packages:
+                            obj = self.link.bus.get_object(self.link.address, "/package/%s" % package)
+                            met = getattr(obj, self.method)
+
+                            met(dbus_interface="%s.%s.%s" % (self.link.interface, self.group, self.class_), reply_handler=handleResult(package), error_handler=handleError(package), timeout=self.timeout, *args)
+
+                def handlePackError(exception):
+                    if self.quiet:
+                        pass
+                    else:
+                        raise exception
+
+                if self.quiet:
+                    obj = self.link.bus.get_object(self.link.address, "/", introspect=False)
+                    packages = obj.listModelApplications("%s.%s" % (self.group, self.class_), dbus_interface=self.link.interface)
+                    handlePackages(packages)
+                else:
+                    obj = self.link.bus.get_object(self.link.address, "/", introspect=False)
+                    obj.listModelApplications("%s.%s" % (self.group, self.class_), dbus_interface=self.link.interface, reply_handler=handlePackages, error_handler=handlePackError, timeout=self.timeout)
+        else:
+            if self.package:
+                obj = self.link.bus.get_object(self.link.address, "/package/%s" % self.package)
+                met = getattr(obj, self.method)
+                try:
+                    return met(dbus_interface="%s.%s.%s" % (self.link.interface, self.group, self.class_), timeout=self.timeout, *args)
+                except dbus.DBusException, exception:
+                    if "policy.auth" in exception._dbus_error_name or "Comar.PolicyKit" in exception._dbus_error_name:
+                        action = exception.get_dbus_message()
+                        if self.queryPolicyKit(action):
+                            return self.call(*args, **kwargs)
+                    raise dbus.DBusException, exception
+            else:
+                raise AttributeError, "Package name required for non-async calls."
+
+    def queryPolicyKit(self, action):
+        return False
+
+
+class Link:
+    def __init__(self, version="2", socket=None, alternate=False):
+        self.version = str(version)
+        self.address = "tr.org.pardus.comar"
+        self.interface = "tr.org.pardus.comar"
+        self.socket = socket
+
+        # Auto-enable agent, if X session present.
+        self.use_agent = ("DISPLAY" in os.environ)
+
+        if not socket:
+            self.bus = dbus.SystemBus()
+        else:
+            self.bus = dbus.bus.BusConnection(address_or_type="unix:path=%s" % socket)
+
+        if alternate:
+            self.address += "2"
+
+    def useAgent(self, agent=True):
+        self.use_agent = agent
+
+    def setLocale(self):
+        try:
+            code, encoding = locale.getdefaultlocale()
+            if code:
+                if "_" in code:
+                    code = code.split("_")[0]
+                obj = self.bus.get_object(self.address, '/', introspect=False)
+                obj.setLocale(code, dbus_interface=self.interface)
+        except dbus.DBusException, exception:
+            pass
+
+    def cancel(self, method="*"):
+        try:
+            obj = self.bus.get_object(self.address, '/', introspect=False)
+            return obj.cancel(method, dbus_interface=self.interface)
+        except dbus.DBusException, exception:
+            return 0
+
+    def listRunning(self, all=True):
+        methods = []
+        try:
+            obj = self.bus.get_object(self.address, '/', introspect=False)
+            methods = obj.listRunning(all, dbus_interface=self.interface)
+        except dbus.DBusException, exception:
+            return methods
+        for index, method in enumerate(methods):
+            if method.startswith("%s." % self.interface):
+                methods[index] = method[len("%s." % self.interface):]
+        return methods
+
+    def listenSignals(self, model, handler):
+        def sigHandler(*args, **kwargs):
+            if "/package/" not in kwargs["path"]:
+                return
+            package = kwargs["path"].split("/package/")[1]
+            signal = kwargs["signal"]
+            handler(package, signal, args)
+        self.bus.add_signal_receiver(sigHandler, dbus_interface="%s.%s" % (self.interface, model), member_keyword="signal", path_keyword="path")
+
+    def register(self, app, model, script, timeout=120):
+        obj = self.bus.get_object(self.address, '/', introspect=False)
+        obj.register(app, model, script, dbus_interface=self.interface, timeout=timeout)
+
+    def remove(self, app, timeout=120):
+        obj = self.bus.get_object(self.address, '/', introspect=False)
+        obj.remove(app, dbus_interface=self.interface, timeout=timeout)
+
+    def __getattr__(self, name):
+        if name[0] < 'A' or name[0] > 'Z':
+            raise AttributeError
+        return Call(self, name)

comar/network.py

@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2006-2009, TUBITAK/UEKAE
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free
+# Software Foundation; either version 2 of the License, or (at your option)
+# any later version.
+#
+# Please read the COPYING file.
+#
+
+"""network module provides network management utils."""
+
+import os
+import subprocess
+
+from pisilinux import iniutils
+from pisilinux import netutils
+
+from comar.service import startService, stopService, loadConfig
+
+NET_PATH = "/etc/network"
+NET_STACK = "baselayout"
+
+MSG_PROFILE_NAME = {
+    "en": "You have to enter a profile name to create a connection",
+    "tr": "Bağlantı yaratmak için profil ismi girmelisiniz",
+}
+
+INI = iniutils.iniParser(os.path.join(NET_PATH, script()), quiet=True)
+
+def listProfiles():
+    try:
+        return INI.listSections()
+    except iniutils.iniParserError:
+        return []
+
+class Profile:
+    def __init__(self, name):
+        if not len(name):
+            fail(_(MSG_PROFILE_NAME))
+        self.name = name
+        try:
+            self.info = INI.getSection(name)
+        except iniutils.iniParserError:
+            self.info = {}
+
+    def delete(self):
+        INI.removeSection(self.name)
+
+    def save(self, no_notify=False):
+        is_new = self.name not in listProfiles()
+        INI.setSection(self.name, self.info)
+        if no_notify:
+            return
+        if is_new:
+            notify("Network.Link", "connectionChanged", ("added", self.name))
+        else:
+            notify("Network.Link", "connectionChanged", ("changed", self.name))
+
+class AccessPoint:
+    def __init__(self, id=None):
+        self.ssid = ""
+        self.mode = ""
+        self.mac = ""
+        self.encryption = "none"
+        self.qual = ""
+        self.qual_max = "100"
+        self.protocol = ""
+        self.channel = ""
+        if id:
+            if " (" in id and id.endswith(")"):
+                self.ssid, rest = id.split(" (", 1)
+                self.mode, self.mac = rest.split(" ", 1)
+                self.mac = self.mac[:-1]
+            else:
+                self.ssid = id
+
+    def id(self):
+        d = {
+            "remote": self.ssid,
+            "mode": self.mode,
+            "mac": self.mac,
+            "encryption": self.encryption,
+            "quality": self.qual,
+            "quality_max": self.qual_max,
+            "protocol": self.protocol,
+            "channel": self.channel,
+        }
+        return d
+
+def stopSameDevice(name):
+    from csl import setState
+    profile = Profile(name)
+    device = profile.info["device"]
+    for pn in listProfiles():
+        if pn == name:
+            continue
+        pro = Profile(pn)
+        if pro.info["device"] == device:
+            setState(pn, "down")
+
+def registerNameServers(profile, iface):
+    name_mode = profile.info.get("name_mode", "default")
+    name_servers = []
+    name_domain = ""
+    if name_mode == "auto":
+        for server in iface.autoNameServers():
+            name_servers.append(server)
+        name_domain = iface.autoNameSearch()
+    elif name_mode == "custom":
+        for server in profile.info.get("name_server", ",").split():
+           if server.strip():
+               name_servers.append(server.strip())
+    elif name_mode == "default":
+        name_servers = call(NET_STACK, "Network.Stack", "getNameServers")
+    call(NET_STACK, "Network.Stack", "registerNameServers", (iface.name, name_servers, name_domain))
+
+def unregisterNameServers(ifname):
+    call(NET_STACK, "Network.Stack", "unregisterNameServers", (ifname, [], ""))
+
+def callScript(name, state):
+    path = os.path.join("/etc/network/netlink.d", "%s.%s" % (name, state))
+    if os.path.exists(path):
+        try:
+            subprocess.call([path])
+        except:
+            pass
+
+def plugService(device, state, wireless=False):
+    # Do nothing if ifplugd is missing
+    if not os.path.exists("/usr/sbin/ifplugd"):
+        return
+    if state == "up":
+        # Do nothing if device is missing
+        if not netutils.IF(device):
+            return
+        # Load service configuration
+        config = loadConfig("/etc/conf.d/ifplugd")
+        # Get arguments
+        if wireless:
+            args = config.get("IFPLUGD_WLAN_ARGS", "")
+        else:
+            args = config.get("IFPLUGD_ARGS", "")
+        # Start service
+        startService(command="/usr/sbin/ifplugd",
+                     args="%s -i %s" % (args, device),
+                     pidfile="/run/ifplugd.%s.pid" % device,
+                     detach=True,
+                     donotify=False)
+    else:
+        # Stop service
+        stopService(pidfile="/run/ifplugd.%s.pid" % device, donotify=False)
+
+def plugCheck(device):
+    # Return true if ifplugd is missing
+    if not os.path.exists("/usr/sbin/ifplugstatus"):
+        return True
+    return subprocess.call(["/usr/sbin/ifplugstatus", "-q", device]) == 2