* python/dbus_bindings.pyx.in: removed

* python/dbus_bindings.pyx: Added.
	- Fixed some memleaks (patch from
	  Sean Meiners <sean.meiners@linspireinc.com>)
	- Broke out the #include "dbus_h_wrapper.h" and put it in its
	  own pxd file (Pyrex definition)
	- Broke out glib dependancies into its own pyx module

* python/dbus_bindings.pdx: Added.
	- Defines C class Connection for exporting to other modules

* python/dbus_glib_bindings.pyx: Added.
	- New module to handle lowlevel dbus-glib mainloop integration

* python/glib.py: Added.
	- Registers the glib mainloop when you import this module

* python/services.py: Removed (renamed to service.py)

* python/service.py: Added.
	- (class Server): renamed Name

* python/__init__.py: Bump ro version (0,41,0)
	- don't import the decorators or service module
   	  by default.  These now reside in the dbus.service namespace

* python/_dbus.py (Bus::__init__): Add code run the main loop
  setup function on creation

* python/examples/example-service.py,
  python/examples/example-signal-emitter.py: update examples

* python/examples/gconf-proxy-service.py,
  python/examples/gconf-proxy-service2.py: TODO fix these up

* doc/TODO: Addition
	- Added a Python Bindings 1.0 section
	- added "Add match on args or match on details to match rules"

1 files changed, 1488 insertions, 0 deletions

diff --git a/python/dbus_bindings.pyx b/python/dbus_bindings.pyx
new file mode 100644
index 00000000..608ef544
--- /dev/null
+++ b/python/dbus_bindings.pyx
@@ -0,0 +1,1488 @@
+# -*- Mode: Python -*-
+
+# jdahlin is the most coolest and awesomest person in the world
+# and wrote all the good parts of this code. all the bad parts
+# where python conditionals have a ( ) around them, thus violating
+# PEP-8 were written by the lame wannabe python programmer seth
+
+#FIXME: find memory leaks that I am sure exist
+
+cdef extern from "sys/types.h":
+    ctypedef size_t
+    ctypedef __int64_t
+    ctypedef __uint64_t
+
+cdef extern from "sys/cdefs.h":
+    ctypedef __signed
+
+cdef extern from "stdlib.h":
+    cdef void *malloc(size_t size)
+    cdef void free(void *ptr)
+    cdef void *calloc(size_t nmemb, size_t size)
+
+cdef extern from "Python.h":
+    void Py_XINCREF (object)
+    void Py_XDECREF (object)
+    object PyString_FromStringAndSize(char *, int)
+    ctypedef void *PyGILState_STATE
+    void PyErr_Clear()
+    PyGILState_STATE PyGILState_Ensure()
+    void PyGILState_Release(PyGILState_STATE)
+
+ctypedef struct DBusError:
+    char *name
+    char *message
+    unsigned int dummy1 
+    unsigned int dummy2
+    unsigned int dummy3
+    unsigned int dummy4
+    unsigned int dummy5
+    void *padding1
+    
+ctypedef struct DBusMessageIter:
+    void *dummy1
+    void *dummy2
+    dbus_uint32_t dummy3
+    int dummy4
+    int dummy5
+    int dummy6
+    int dummy7
+    int dummy8
+    int dummy9
+    int dummy10
+    int dummy11
+    int pad1
+    int pad2
+    void *pad3
+
+ctypedef struct DBusObjectPathVTable:
+  DBusObjectPathUnregisterFunction   unregister_function
+  DBusObjectPathMessageFunction      message_function
+  void (* dbus_internal_pad1) (void *)
+  void (* dbus_internal_pad2) (void *)
+  void (* dbus_internal_pad3) (void *)
+  void (* dbus_internal_pad4) (void *)
+
+
+_user_data_references = [ ]
+
+class DBusException(Exception):
+    pass
+
+class ConnectionError(Exception):
+    pass
+
+class ObjectPath(str):
+    def __init__(self, value):
+        str.__init__(value)
+
+class ByteArray(str):
+    def __init__(self, value):
+        str.__init__(value)
+
+class Signature(str):
+    def __init__(self, value):
+        str.__init__(value)
+
+class Byte(int):
+    def __init__(self, value):
+        int.__init__(value)
+
+class Boolean(int):
+    def __init__(self, value):
+        int.__init__(value)
+
+class Int16(int):
+    def __init__(self, value):
+        int.__init__(value)
+
+class UInt16(int):
+    def __init__(self, value):
+        if value < 0:
+            raise TypeError('Unsigned integers must not have a negitive value') 
+        int.__init__(value)
+
+class Int32(int):
+    def __init__(self, value):
+        int.__init__(value)
+
+class UInt32(long):
+    def __init__(self, value):
+        if value < 0:
+            raise TypeError('Unsigned integers must not have a negitive value') 
+        long.__init__(value)
+
+class Int64(long):
+    def __init__(self, value):
+        long.__init__(value)
+
+class UInt64(long):
+    def __init__(self, value):
+        if value < 0:
+            raise TypeError('Unsigned integers must not have a negitive value') 
+        long.__init__(value)
+
+class Double(float):
+    def __init__(self, value):
+        float.__init__(self, value)
+
+class String(str):
+    def __init__(self, value):
+        str.__init__(value)
+
+class Array(list):
+    def __init__(self, value):
+        list.__init__(value)
+
+class Struct(tuple):
+    def __init__(self, value):
+        tuple.__init__(value)
+
+class Dictionary(dict):
+    def __init__(self, value):
+        dict.__init__(value)
+
+#forward delcerations
+cdef class Message
+cdef class PendingCall
+cdef class Watch
+cdef class MessageIter
+
+cdef void cunregister_function_handler (DBusConnection *connection,
+                                        void *user_data):
+    cdef Connection conn
+    cdef PyGILState_STATE gil
+
+    gil = PyGILState_Ensure()
+    try:
+        itup = <object>user_data
+        assert (type(tup) == list)    
+        function = tup[1]
+        conn = Connection()
+        conn.__cinit__(None, connection)
+
+        args = [conn]
+        function(*args)
+    finally:
+        PyGILState_Release(gil)
+
+cdef DBusHandlerResult cmessage_function_handler (DBusConnection *connection,
+                                                  DBusMessage *msg,
+                                                  void *user_data):
+    cdef Connection conn
+    cdef Message message
+    cdef PyGILState_STATE gil
+
+    gil = PyGILState_Ensure()
+    try:
+        tup = <object>user_data
+        assert (type(tup) == list)
+        function = tup[0]
+        message = Message(_create=0)
+        message._set_msg(msg)
+        conn = Connection()
+        conn.__cinit__(None, connection)  
+        args = [conn,
+                message]
+        retval = function(*args)
+        if (retval == None):
+            retval = DBUS_HANDLER_RESULT_HANDLED
+        return retval
+    finally:
+        PyGILState_Release(gil)
+	
+cdef class Connection:
+    def __init__(self, address=None, Connection _conn=None):
+        cdef DBusConnection *c_conn
+        cdef char *c_address
+        c_conn=NULL
+        self.conn = NULL
+        if (_conn != None):
+            c_conn = _conn.conn
+
+        if (address != None or _conn != None):
+            self.__cinit__(c_address, c_conn)
+
+    # hack to be able to pass in a c pointer to the constructor
+    # while still alowing python programs to create a Connection object
+    cdef __cinit__(self, address, DBusConnection *_conn):
+        cdef DBusError error
+        dbus_error_init(&error)
+        if _conn != NULL:
+            self.conn = _conn
+            dbus_connection_ref(self.conn)
+        else:
+            self.conn = dbus_connection_open(address,
+                                         &error)
+            if dbus_error_is_set(&error):
+                raise DBusException, error.message
+
+    def __del__(self):
+        if self.conn != NULL:
+            dbus_connection_unref(self.conn)
+
+    cdef _set_conn(self, DBusConnection *conn):
+        self.conn = conn
+    
+    cdef DBusConnection *_get_conn(self):
+        return self.conn
+    
+    def get_unique_name(self):
+        return bus_get_unique_name(self)
+
+    def disconnect(self):
+        dbus_connection_disconnect(self.conn)
+
+    def get_is_connected(self):
+        return dbus_connection_get_is_connected(self.conn)
+    
+    def get_is_authenticated(self):
+        return dbus_connection_get_is_authenticated(self.conn)
+
+    def flush(self):
+        dbus_connection_flush(self.conn)
+
+    def borrow_message(self):
+        cdef Message m
+        m = Message(_create=0)
+        m._set_msg(dbus_connection_borrow_message(self.conn))
+        return m
+    
+    def return_message(self, Message message):
+        cdef DBusMessage *msg
+        msg = message._get_msg()
+        dbus_connection_return_message(self.conn, msg)
+
+    def steal_borrowed_message(self, Message message):
+        cdef DBusMessage *msg
+        msg = message._get_msg()
+        dbus_connection_steal_borrowed_message(self.conn,
+                                               msg)
+    
+    def pop_message(self):
+        cdef DBusMessage *msg
+        cdef Message m
+ 
+        msg = dbus_connection_pop_message(self.conn)
+        if msg != NULL:
+            m = Message(_create=0)
+            m._set_msg(msg)
+        else:
+            m = None
+        return m        
+
+    def get_dispatch_status(self):
+        return dbus_connection_get_dispatch_status(self.conn)
+    
+    def dispatch(self):
+        return dbus_connection_dispatch(self.conn)
+
+    def send(self, Message message):
+        #cdef dbus_uint32_t client_serial
+        #if type(message) != Message:
+        #    raise TypeError
+        cdef DBusMessage *msg
+        msg = message._get_msg()
+        retval = dbus_connection_send(self.conn,
+                                      msg,
+                                      NULL)
+        return retval
+
+    def send_with_reply_handlers(self, Message message, timeout_milliseconds, reply_handler, error_handler):
+        retval = False
+        try:
+            (retval, pending_call) = self.send_with_reply(message, timeout_milliseconds)
+            if pending_call:
+                pending_call.set_notify(reply_handler, error_handler)
+        except Exception, e:
+            error_handler(e)
+            
+        return retval
+
+    def send_with_reply(self, Message message, timeout_milliseconds):
+        cdef dbus_bool_t retval
+        cdef DBusPendingCall *cpending_call
+        cdef DBusError error
+        cdef DBusMessage *msg
+        cdef PendingCall pending_call
+
+        dbus_error_init(&error)
+
+        cpending_call = NULL
+        
+        msg = message._get_msg()
+
+        retval = dbus_connection_send_with_reply(self.conn,
+                                                 msg,
+                                                 &cpending_call,
+                                                 timeout_milliseconds)
+
+        if dbus_error_is_set(&error):
+            raise DBusException, error.message
+
+        if (cpending_call != NULL):
+            pending_call = PendingCall()
+            pending_call.__cinit__(cpending_call)
+        else:
+            pending_call = None
+
+        return (retval, pending_call)
+                                
+    def send_with_reply_and_block(self, Message message,
+                                  timeout_milliseconds=0):
+        cdef DBusMessage * retval
+        cdef DBusError error
+        cdef DBusMessage *msg
+        cdef Message m
+
+        dbus_error_init(&error)
+
+        msg = message._get_msg()
+
+        retval = dbus_connection_send_with_reply_and_block(
+            self.conn,
+            msg,
+            timeout_milliseconds,
+            &error)
+
+        if dbus_error_is_set(&error):
+            raise DBusException, error.message
+
+        if retval == NULL:
+            raise AssertionError
+        
+        m = Message(_create=0)
+        m._set_msg(retval)
+        return m
+
+    def set_watch_functions(self, add_function, remove_function, data):
+        pass
+
+    def set_timeout_functions(self, add_function, remove_function, data):
+        pass
+
+    def set_wakeup_main_function(self, wakeup_main_function, data):
+        pass
+
+    # FIXME: set_dispatch_status_function, get_unix_user, set_unix_user_function
+
+    def add_filter(self, filter_function):
+        user_data = [ filter_function ]
+        global _user_data_references
+        _user_data_references.append(user_data)
+        
+        return dbus_connection_add_filter(self.conn,
+                                          cmessage_function_handler,
+                                          <void*>user_data,
+                                          NULL)
+
+
+    #FIXME: remove_filter
+    #       this is pretty tricky, we want to only remove the filter
+    #       if we truly have no more calls to our message_function_handler...ugh
+
+    def set_data(self, slot, data):
+        pass
+
+    def get_data(self, slot):
+        pass
+
+    def set_max_message_size(self, size):
+        dbus_connection_set_max_message_size(self.conn, size)
+
+    def get_max_message_size(self):
+        return dbus_connection_get_max_message_size(self.conn)
+
+    def set_max_received_size(self, size):
+        dbus_connection_set_max_received_size(self.conn, size)
+
+    def get_max_received_size(self):
+        return dbus_connection_get_max_received_size(self.conn)
+
+    def get_outgoing_size(self):
+        return dbus_connection_get_outgoing_size(self.conn)    
+
+    # preallocate_send, free_preallocated_send, send_preallocated
+
+    def register_object_path(self, path, unregister_cb, message_cb):
+        cdef DBusObjectPathVTable cvtable
+        
+        cvtable.unregister_function = cunregister_function_handler 
+        cvtable.message_function    = cmessage_function_handler
+
+        user_data = [message_cb, unregister_cb]
+        global _user_data_references
+        _user_data_references.append(user_data)
+        
+        return dbus_connection_register_object_path(self.conn, path, &cvtable,
+                                                    <void*>user_data) 
+
+    def register_fallback(self, path, unregister_cb, message_cb):
+        cdef DBusObjectPathVTable cvtable
+
+        cvtable.unregister_function = cunregister_function_handler 
+        cvtable.message_function    = cmessage_function_handler
+
+        user_data = [message_cb, unregister_cb]
+        global _user_data_references
+        _user_data_references.append(user_data)        
+        
+        return dbus_connection_register_fallback(self.conn, path, &cvtable,
+                                                 <void*>user_data) 
+
+    #FIXME: unregister_object_path , see problems with remove_filter
+
+    def list_registered (self, parent_path):
+        cdef char **cchild_entries
+        cdef dbus_bool_t retval
+        
+        retval = dbus_connection_list_registered(self.conn, parent_path, &cchild_entries)
+
+        if (not retval):
+            #FIXME: raise out of memory exception?
+            return None
+
+        i = 0
+        child_entries = []
+
+        while (cchild_entries[i] != NULL):
+            child_entries.append(cchild_entries[i])
+            i = i + 1
+
+        dbus_free_string_array(cchild_entries)
+
+        return child_entries
+
+cdef void _pending_call_notification(DBusPendingCall *pending_call, void *user_data):
+    cdef DBusMessage *dbus_message
+    cdef Message message
+   
+    (reply_handler, error_handler) = <object>user_data
+   
+    dbus_message = dbus_pending_call_steal_reply(pending_call)
+    message = Message(_create=0)
+    message._set_msg(dbus_message)
+
+    type = message.get_type()
+
+    if type == MESSAGE_TYPE_METHOD_RETURN:
+        args = message.get_args_list()
+        reply_handler(*args)
+    elif type == MESSAGE_TYPE_ERROR:
+        args = message.get_args_list()
+        error_handler(DBusException(args[0]))
+    else:
+        error_handler(DBusException('Unexpected Message Type: ' + message.type_to_name(type)))
+
+    dbus_message_unref(dbus_message)
+    dbus_pending_call_unref(pending_call)
+
+cdef void _pending_call_free_user_data(void *data):
+    call_tuple = <object>data
+    Py_XDECREF(call_tuple)
+
+cdef class PendingCall:
+    cdef DBusPendingCall *pending_call
+
+    def __init__(self, PendingCall _pending_call=None):
+        self.pending_call = NULL
+        if (_pending_call != None):
+            self.__cinit__(_pending_call.pending_call)
+
+    cdef void __cinit__(self, DBusPendingCall *_pending_call):
+        self.pending_call = _pending_call
+        dbus_pending_call_ref(self.pending_call)
+
+    def __del__(self):
+        if self.pending_call != NULL:
+            dbus_pending_call_unref(self.pending_call)
+
+    cdef DBusPendingCall *_get_pending_call(self):
+        return self.pending_call
+
+    def cancel(self):
+        dbus_pending_call_cancel(self.pending_call)
+
+    def get_completed(self):
+        return dbus_pending_call_get_completed(self.pending_call)
+
+    def get_reply(self):
+        cdef Message message
+        message = Message(_create=0)
+        message._set_msg(dbus_pending_call_steal_reply(self.pending_call))
+        return message
+
+    def block(self):
+        dbus_pending_call_block(self.pending_call)
+
+    def set_notify(self, reply_handler, error_handler):
+        user_data = (reply_handler, error_handler)
+        Py_XINCREF(user_data)
+        dbus_pending_call_set_notify(self.pending_call, _pending_call_notification, 
+                                     <void *>user_data, _pending_call_free_user_data)
+        
+
+cdef class Watch:
+    cdef DBusWatch* watch
+
+    def __init__(self):
+        pass
+
+    cdef __cinit__(self, DBusWatch *cwatch):
+        self.watch = cwatch
+
+    def get_fd(self):
+        return dbus_watch_get_fd(self.watch)
+
+    # FIXME: not picked up correctly by extract.py
+    #def get_flags(self):
+    #    return dbus_watch_get_flags(self.watch)
+
+    def handle(self, flags):
+        return dbus_watch_handle(self.watch, flags)
+
+    def get_enabled(self):
+        return dbus_watch_get_enabled(self.watch)
+    
+cdef class MessageIter:
+    cdef DBusMessageIter *iter
+    cdef DBusMessageIter real_iter
+    cdef dbus_uint32_t level
+
+    def __init__(self, level=0):
+        self.iter = &self.real_iter
+        self.level = level
+        if(self.level > 32):
+            raise TypeError, 'Type recurion is too deep' 
+
+    cdef __cinit__(self, DBusMessageIter *iter):
+        self.real_iter = iter[0]
+
+    cdef DBusMessageIter *_get_iter(self):
+        return self.iter
+
+    def has_next(self):
+        return dbus_message_iter_has_next(self.iter)
+    
+    def next(self):
+        return dbus_message_iter_next(self.iter)
+
+    def get(self, arg_type=None):
+        if(arg_type == None):
+            arg_type = self.get_arg_type()
+
+        if arg_type == TYPE_INVALID:
+            raise TypeError, 'Invalid arg type in MessageIter'
+        elif arg_type == TYPE_STRING:
+            retval = self.get_string()
+        elif arg_type == TYPE_INT16:
+            retval = self.get_int16()
+        elif arg_type == TYPE_UINT16:
+            retval = self.get_uint16()
+        elif arg_type == TYPE_INT32:
+            retval = self.get_int32()
+        elif arg_type == TYPE_UINT32:
+            retval = self.get_uint32()
+        elif arg_type == TYPE_INT64:
+            retval = self.get_int64()
+        elif arg_type == TYPE_UINT64:
+            retval = self.get_uint64()
+        elif arg_type == TYPE_DOUBLE:
+            retval = self.get_double()
+        elif arg_type == TYPE_BYTE:
+            retval = self.get_byte()
+        elif arg_type == TYPE_BOOLEAN:
+            retval = self.get_boolean()
+        elif arg_type == TYPE_SIGNATURE:
+            retval = self.get_signature()
+        elif arg_type == TYPE_ARRAY:
+            array_type = self.get_element_type()
+            if array_type == TYPE_DICT_ENTRY:
+                retval = self.get_dict()
+            else:
+                retval = self.get_array(array_type)
+        elif arg_type == TYPE_OBJECT_PATH:
+            retval = self.get_object_path()
+        elif arg_type == TYPE_STRUCT:
+            retval = self.get_struct()
+        elif arg_type == TYPE_VARIANT:
+            retval = self.get_variant()
+        elif arg_type == TYPE_DICT_ENTRY:
+            raise TypeError, 'Dictionary Entries can only appear as part of an array container'
+        else:
+            raise TypeError, 'Unknown arg type %d in MessageIter' % (arg_type)
+
+        return retval
+
+    def get_arg_type(self):
+        return dbus_message_iter_get_arg_type(self.iter)
+
+    def get_element_type(self):
+        return dbus_message_iter_get_element_type(self.iter)
+
+    def get_byte(self):
+        cdef char c_val
+        dbus_message_iter_get_basic(self.iter, <char *>&c_val)
+        return c_val
+        
+    def get_boolean(self):
+        cdef dbus_bool_t c_val
+        dbus_message_iter_get_basic(self.iter, <dbus_bool_t *>&c_val)
+        return c_val
+
+    def get_signature(self):
+        signature_string = self.get_string()
+        return Signature(signature_string)
+
+    def get_int16(self):
+        cdef dbus_int16_t c_val
+        dbus_message_iter_get_basic(self.iter, <dbus_int16_t *>&c_val)
+        return c_val
+
+    def get_uint16(self):
+        cdef dbus_uint16_t c_val
+        dbus_message_iter_get_basic(self.iter, <dbus_uint16_t *>&c_val)
+        return c_val
+
+    def get_int32(self):
+        cdef dbus_int32_t c_val
+        dbus_message_iter_get_basic(self.iter, <dbus_int32_t *>&c_val)
+        return c_val
+        
+    def get_uint32(self):
+        cdef dbus_uint32_t c_val
+        dbus_message_iter_get_basic(self.iter, <dbus_uint32_t *>&c_val)
+        return c_val
+        
+    def get_int64(self):
+        cdef dbus_int64_t c_val
+        dbus_message_iter_get_basic(self.iter, <dbus_int64_t *>&c_val)
+        return c_val
+
+    def get_uint64(self):
+        cdef dbus_uint64_t c_val
+        dbus_message_iter_get_basic(self.iter, <dbus_uint64_t *>&c_val)
+        return c_val
+
+    def get_double(self):
+        cdef double c_val
+        dbus_message_iter_get_basic(self.iter, <double *>&c_val)
+        return c_val
+
+    def get_string(self):
+        cdef char *c_str
+        dbus_message_iter_get_basic(self.iter, <char **>&c_str)
+        return c_str
+
+    def get_object_path(self):
+        object_path_string = self.get_string()
+        return ObjectPath(object_path_string)
+
+    def get_dict(self):
+        cdef DBusMessageIter c_dict_iter
+        cdef MessageIter dict_iter
+        level = self.level + 1
+
+        dbus_message_iter_recurse(self.iter, <DBusMessageIter *>&c_dict_iter)
+        dict_iter = MessageIter(level)
+        dict_iter.__cinit__(&c_dict_iter)
+        
+        python_dict = {}
+        cur_arg_type = dict_iter.get_arg_type()
+        while cur_arg_type == TYPE_DICT_ENTRY:
+            if cur_arg_type != TYPE_DICT_ENTRY:
+                raise TypeError, "Dictionary elements must be of type TYPE_DICT_ENTRY '%s != %s'" % (TYPE_DICT_ENTRY, cur_arg_type)
+                
+            dict_entry = dict_iter.get_struct()
+            if len(dict_entry) != 2:
+                raise TypeError, "Dictionary entries must be structs of two elements.  This entry had %i elements.'" % (len(dict_entry))
+
+            python_dict[dict_entry[0]] = dict_entry[1]
+            
+            dict_iter.next()
+            cur_arg_type = dict_iter.get_arg_type()
+
+        return python_dict
+   
+    def get_array(self, type):
+        cdef DBusMessageIter c_array_iter
+        cdef MessageIter array_iter
+        level = self.level + 1
+
+        dbus_message_iter_recurse(self.iter, <DBusMessageIter *>&c_array_iter)
+        array_iter = MessageIter(level)
+        array_iter.__cinit__(&c_array_iter)
+        
+        python_list = []
+        cur_arg_type = array_iter.get_arg_type()
+        while cur_arg_type != TYPE_INVALID:
+            if cur_arg_type != type:
+                raise TypeError, "Array elements must be of the same type '%s != %s'" % (type, cur_arg_type)
+                
+            value = array_iter.get(type)
+            python_list.append(value)
+            
+            array_iter.next()
+            cur_arg_type = array_iter.get_arg_type()
+
+        return python_list
+
+    def get_variant(self):
+        cdef DBusMessageIter c_var_iter
+        cdef MessageIter var_iter
+        level = self.level + 1
+
+        dbus_message_iter_recurse(self.iter, <DBusMessageIter *>&c_var_iter)
+        var_iter = MessageIter(level)
+        var_iter.__cinit__(&c_var_iter)
+        
+        return var_iter.get() 
+
+    def get_struct(self):
+        cdef DBusMessageIter c_struct_iter
+        cdef MessageIter struct_iter
+        level = self.level + 1
+
+        dbus_message_iter_recurse(self.iter, <DBusMessageIter *>&c_struct_iter)
+        struct_iter = MessageIter(level)
+        struct_iter.__cinit__(&c_struct_iter)
+
+        python_list = []
+        while struct_iter.get_arg_type() != TYPE_INVALID:
+            value = struct_iter.get()
+            python_list.append(value)
+            
+            struct_iter.next()
+
+        return tuple(python_list)
+
+    def python_value_to_dbus_sig(self, value, level = 0):
+
+        if(level > 32):
+            raise TypeError, 'Type recurion is too deep' 
+
+        level = level + 1
+
+        ptype = type(value)
+        ret = ""
+        if ptype == bool:
+            ret = TYPE_BOOL
+            ret = str(chr(ret))
+        elif ptype == int:
+            ret = TYPE_INT32
+            ret = str(chr(ret))
+        elif ptype == long:
+            ret = TYPE_INT64
+            ret = str(chr(ret))
+        elif ptype == str:
+            ret = TYPE_STRING
+            ret = str(chr(ret))
+        elif ptype == float:
+            ret = TYPE_DOUBLE
+            ret = str(chr(ret))
+        elif ptype == dict:
+            dict_list = value.items()
+            key, value = dict_list[0]
+
+            ret = str(chr(TYPE_ARRAY)) + str(chr(DICT_ENTRY_BEGIN))
+            ret = ret + self.python_value_to_dbus_sig(key, level)
+            ret = ret + self.python_value_to_dbus_sig(value, level)
+            ret = ret + str(chr(DICT_ENTRY_END))
+
+        elif ptype == tuple:
+            ret = str(chr(STRUCT_BEGIN))
+            for item in value:
+                ret = ret + self.python_value_to_dbus_sig(item, level)
+            ret = ret + str(chr(STRUCT_END))
+        elif ptype == list:
+            ret = str(chr(TYPE_ARRAY))
+            ret = ret + self.python_value_to_dbus_sig(value[0], level)
+        elif isinstance(value, ObjectPath):
+            ret = TYPE_OBJECT_PATH
+            ret = str(chr(ret))
+        elif isinstance(ByteArray):
+            ret = str(chr(TYPE_ARRAY)) + str(chr(TYPE_BYTE))
+        elif isinstance(Signature):
+            ret = TYPE_SIGNATURE
+            ret = str(chr(ret))
+        elif isinstance(value, Byte):
+            ret = TYPE_BYTE
+            ret = str(chr(ret))
+        elif isinstance(value, Boolean):
+            ret = TYPE_BOOL
+            ret = str(chr(ret))
+        elif isinstance(value, Int16):
+            ret = TYPE_INT16
+            ret = str(chr(ret))
+        elif isinstance(value, UInt16):
+            ret = TYPE_UINT16
+            ret = str(chr(ret))
+        elif isinstance(value, Int32):
+            ret = TYPE_INT32
+            ret = str(chr(ret))
+        elif isinstance(value, UInt32):
+            ret = TYPE_UINT32
+            ret = str(chr(ret))
+        elif isinstance(value, Int64):
+            ret = TYPE_INT64
+            ret = str(chr(ret))
+        elif isinstance(value, UInt64):
+            ret = TYPE_UINT64
+            ret = str(chr(ret))
+        elif isinstance(value, Double):
+            ret = TYPE_DOUBLE
+            ret = str(chr(ret))
+        elif isinstance(value, String):
+            ret = TYPE_STRING
+            ret = str(chr(ret))
+        elif isinstance(value, Array):
+            ret = str(chr(TYPE_ARRAY))
+            ret = ret + self.python_value_to_dbus_sig(value[0], level)
+        elif isinstance(value, Struct):
+            ret = str(chr(STRUCT_BEGIN))
+            for item in value:
+                ret = ret + self.python_value_to_dbus_sig(item, level)
+            ret = ret + str(chr(STRUCT_END))
+        elif isinstance(value, Dictionary):
+            dict_list = value.items()
+            key, value = dict_list[0]
+
+            ret = str(chr(TYPE_ARRAY)) + str(chr(DICT_ENTRY_BEGIN))
+            ret = ret + self.python_value_to_dbus_sig(key, level)
+            ret = ret + self.python_value_to_dbus_sig(value, level)
+            ret = ret + str(chr(DICT_ENTRY_END))
+        else:
+            raise TypeError, "Argument of unknown type '%s'" % (ptype)
+
+        return ret
+
+    
+    #FIXME: handle all the different types?
+    def append(self, value):
+        value_type = type(value)
+        if value_type == bool:
+            retval = self.append_boolean(value)
+        elif value_type == int:
+            retval = self.append_int32(value)
+        elif value_type == long:
+            retval = self.append_int64(value)
+        elif value_type == str:
+            retval = self.append_string(value)
+        elif value_type == float:
+            retval = self.append_double(value)
+        elif value_type == dict:
+            retval = self.append_dict(value)
+        elif value_type == tuple:
+            retval = self.append_struct(value)
+        elif value_type == list:
+             retval = self.append_array(value)
+        #elif value_type == None.__class__:
+        #    retval = self.append_nil()
+        elif isinstance(value, ObjectPath):
+            retval = self.append_object_path(value)
+        elif isinstance(value, ByteArray):
+            retval = self.append_array(value)
+        elif isinstance(value, Signature):
+            retval = self.append_signature(value)
+        elif isinstance(value, Byte):
+            retval = self.append_byte(value)
+        elif isinstance(value, Boolean):
+            retval = self.append_boolean(value)
+        elif isinstance(value, Int16):
+            retval = self.append_int16(value)
+        elif isinstance(value, UInt16):
+            retval = self.append_uint16(value)
+        elif isinstance(value, Int32):
+            retval = self.append_int32(value)
+        elif isinstance(value, UInt32):
+            retval = self.append_uint32(value)
+        elif isinstance(value, Int64):
+            retval = self.append_int64(value)
+        elif isinstance(value, UInt64):
+            retval = self.append_uint64(value)
+        elif isinstance(value, Double):
+            retval = self.append_double(value)
+        elif isinstance(value, String):
+            retval = self.append_string(value)
+        elif isinstance(value, Array):
+            retval = self.append_array(value)
+        elif isinstance(value, Struct):
+            retval = self.append_struct(value)
+        elif isinstance(value, Dictionary):
+            retval = self.append_dict(value)
+        else:
+            raise TypeError, "Argument of unknown type '%s'" % (value_type)
+
+        return retval
+
+    def append_boolean(self, value):
+        cdef dbus_bool_t c_value
+        c_value = value
+        return dbus_message_iter_append_basic(self.iter, TYPE_BOOLEAN, <dbus_bool_t *>&c_value)
+
+    def append_byte(self, value):
+        cdef char b
+        if type(value) != str or len(value) != 1:
+            raise TypeError
+
+        b = ord(value)
+        return dbus_message_iter_append_basic(self.iter, TYPE_BYTE, <char *>&b)
+
+    def append_int16(self, value):
+        cdef dbus_int32_t c_value
+        c_value = value
+        return dbus_message_iter_append_basic(self.iter, TYPE_INT16, <dbus_int32_t *>&c_value)
+
+    def append_uint16(self, value):
+        cdef dbus_uint32_t c_value
+        c_value = value
+        return dbus_message_iter_append_basic(self.iter, TYPE_UINT16, <dbus_uint32_t *>&c_value)
+
+    def append_int32(self, value):
+        cdef dbus_int32_t c_value
+        c_value = value
+        return dbus_message_iter_append_basic(self.iter, TYPE_INT32, <dbus_int32_t *>&c_value)
+
+    def append_uint32(self, value):
+        cdef dbus_uint32_t c_value
+        c_value = value
+        return dbus_message_iter_append_basic(self.iter, TYPE_UINT32, <dbus_uint32_t *>&c_value)
+
+    def append_int64(self, value):
+        cdef dbus_int64_t c_value
+        c_value = value
+        return dbus_message_iter_append_basic(self.iter, TYPE_INT64, <dbus_int64_t *>&c_value)
+
+    def append_uint64(self, value):
+        cdef dbus_uint64_t c_value
+        c_value = value
+        return dbus_message_iter_append_basic(self.iter, TYPE_UINT64, <dbus_uint64_t *>&c_value)
+
+    def append_double(self, value):
+        cdef double c_value
+        c_value = value
+        return dbus_message_iter_append_basic(self.iter, TYPE_DOUBLE, <double *>&c_value)
+
+    def append_string(self, value):
+        cdef char *c_value
+        c_value = value
+        return dbus_message_iter_append_basic(self.iter, TYPE_STRING, <char **>&c_value)    
+
+    def append_object_path(self, value):
+        cdef char *c_value
+        c_value = value
+        return dbus_message_iter_append_basic(self.iter, TYPE_OBJECT_PATH, <char **>&c_value)
+
+    def append_signature(self, value):
+        cdef char *c_value
+        c_value = value
+        return dbus_message_iter_append_basic(self.iter, TYPE_SIGNATURE, <char **>&c_value)
+
+
+    def append_dict(self, python_dict):
+        cdef DBusMessageIter c_dict_iter, c_dict_entry_iter
+        cdef MessageIter dict_iter, dict_entry_iter
+        
+        level = self.level + 1
+
+        dict_list = python_dict.items()
+        key, value = dict_list[0]
+
+        sig = str(chr(DICT_ENTRY_BEGIN))
+        sig = sig + self.python_value_to_dbus_sig(key)
+        sig = sig + self.python_value_to_dbus_sig(value)
+        sig = sig + str(chr(DICT_ENTRY_END))
+
+        dbus_message_iter_open_container(self.iter, TYPE_ARRAY, sig, <DBusMessageIter *>&c_dict_iter)
+        dict_iter = MessageIter(level)
+        dict_iter.__cinit__(&c_dict_iter)
+
+        for key, value in dict_list:
+            dbus_message_iter_open_container(dict_iter.iter, TYPE_DICT_ENTRY, sig, <DBusMessageIter *>&c_dict_entry_iter)
+            dict_entry_iter = MessageIter(level)
+            dict_entry_iter.__cinit__(&c_dict_entry_iter)
+
+            dict_entry_iter.append(key)
+            dict_entry_iter.append(value)
+
+            dbus_message_iter_close_container(dict_iter.iter, dict_entry_iter.iter)
+
+        dbus_message_iter_close_container(self.iter, dict_iter.iter)
+
+    def append_struct(self, python_struct):
+        cdef DBusMessageIter c_struct_iter
+        cdef MessageIter struct_iter
+
+        level = self.level + 1
+        dbus_message_iter_open_container(self.iter, TYPE_STRUCT, NULL, <DBusMessageIter *>&c_struct_iter)
+        struct_iter = MessageIter(level)
+        struct_iter.__cinit__(&c_struct_iter)
+        
+        for item in python_struct:
+            if not struct_iter.append(item):
+                dbus_message_iter_close_container(self.iter, struct_iter.iter)
+                return False
+
+        dbus_message_iter_close_container(self.iter, struct_iter.iter)
+
+    def append_array(self, python_list):
+        cdef DBusMessageIter c_array_iter
+        cdef MessageIter array_iter
+
+        level = self.level + 1
+        sig = self.python_value_to_dbus_sig(python_list[0])
+
+        dbus_message_iter_open_container(self.iter, TYPE_ARRAY, sig, <DBusMessageIter *>&c_array_iter)
+        array_iter = MessageIter(level)
+        array_iter.__cinit__(&c_array_iter)
+
+        length = len(python_list)
+        for item in python_list:
+            if not array_iter.append(item):
+                dbus_message_iter_close_container(self.iter, array_iter.iter)
+                return False
+
+        dbus_message_iter_close_container(self.iter, array_iter.iter)
+
+        return True
+
+    def __str__(self):
+        cdef DBusMessageIter c_array_iter
+        cdef MessageIter array_iter
+
+        value_at_iter = True
+        retval = ""
+        while (value_at_iter):
+            type = self.get_arg_type()
+            if type == TYPE_INVALID:
+                break
+            elif type == TYPE_STRING:
+                str = iter.get_string()
+                arg = 'string:%s\n' % (str)
+            elif type == TYPE_OBJECT_PATH:
+                path = iter.get_object_path()
+                arg = 'object_path:%s\n' % (path)
+            elif type == TYPE_INT32:
+                num = iter.get_int32()
+                arg = 'int32:%d\n' % (num)
+            elif type == TYPE_UINT32:
+                num = iter.get_uint32()
+                arg = 'uint32:%u\n' % (num)
+            elif type == TYPE_INT64:
+                num = iter.get_int64()
+                arg = 'int64:%d\n' % (num)
+            elif type == TYPE_UINT64:
+                num = iter.get_uint64()
+                arg = 'uint64:%u\n' % (num)
+            elif type == TYPE_DOUBLE:
+                num = iter.get_double()
+                arg = 'double:%f\n' % (num)
+            elif type == TYPE_BYTE:
+                num = iter.get_byte()
+                arg = 'byte:%x(%s)\n' % (num, str(chr(num)))
+            elif type == TYPE_BOOLEAN:
+                bool = iter.get_boolean()
+                if (bool):
+                    str = "true"
+                else:
+                    str = "false"
+                arg = 'boolean:%s\n' % (str)
+            elif type == TYPE_ARRAY:
+                dbus_message_iter_recurse(self.iter, <DBusMessageIter *>&c_array_iter)
+                array_iter = MessageIter(self.level + 1)
+                array_iter.__cinit__(&c_array_iter)
+                if array_iter.has_next():
+                    arg = 'array [' + str(array_iter) + ']'
+                else:
+                    arg = 'array []'
+            else:
+                arg = '(unknown arg type %d)\n' % type
+
+            retval = retval + arg
+            value_at_iter = self.next()
+
+        return retval
+
+
+(MESSAGE_TYPE_INVALID, MESSAGE_TYPE_METHOD_CALL, MESSAGE_TYPE_METHOD_RETURN, MESSAGE_TYPE_ERROR, MESSAGE_TYPE_SIGNAL) = range(5)
+(TYPE_INVALID, TYPE_BYTE, TYPE_BOOLEAN, TYPE_INT16, TYPE_UINT16, TYPE_INT32, TYPE_UINT32, TYPE_INT64, TYPE_UINT64, TYPE_DOUBLE, TYPE_STRING, TYPE_OBJECT_PATH, TYPE_SIGNATURE, TYPE_ARRAY, TYPE_STRUCT, STRUCT_BEGIN, STRUCT_END, TYPE_VARIANT, TYPE_DICT_ENTRY, DICT_ENTRY_BEGIN, DICT_ENTRY_END) = (0, ord('y'), ord('b'), ord('n'), ord('q'), ord('i'), ord('u'), ord('x'), ord('t'), ord('d'), ord('s'), ord('o'), ord('g'), ord('a'), ord('r'), ord('('), ord(')'), ord('v'), ord('e'), ord('{'), ord('}'))
+(HANDLER_RESULT_HANDLED, HANDLER_RESULT_NOT_YET_HANDLED, HANDLER_RESULT_NEED_MEMORY) = range(3)
+    
+cdef class Message:
+    cdef DBusMessage *msg
+
+    def __init__(self, message_type=MESSAGE_TYPE_INVALID,
+                 service=None, path=None, dbus_interface=None, method=None,
+                 Message method_call=None,
+                 name=None,
+                 Message reply_to=None, error_name=None, error_message=None,
+                 _create=1):
+
+        self.msg = NULL
+
+        cdef char *cservice
+        cdef char *ciface
+        cdef DBusMessage *cmsg
+
+        ciface = NULL
+        if (dbus_interface != None):
+            ciface = dbus_interface
+
+        cservice = NULL
+        if (service != None):
+            cservice = service
+            
+        if not _create:
+            return
+
+        if message_type == MESSAGE_TYPE_METHOD_CALL:
+            self.msg = dbus_message_new_method_call(cservice, path, ciface, method)
+        elif message_type == MESSAGE_TYPE_METHOD_RETURN:
+            cmsg = method_call._get_msg()
+            self.msg = dbus_message_new_method_return(cmsg)
+        elif message_type == MESSAGE_TYPE_SIGNAL:
+            self.msg = dbus_message_new_signal(path, ciface, name)
+        elif message_type == MESSAGE_TYPE_ERROR:
+            cmsg = reply_to._get_msg()
+            self.msg = dbus_message_new_error(cmsg, error_name, error_message)
+
+    def __del__(self):
+        if self.msg != NULL:
+            dbus_message_unref(self.msg)
+            
+    def type_to_name(self, type):
+        if type == MESSAGE_TYPE_SIGNAL:
+            return "signal"
+        elif type == MESSAGE_TYPE_METHOD_CALL:
+            return "method call"
+        elif type == MESSAGE_TYPE_METHOD_RETURN:
+            return "method return"
+        elif type == MESSAGE_TYPE_ERROR:
+            return "error"
+        else:
+            return "(unknown message type)"
+
+    def __str__(self):
+        message_type = self.get_type()
+        sender = self.get_sender()
+
+        if sender == None:
+            sender = "(no sender)"
+
+        if (message_type == MESSAGE_TYPE_METHOD_CALL) or (message_type == MESSAGE_TYPE_SIGNAL):
+            retval = '%s interface=%s; member=%s; sender=%s' % (self.type_to_name(message_type),
+                                                                self.get_interface(),
+                                                                self.get_member(),
+                                                                sender)
+        elif message_type == MESSAGE_TYPE_METHOD_RETURN:
+            retval = '%s sender=%s' % (self.type_to_name(message_type),
+                                        sender)
+        elif message_type == MESSAGE_TYPE_ERROR:
+            retval = '%s name=%s; sender=%s' % (self.type_to_name(message_type),
+                                                self.get_error_name(),
+                                                sender)
+        else:
+            retval = "Message of unknown type %d" % (message_type)
+
+
+        # FIXME: should really use self.convert_to_tuple() here
+        
+        iter = self.get_iter()
+
+        retval = retval + "\n" + str(iter) 
+
+        return retval
+    
+    cdef _set_msg(self, DBusMessage *msg):
+        self.msg = msg
+
+    cdef DBusMessage *_get_msg(self):
+        return self.msg
+
+    def get_iter(self, append=False):
+        cdef DBusMessageIter iter
+        cdef MessageIter message_iter
+        cdef DBusMessage *msg
+
+        msg = self._get_msg()
+
+        if append:
+            dbus_message_iter_init_append(msg, &iter)
+        else:
+            dbus_message_iter_init(msg, &iter)
+
+        message_iter = MessageIter(0)
+        message_iter.__cinit__(&iter)
+
+        return message_iter
+
+    def get_args_list(self):
+        retval = [ ]
+
+        iter = self.get_iter()
+        try:
+            retval.append(iter.get())
+        except TypeError, e:
+            return [ ]
+            
+        value_at_iter = iter.next()
+        while (value_at_iter):
+            retval.append(iter.get())
+            value_at_iter = iter.next()        
+
+        return retval
+            
+    # FIXME: implement dbus_message_copy?
+
+    def get_type(self):
+        return dbus_message_get_type(self.msg)
+
+    def set_path(self, object_path):
+        return dbus_message_set_path(self.msg, object_path)
+    
+    def get_path(self):
+        return dbus_message_get_path(self.msg)
+    
+    def set_interface(self, interface):
+        return dbus_message_set_interface(self.msg, interface)
+
+    def get_interface(self):
+        return dbus_message_get_interface(self.msg)    
+
+    def set_member(self, member):
+        return dbus_message_set_member(self.msg, member)
+
+    def get_member(self):
+        return dbus_message_get_member(self.msg)
+
+    def set_error_name(self, name):
+        return dbus_message_set_error_name(self.msg, name)
+
+    def get_error_name(self):
+        return dbus_message_get_error_name(self.msg)
+
+    def set_destination(self, destination):
+        return dbus_message_set_destination(self.msg, destination)
+
+    def get_destination(self):
+        return dbus_message_get_destination(self.msg)
+
+    def set_sender(self, sender):
+        return dbus_message_set_sender(self.msg, sender)
+    
+    def get_sender(self):
+        cdef char *sender
+        sender = dbus_message_get_sender(self.msg)
+        if (sender == NULL):
+            return None
+        else:
+            return sender
+
+    def set_no_reply(self, no_reply):
+        dbus_message_set_no_reply(self.msg, no_reply)
+
+    def get_no_reply(self):
+        return dbus_message_get_no_reply(self.msg)
+
+    def is_method_call(self, interface, method):
+        return dbus_message_is_method_call(self.msg, interface, method)
+
+    def is_signal(self, interface, signal_name):
+        return dbus_message_is_signal(self.msg, interface, signal_name)
+
+    def is_error(self, error_name):
+        return dbus_message_is_error(self.msg, error_name)
+
+    def has_destination(self, service):
+        return dbus_message_has_destination(self.msg, service)
+
+    def has_sender(self, service):
+        return dbus_message_has_sender(self.msg, service)
+
+    def get_serial(self):
+        return dbus_message_get_serial(self.msg)
+
+    def set_reply_serial(self, reply_serial):
+        return dbus_message_set_reply_serial(self.msg, reply_serial)
+
+    def get_reply_serial(self):
+        return dbus_message_get_reply_serial(self.msg)    
+
+    #FIXME: dbus_message_get_path_decomposed
+    
+    # FIXME: all the different dbus_message_*args* methods
+
+class Signal(Message):
+    def __init__(self, spath, sinterface, sname):
+        Message.__init__(self, MESSAGE_TYPE_SIGNAL, path=spath, dbus_interface=sinterface, name=sname)
+
+class MethodCall(Message):
+    def __init__(self, mpath, minterface, mmethod):
+        Message.__init__(self, MESSAGE_TYPE_METHOD_CALL, path=mpath, dbus_interface=minterface, method=mmethod)
+
+class MethodReturn(Message):
+    def __init__(self, method_call):
+        Message.__init__(self, MESSAGE_TYPE_METHOD_RETURN, method_call=method_call)
+
+class Error(Message):
+    def __init__(self, reply_to, error_name, error_message):
+        Message.__init__(self, MESSAGE_TYPE_ERROR, reply_to=reply_to, error_name=error_name, error_message=error_message)
+        
+cdef class Server:
+    cdef DBusServer *server
+    def __init__(self, address):
+        cdef DBusError error
+        dbus_error_init(&error)
+        self.server = dbus_server_listen(address,
+                                         &error)
+        if dbus_error_is_set(&error):
+            raise DBusException, error.message
+
+    def disconnect(self):
+        dbus_server_disconnect(self.server)
+
+    def get_is_connected(self):
+        return dbus_server_get_is_connected(self.server)
+
+#    def set_new_connection_function(self, function, data):
+#        dbus_server_set_new_connection_function(self.conn, function,
+#                                                data, NULL)
+        
+#    def set_watch_functions(self, add_function, remove_function, data):
+#        dbus_server_set_watch_functions(self.server,
+#                                        add_function, remove_function,
+#                                        data, NULL)
+        
+#    def set_timeout_functions(self, add_function, remove_function, data):
+#        dbus_server_set_timeout_functions(self.server,
+#                                          add_function, remove_function,
+#                                          data, NULL)
+        
+#    def handle_watch(self, watch, condition):
+#        dbus_server_handle_watch(self.conn, watch, condition)
+
+BUS_SESSION = DBUS_BUS_SESSION
+BUS_SYSTEM = DBUS_BUS_SYSTEM
+BUS_STARTER = DBUS_BUS_STARTER
+
+def bus_get (bus_type):
+    cdef DBusError error
+    cdef Connection conn
+    dbus_error_init(&error)
+    cdef DBusConnection *connection
+
+    connection = dbus_bus_get(bus_type,
+                              &error)
+
+    if dbus_error_is_set(&error):
+        raise DBusException, error.message
+
+    conn = Connection()
+    conn.__cinit__(None, connection)
+    return conn 
+
+def bus_get_unique_name(Connection connection):
+    cdef DBusConnection *conn
+    conn = connection._get_conn()
+    return dbus_bus_get_unique_name(conn)
+
+def bus_get_unix_user(Connection connection, service_name):
+    cdef DBusError error
+    dbus_error_init(&error)
+    cdef int retval
+    cdef DBusConnection *conn
+
+    conn = connection._get_conn()
+    retval = dbus_bus_get_unix_user(conn, service_name, &error)
+
+    if dbus_error_is_set(&error):
+        raise DBusException, error.message
+    return retval
+
+#These are defines, not enums so they aren't auto generated
+DBUS_START_REPLY_SUCCESS = 0 
+DBUS_START_REPLY_ALREADY_RUNNING = 1 
+    
+def bus_start_service_by_name(Connection connection, service_name, flags=0):
+    cdef DBusError error
+    dbus_error_init(&error)
+    cdef dbus_bool_t retval
+    cdef dbus_uint32_t results
+    cdef DBusConnection *conn
+
+    conn = connection._get_conn()
+
+    retval = dbus_bus_start_service_by_name(conn, service_name, flags, &results, &error)
+
+    return (retval, results) 
+
+def bus_register(Connection connection):
+    cdef DBusError error
+    dbus_error_init(&error)
+    cdef dbus_bool_t retval
+    cdef DBusConnection *conn
+
+    conn = connection._get_conn()
+    retval = dbus_bus_register(conn,
+                               &error)
+    if dbus_error_is_set(&error):
+        raise DBusException, error.message
+
+    return retval
+
+SERVICE_FLAG_PROHIBIT_REPLACEMENT = 0x1
+SERVICE_FLAG_REPLACE_EXISTING     = 0x2
+
+def bus_request_name(Connection connection, service_name, flags=0):
+    cdef DBusError error
+    dbus_error_init(&error)
+    cdef int retval
+    cdef DBusConnection *conn
+
+    conn = connection._get_conn()
+    retval = dbus_bus_request_name(conn,
+                                   service_name,
+                                   flags,
+                                   &error)
+    if dbus_error_is_set(&error):
+        raise DBusException, error.message
+    return retval
+    
+def bus_name_has_owner(Connection connection, service_name):
+    cdef DBusError error
+    dbus_error_init(&error)
+    cdef dbus_bool_t retval
+    cdef DBusConnection *conn
+
+    conn = connection._get_conn()
+    retval = dbus_bus_name_has_owner(conn,
+                                     service_name,
+                                     &error)
+    if dbus_error_is_set(&error):
+        raise DBusException, error.message
+    return retval
+
+def bus_add_match(Connection connection, rule):
+    cdef DBusError error
+    cdef DBusConnection *conn
+
+    dbus_error_init(&error)
+    
+    conn = connection._get_conn()
+    dbus_bus_add_match (conn, rule, &error)
+    
+    if dbus_error_is_set(&error):
+        raise DBusException, error.message
+
+def bus_remove_match(Connection connection, rule):
+    cdef DBusError error
+    cdef DBusConnection *conn
+
+    dbus_error_init(&error)
+
+    conn = connection._get_conn()
+    dbus_bus_remove_match (conn, rule, &error)
+    
+    if dbus_error_is_set(&error):
+        raise DBusException, error.message
+