diff --git a/include/libvirt/libvirt.h b/include/libvirt/libvirt.h
index d519452..9b6e1da 100644
--- a/include/libvirt/libvirt.h
+++ b/include/libvirt/libvirt.h
@@ -987,6 +987,50 @@ char *                  virStorageVolGetXMLDesc         (virStorageVolPtr pool,
 
 char *                  virStorageVolGetPath            (virStorageVolPtr vol);
 
+/*
+ * Domain Event Notification
+ */
+
+typedef enum {
+      VIR_DOMAIN_EVENT_ADDED,
+      VIR_DOMAIN_EVENT_REMOVED,
+      VIR_DOMAIN_EVENT_STARTED,
+      VIR_DOMAIN_EVENT_SUSPENDED,
+      VIR_DOMAIN_EVENT_RESUMED,
+      VIR_DOMAIN_EVENT_STOPPED,
+      VIR_DOMAIN_EVENT_SAVED,
+      VIR_DOMAIN_EVENT_RESTORED,
+} virDomainEventType;
+
+typedef int (*virConnectDomainEventCallback)(virConnectPtr conn,
+                                             virDomainPtr dom,
+                                             int event,
+                                             void *opaque);
+
+int virConnectDomainEventRegister(virConnectPtr conn,
+                                  virConnectDomainEventCallback cb,
+                                  void *opaque);
+
+int virConnectDomainEventDeregister(virConnectPtr conn,
+                                    virConnectDomainEventCallback cb);
+
+/**
+ * virEventHandleCallback: callback for receiving file handle events
+ *
+ * @fd: file handle on which the event occurred
+ * @events: bitset of events from POLLnnn constants
+ * @opaque: user data registered with handle
+ */
+typedef void (*virEventHandleCallback)(int fd, int events, void *opaque);
+
+typedef int (*virEventAddHandleFunc)(int, int, virEventHandleCallback, void *);
+typedef void (*virEventUpdateHandleFunc)(int, int);
+typedef int (*virEventRemoveHandleFunc)(int);
+
+void virEventRegisterHandleImpl(virEventAddHandleFunc addHandle,
+                                virEventUpdateHandleFunc updateHandle,
+                                virEventRemoveHandleFunc removeHandle);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in
index 24b5680..71f4797 100644
--- a/include/libvirt/libvirt.h.in
+++ b/include/libvirt/libvirt.h.in
@@ -987,6 +987,50 @@ char *                  virStorageVolGetXMLDesc         (virStorageVolPtr pool,
 
 char *                  virStorageVolGetPath            (virStorageVolPtr vol);
 
+/*
+ * Domain Event Notification
+ */
+
+typedef enum {
+      VIR_DOMAIN_EVENT_ADDED,
+      VIR_DOMAIN_EVENT_REMOVED,
+      VIR_DOMAIN_EVENT_STARTED,
+      VIR_DOMAIN_EVENT_SUSPENDED,
+      VIR_DOMAIN_EVENT_RESUMED,
+      VIR_DOMAIN_EVENT_STOPPED,
+      VIR_DOMAIN_EVENT_SAVED,
+      VIR_DOMAIN_EVENT_RESTORED,
+} virDomainEventType;
+
+typedef int (*virConnectDomainEventCallback)(virConnectPtr conn,
+                                             virDomainPtr dom,
+                                             int event,
+                                             void *opaque);
+
+int virConnectDomainEventRegister(virConnectPtr conn,
+                                  virConnectDomainEventCallback cb,
+                                  void *opaque);
+
+int virConnectDomainEventDeregister(virConnectPtr conn,
+                                    virConnectDomainEventCallback cb);
+
+/**
+ * virEventHandleCallback: callback for receiving file handle events
+ *
+ * @fd: file handle on which the event occurred
+ * @events: bitset of events from POLLnnn constants
+ * @opaque: user data registered with handle
+ */
+typedef void (*virEventHandleCallback)(int fd, int events, void *opaque);
+
+typedef int (*virEventAddHandleFunc)(int, int, virEventHandleCallback, void *);
+typedef void (*virEventUpdateHandleFunc)(int, int);
+typedef int (*virEventRemoveHandleFunc)(int);
+
+void virEventRegisterHandleImpl(virEventAddHandleFunc addHandle,
+                                virEventUpdateHandleFunc updateHandle,
+                                virEventRemoveHandleFunc removeHandle);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/python/generator.py b/python/generator.py
index c706b19..6816cc3 100755
--- a/python/generator.py
+++ b/python/generator.py
@@ -332,6 +332,9 @@ skip_function = (
     'virCopyLastError', # Python API is called virGetLastError instead
     'virConnectOpenAuth', # Python C code is manually written
     'virDefaultErrorFunc', # Python virErrorFuncHandler impl calls this from C
+    'virConnectDomainEventRegister', # TODO: generate python bindings for these below XXX
+    'virConnectDomainEventDeregister',
+    'virEventRegisterHandleImpl',
 )
 
 
diff --git a/qemud/qemud.c b/qemud/qemud.c
index 9da27d2..2d7e959 100644
--- a/qemud/qemud.c
+++ b/qemud/qemud.c
@@ -1503,7 +1503,7 @@ static int qemudClientWrite(struct qemud_server *server,
 }
 
 
-static void qemudDispatchClientWrite(struct qemud_server *server, struct qemud_client *client) {
+void qemudDispatchClientWrite(struct qemud_server *server, struct qemud_client *client) {
     switch (client->mode) {
     case QEMUD_MODE_TX_PACKET: {
         if (qemudClientWrite(server, client) < 0)
diff --git a/qemud/qemud.h b/qemud/qemud.h
index 91cb939..63784cd 100644
--- a/qemud/qemud.h
+++ b/qemud/qemud.h
@@ -132,6 +132,10 @@ struct qemud_client {
      */
     virConnectPtr conn;
 
+    /* This client supports events, and has registered for at least
+       one event type. This is a bitmask of requested event types */
+    int events_registered;
+
     struct qemud_client *next;
 };
 
@@ -179,6 +183,9 @@ void qemudLog(int priority, const char *fmt, ...)
 void remoteDispatchClientRequest (struct qemud_server *server,
                                   struct qemud_client *client);
 
+void qemudDispatchClientWrite(struct qemud_server *server,
+                             struct qemud_client *client);
+
 #if HAVE_POLKIT
 int qemudGetSocketIdentity(int fd, uid_t *uid, pid_t *pid);
 #endif
diff --git a/qemud/remote.c b/qemud/remote.c
index 8acd95d..55ccc2c 100644
--- a/qemud/remote.c
+++ b/qemud/remote.c
@@ -75,6 +75,18 @@ typedef int (*dispatch_fn) (struct qemud_server *server,
                             char *args,
                             char *ret);
 
+/* Prototypes */
+static void
+remoteDispatchDomainEventSend (struct qemud_client *client,
+                               virDomainPtr dom,
+                               virDomainEventType event);
+
+static int
+remoteRelayDomainEvent (virConnectPtr conn,
+                        virDomainPtr dom,
+                        int event,
+                        void *opaque);
+
 /* This function gets called from qemud when it detects an incoming
  * remote protocol message.  At this point, client->buffer contains
  * the full call message (including length word which we skip).
@@ -405,12 +417,33 @@ remoteDispatchError (struct qemud_client *client,
     remoteDispatchSendError (client, req, VIR_ERR_RPC, msg);
 }
 
+static int remoteRelayDomainEvent (virConnectPtr conn ATTRIBUTE_UNUSED,
+                                   virDomainPtr dom,
+                                   int event,
+                                   void *opaque)
+{
+    struct qemud_server *server = opaque;
+    REMOTE_DEBUG("Relaying domain event %d", event);
+
+    struct qemud_client *c = server->clients;
+    while(c) {
+        if ( c->conn == conn &&
+             (c->events_registered & virDomainEvent) ) {
+            remoteDispatchDomainEventSend (c, dom, event);
+            qemudDispatchClientWrite(server,c);
+        } else {
+            REMOTE_DEBUG("Event class %d not registered for client", virDomainEvent);
+        }
+        c = c->next;
+    }
+    return 0;
+}
 
 
 /*----- Functions. -----*/
 
 static int
-remoteDispatchOpen (struct qemud_server *server ATTRIBUTE_UNUSED,
+remoteDispatchOpen (struct qemud_server *server,
                     struct qemud_client *client, remote_message_header *req,
                     struct remote_open_args *args, void *ret ATTRIBUTE_UNUSED)
 {
@@ -436,6 +469,11 @@ remoteDispatchOpen (struct qemud_server *server ATTRIBUTE_UNUSED,
         ? virConnectOpenReadOnly (name)
         : virConnectOpen (name);
 
+    /* Register event delivery callback */
+    if(client->conn) {
+        REMOTE_DEBUG("%s","Registering to relay remote events");
+        virConnectDomainEventRegister(client->conn, remoteRelayDomainEvent, server);
+    }
     return client->conn ? 0 : -1;
 }
 
@@ -3620,6 +3658,111 @@ remoteDispatchStorageVolLookupByPath (struct qemud_server *server ATTRIBUTE_UNUS
 }
 
 
+/**************************
+ * Async Events
+ **************************/
+static int remoteDispatchEventsDomainEvent (struct qemud_server *server ATTRIBUTE_UNUSED,
+                                           struct qemud_client *client ATTRIBUTE_UNUSED,
+                                           remote_message_header *req ATTRIBUTE_UNUSED,
+                                           void *args ATTRIBUTE_UNUSED,
+                                           remote_events_domain_event_ret *ret ATTRIBUTE_UNUSED)
+{
+    /* This call gets dispatched from a client call.
+     * This does not make sense, as this should not be intiated
+     * from the client side in generated code.
+     */
+     return -1;
+}
+
+/***************************
+ * Enabe / disable event classes
+ ***************************/
+static int remoteDispatchEventsEnable (struct qemud_server *server ATTRIBUTE_UNUSED,
+                                       struct qemud_client *client,
+                                       remote_message_header *req ATTRIBUTE_UNUSED,
+                                       remote_events_enable_args *args,
+                                       remote_events_enable_ret *ret)
+{
+    CHECK_CONN(client);
+    if(args->enable) {
+        client->events_registered |= args->event_class;
+    } else {
+        client->events_registered &= ~args->event_class;
+    }
+    ret->success = 1;
+    return 0;
+}
+
+static void
+remoteDispatchDomainEventSend (struct qemud_client *client,
+                         virDomainPtr dom,
+                         virDomainEventType event)
+{
+    remote_message_header rep;
+    XDR xdr;
+    int len;
+    remote_events_domain_event_ret data;
+
+    if(!client) {
+        remoteDispatchError (client, NULL, "%s", _("Invalid Client"));
+        return;
+    }
+
+    /* Future versions of the protocol may use different vers or prog.  Try
+     * our hardest to send back a message that such clients could see.
+     */
+    rep.prog = REMOTE_PROGRAM;
+    rep.vers = REMOTE_PROTOCOL_VERSION;
+    rep.proc = REMOTE_PROC_EVENTS_DOMAIN_EVENT;
+    rep.direction = REMOTE_MESSAGE;
+    rep.serial = 1;
+    rep.status = REMOTE_OK;
+
+    /* Serialise the return header and event. */
+    xdrmem_create (&xdr, client->buffer, sizeof client->buffer, XDR_ENCODE);
+
+    len = 0; /* We'll come back and write this later. */
+    if (!xdr_int (&xdr, &len)) {
+        remoteDispatchError (client, NULL, "%s", _("xdr_int failed (1)"));
+        xdr_destroy (&xdr);
+        return;
+    }
+
+    if (!xdr_remote_message_header (&xdr, &rep)) {
+        xdr_destroy (&xdr);
+        return;
+    }
+
+    /* build return data */
+    make_nonnull_domain (&data.dom, dom);
+    data.event = (int) event;
+
+    if (!xdr_remote_events_domain_event_ret(&xdr, &data)) {
+        remoteDispatchError (client, NULL, "%s", _("serialise return struct"));
+        xdr_destroy (&xdr);
+        return;
+    }
+
+    len = xdr_getpos (&xdr);
+    if (xdr_setpos (&xdr, 0) == 0) {
+        remoteDispatchError (client, NULL, "%s", _("xdr_setpos failed"));
+        xdr_destroy (&xdr);
+        return;
+    }
+
+    if (!xdr_int (&xdr, &len)) {
+        remoteDispatchError (client, NULL, "%s", _("xdr_int failed (2)"));
+        xdr_destroy (&xdr);
+        return;
+    }
+
+    xdr_destroy (&xdr);
+
+    /* Send it. */
+    client->mode = QEMUD_MODE_TX_PACKET;
+    client->bufferLength = len;
+    client->bufferOffset = 0;
+}
 /*----- Helpers. -----*/
 
 /* get_nonnull_domain and get_nonnull_network turn an on-wire
diff --git a/qemud/remote_dispatch_localvars.h b/qemud/remote_dispatch_localvars.h
index 18d71e9..bb28109 100644
--- a/qemud/remote_dispatch_localvars.h
+++ b/qemud/remote_dispatch_localvars.h
@@ -96,6 +96,8 @@ remote_network_lookup_by_name_ret lv_remote_network_lookup_by_name_ret;
 remote_domain_memory_peek_args lv_remote_domain_memory_peek_args;
 remote_domain_memory_peek_ret lv_remote_domain_memory_peek_ret;
 remote_num_of_defined_domains_ret lv_remote_num_of_defined_domains_ret;
+remote_events_enable_args lv_remote_events_enable_args;
+remote_events_enable_ret lv_remote_events_enable_ret;
 remote_domain_block_stats_args lv_remote_domain_block_stats_args;
 remote_domain_block_stats_ret lv_remote_domain_block_stats_ret;
 remote_domain_detach_device_args lv_remote_domain_detach_device_args;
@@ -112,6 +114,7 @@ remote_get_version_ret lv_remote_get_version_ret;
 remote_domain_suspend_args lv_remote_domain_suspend_args;
 remote_storage_pool_lookup_by_name_args lv_remote_storage_pool_lookup_by_name_args;
 remote_storage_pool_lookup_by_name_ret lv_remote_storage_pool_lookup_by_name_ret;
+remote_events_domain_event_ret lv_remote_events_domain_event_ret;
 remote_network_set_autostart_args lv_remote_network_set_autostart_args;
 remote_network_get_autostart_args lv_remote_network_get_autostart_args;
 remote_network_get_autostart_ret lv_remote_network_get_autostart_ret;
diff --git a/qemud/remote_dispatch_proc_switch.h b/qemud/remote_dispatch_proc_switch.h
index 767b142..eeeb580 100644
--- a/qemud/remote_dispatch_proc_switch.h
+++ b/qemud/remote_dispatch_proc_switch.h
@@ -335,6 +335,21 @@ case REMOTE_PROC_DOMAIN_UNDEFINE:
         args = (char *) &lv_remote_domain_undefine_args;
         memset (&lv_remote_domain_undefine_args, 0, sizeof lv_remote_domain_undefine_args);
         break;
+case REMOTE_PROC_EVENTS_DOMAIN_EVENT:
+        fn = (dispatch_fn) remoteDispatchEventsDomainEvent;
+        ret_filter = (xdrproc_t) xdr_remote_events_domain_event_ret;
+        ret = (char *) &lv_remote_events_domain_event_ret;
+        memset (&lv_remote_events_domain_event_ret, 0, sizeof lv_remote_events_domain_event_ret);
+        break;
+case REMOTE_PROC_EVENTS_ENABLE:
+        fn = (dispatch_fn) remoteDispatchEventsEnable;
+        args_filter = (xdrproc_t) xdr_remote_events_enable_args;
+        args = (char *) &lv_remote_events_enable_args;
+        memset (&lv_remote_events_enable_args, 0, sizeof lv_remote_events_enable_args);
+        ret_filter = (xdrproc_t) xdr_remote_events_enable_ret;
+        ret = (char *) &lv_remote_events_enable_ret;
+        memset (&lv_remote_events_enable_ret, 0, sizeof lv_remote_events_enable_ret);
+        break;
 case REMOTE_PROC_FIND_STORAGE_POOL_SOURCES:
         fn = (dispatch_fn) remoteDispatchFindStoragePoolSources;
         args_filter = (xdrproc_t) xdr_remote_find_storage_pool_sources_args;
diff --git a/qemud/remote_dispatch_prototypes.h b/qemud/remote_dispatch_prototypes.h
index 950ad05..ce345e9 100644
--- a/qemud/remote_dispatch_prototypes.h
+++ b/qemud/remote_dispatch_prototypes.h
@@ -47,6 +47,8 @@ static int remoteDispatchDomainSetVcpus (struct qemud_server *server, struct qem
 static int remoteDispatchDomainShutdown (struct qemud_server *server, struct qemud_client *client, remote_message_header *req, remote_domain_shutdown_args *args, void *ret);
 static int remoteDispatchDomainSuspend (struct qemud_server *server, struct qemud_client *client, remote_message_header *req, remote_domain_suspend_args *args, void *ret);
 static int remoteDispatchDomainUndefine (struct qemud_server *server, struct qemud_client *client, remote_message_header *req, remote_domain_undefine_args *args, void *ret);
+static int remoteDispatchEventsDomainEvent (struct qemud_server *server, struct qemud_client *client, remote_message_header *req, void *args, remote_events_domain_event_ret *ret);
+static int remoteDispatchEventsEnable (struct qemud_server *server, struct qemud_client *client, remote_message_header *req, remote_events_enable_args *args, remote_events_enable_ret *ret);
 static int remoteDispatchFindStoragePoolSources (struct qemud_server *server, struct qemud_client *client, remote_message_header *req, remote_find_storage_pool_sources_args *args, remote_find_storage_pool_sources_ret *ret);
 static int remoteDispatchGetCapabilities (struct qemud_server *server, struct qemud_client *client, remote_message_header *req, void *args, remote_get_capabilities_ret *ret);
 static int remoteDispatchGetHostname (struct qemud_server *server, struct qemud_client *client, remote_message_header *req, void *args, remote_get_hostname_ret *ret);
diff --git a/qemud/remote_protocol.c b/qemud/remote_protocol.c
index be1d6d8..b876127 100644
--- a/qemud/remote_protocol.c
+++ b/qemud/remote_protocol.c
@@ -1943,6 +1943,37 @@ xdr_remote_storage_vol_get_path_ret (XDR *xdrs, remote_storage_vol_get_path_ret
 }
 
 bool_t
+xdr_remote_events_enable_args (XDR *xdrs, remote_events_enable_args *objp)
+{
+
+         if (!xdr_int (xdrs, &objp->event_class))
+                 return FALSE;
+         if (!xdr_int (xdrs, &objp->enable))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
+xdr_remote_events_enable_ret (XDR *xdrs, remote_events_enable_ret *objp)
+{
+
+         if (!xdr_int (xdrs, &objp->success))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
+xdr_remote_events_domain_event_ret (XDR *xdrs, remote_events_domain_event_ret *objp)
+{
+
+         if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+                 return FALSE;
+         if (!xdr_int (xdrs, &objp->event))
+                 return FALSE;
+        return TRUE;
+}
+
+bool_t
 xdr_remote_procedure (XDR *xdrs, remote_procedure *objp)
 {
 
diff --git a/qemud/remote_protocol.h b/qemud/remote_protocol.h
index bcaa219..f0b511f 100644
--- a/qemud/remote_protocol.h
+++ b/qemud/remote_protocol.h
@@ -1081,6 +1081,23 @@ struct remote_storage_vol_get_path_ret {
         remote_nonnull_string name;
 };
 typedef struct remote_storage_vol_get_path_ret remote_storage_vol_get_path_ret;
+
+struct remote_events_enable_args {
+        int event_class;
+        int enable;
+};
+typedef struct remote_events_enable_args remote_events_enable_args;
+
+struct remote_events_enable_ret {
+        int success;
+};
+typedef struct remote_events_enable_ret remote_events_enable_ret;
+
+struct remote_events_domain_event_ret {
+        remote_nonnull_domain dom;
+        int event;
+};
+typedef struct remote_events_domain_event_ret remote_events_domain_event_ret;
 #define REMOTE_PROGRAM 0x20008086
 #define REMOTE_PROTOCOL_VERSION 1
 
@@ -1189,6 +1206,8 @@ enum remote_procedure {
         REMOTE_PROC_NODE_GET_FREE_MEMORY = 102,
         REMOTE_PROC_DOMAIN_BLOCK_PEEK = 103,
         REMOTE_PROC_DOMAIN_MEMORY_PEEK = 104,
+        REMOTE_PROC_EVENTS_ENABLE = 105,
+        REMOTE_PROC_EVENTS_DOMAIN_EVENT = 106,
 };
 typedef enum remote_procedure remote_procedure;
 
@@ -1394,6 +1413,9 @@ extern  bool_t xdr_remote_storage_vol_get_info_args (XDR *, remote_storage_vol_g
 extern  bool_t xdr_remote_storage_vol_get_info_ret (XDR *, remote_storage_vol_get_info_ret*);
 extern  bool_t xdr_remote_storage_vol_get_path_args (XDR *, remote_storage_vol_get_path_args*);
 extern  bool_t xdr_remote_storage_vol_get_path_ret (XDR *, remote_storage_vol_get_path_ret*);
+extern  bool_t xdr_remote_events_enable_args (XDR *, remote_events_enable_args*);
+extern  bool_t xdr_remote_events_enable_ret (XDR *, remote_events_enable_ret*);
+extern  bool_t xdr_remote_events_domain_event_ret (XDR *, remote_events_domain_event_ret*);
 extern  bool_t xdr_remote_procedure (XDR *, remote_procedure*);
 extern  bool_t xdr_remote_message_direction (XDR *, remote_message_direction*);
 extern  bool_t xdr_remote_message_status (XDR *, remote_message_status*);
@@ -1575,6 +1597,9 @@ extern bool_t xdr_remote_storage_vol_get_info_args ();
 extern bool_t xdr_remote_storage_vol_get_info_ret ();
 extern bool_t xdr_remote_storage_vol_get_path_args ();
 extern bool_t xdr_remote_storage_vol_get_path_ret ();
+extern bool_t xdr_remote_events_enable_args ();
+extern bool_t xdr_remote_events_enable_ret ();
+extern bool_t xdr_remote_events_domain_event_ret ();
 extern bool_t xdr_remote_procedure ();
 extern bool_t xdr_remote_message_direction ();
 extern bool_t xdr_remote_message_status ();
diff --git a/qemud/remote_protocol.x b/qemud/remote_protocol.x
index f848ae5..09acd80 100644
--- a/qemud/remote_protocol.x
+++ b/qemud/remote_protocol.x
@@ -965,6 +965,21 @@ struct remote_storage_vol_get_path_ret {
     remote_nonnull_string name;
 };
 
+/* Events */
+struct remote_events_enable_args {
+    int event_class;
+    int enable;
+};
+
+struct remote_events_enable_ret {
+    int success;
+};
+
+struct remote_events_domain_event_ret {
+    remote_nonnull_domain dom;
+    int event;
+};
+
 /*----- Protocol. -----*/
 
 /* Define the program number, protocol version and procedure numbers here. */
@@ -1086,7 +1101,10 @@ enum remote_procedure {
     REMOTE_PROC_NODE_GET_FREE_MEMORY = 102,
 
     REMOTE_PROC_DOMAIN_BLOCK_PEEK = 103,
-    REMOTE_PROC_DOMAIN_MEMORY_PEEK = 104
+    REMOTE_PROC_DOMAIN_MEMORY_PEEK = 104,
+
+    REMOTE_PROC_EVENTS_ENABLE = 105,
+    REMOTE_PROC_EVENTS_DOMAIN_EVENT = 106
 };
 
 /* Custom RPC structure. */
diff --git a/src/driver.h b/src/driver.h
index 655cd05..005fe03 100644
--- a/src/driver.h
+++ b/src/driver.h
@@ -40,6 +40,13 @@ typedef enum {
     VIR_DRV_OPEN_ERROR = -2,
 } virDrvOpenStatus;
 
+
+/* Event Classes. (bitmasked value) */
+typedef enum {
+    virDomainEvent = 1,
+    virNodeEvent = 2, /* NYI */
+} virEventClass;
+
 /* Feature detection.  This is a libvirt-private interface for determining
  * what features are supported by the driver.
  *
@@ -280,6 +287,15 @@ typedef unsigned long long
     (*virDrvNodeGetFreeMemory)
                     (virConnectPtr conn);
 
+typedef int
+    (*virDrvEventsEnableEventClass)
+                    (virConnectPtr conn,
+                     virEventClass event_class,
+                     int enable);
+
+typedef int
+    (*virDrvDomainEventEmitted)
+                    (virDomainEventType evt);
 /**
  * _virDriver:
  *
@@ -296,6 +312,8 @@ struct _virDriver {
     int	       no;	/* the number virDrvNo */
     const char * name;	/* the name of the driver */
     unsigned long ver;	/* the version of the backend */
+    virConnectPtr conns; /* the list of active connections */
+
     virDrvProbe			probe;
     virDrvOpen			open;
     virDrvClose			close;
@@ -352,6 +370,8 @@ struct _virDriver {
     virDrvDomainMemoryPeek      domainMemoryPeek;
     virDrvNodeGetCellsFreeMemory	nodeGetCellsFreeMemory;
     virDrvNodeGetFreeMemory		getFreeMemory;
+    virDrvEventsEnableEventClass         enableEventClass;
+    virDrvDomainEventEmitted             domainEventEmitted;
 };
 
 typedef int
@@ -396,7 +416,6 @@ typedef int
         (*virDrvNetworkSetAutostart)	(virNetworkPtr network,
                                          int autostart);
 
-
 typedef struct _virNetworkDriver virNetworkDriver;
 typedef virNetworkDriver *virNetworkDriverPtr;
 
diff --git a/src/event.c b/src/event.c
index 49a9e61..9a39ab7 100644
--- a/src/event.c
+++ b/src/event.c
@@ -70,16 +70,28 @@ int virEventRemoveTimeout(int timer) {
     return removeTimeoutImpl(timer);
 }
 
-void __virEventRegisterImpl(virEventAddHandleFunc addHandle,
-                            virEventUpdateHandleFunc updateHandle,
-                            virEventRemoveHandleFunc removeHandle,
-                            virEventAddTimeoutFunc addTimeout,
-                            virEventUpdateTimeoutFunc updateTimeout,
-                            virEventRemoveTimeoutFunc removeTimeout) {
+void virEventRegisterHandleImpl(virEventAddHandleFunc addHandle,
+                                virEventUpdateHandleFunc updateHandle,
+                                virEventRemoveHandleFunc removeHandle) {
     addHandleImpl = addHandle;
     updateHandleImpl = updateHandle;
     removeHandleImpl = removeHandle;
+}
+
+void __virEventRegisterTimeoutImpl(virEventAddTimeoutFunc addTimeout,
+                                  virEventUpdateTimeoutFunc updateTimeout,
+                                  virEventRemoveTimeoutFunc removeTimeout) {
     addTimeoutImpl = addTimeout;
     updateTimeoutImpl = updateTimeout;
     removeTimeoutImpl = removeTimeout;
 }
+
+void __virEventRegisterImpl(virEventAddHandleFunc addHandle,
+                            virEventUpdateHandleFunc updateHandle,
+                            virEventRemoveHandleFunc removeHandle,
+                            virEventAddTimeoutFunc addTimeout,
+                            virEventUpdateTimeoutFunc updateTimeout,
+                            virEventRemoveTimeoutFunc removeTimeout) {
+    virEventRegisterHandleImpl(addHandle,  updateHandle,  removeHandle);
+    virEventRegisterTimeoutImpl(addTimeout, updateTimeout, removeTimeout);
+}
diff --git a/src/event.h b/src/event.h
index 758573c..b3a3849 100644
--- a/src/event.h
+++ b/src/event.h
@@ -23,17 +23,7 @@
 
 #ifndef __VIR_EVENT_H__
 #define __VIR_EVENT_H__
-
-
-/**
- * virEventHandleCallback: callback for receiving file handle events
- *
- * @fd: file handle on which the event occurred
- * @events: bitset of events from POLLnnn constants
- * @opaque: user data registered with handle
- */
-typedef void (*virEventHandleCallback)(int fd, int events, void *opaque);
-
+#include "internal.h"
 /**
  * virEventAddHandle: register a callback for monitoring file handle events
  *
@@ -110,14 +100,14 @@ void virEventUpdateTimeout(int timer, int frequency);
  */
 int virEventRemoveTimeout(int timer);
 
-typedef int (*virEventAddHandleFunc)(int, int, virEventHandleCallback, void *);
-typedef void (*virEventUpdateHandleFunc)(int, int);
-typedef int (*virEventRemoveHandleFunc)(int);
-
 typedef int (*virEventAddTimeoutFunc)(int, virEventTimeoutCallback, void *);
 typedef void (*virEventUpdateTimeoutFunc)(int, int);
 typedef int (*virEventRemoveTimeoutFunc)(int);
 
+void __virEventRegisterTimeoutImpl(virEventAddTimeoutFunc addTimeout,
+                                  virEventUpdateTimeoutFunc updateTimeout,
+                                  virEventRemoveTimeoutFunc removeTimeout);
+
 void __virEventRegisterImpl(virEventAddHandleFunc addHandle,
                             virEventUpdateHandleFunc updateHandle,
                             virEventRemoveHandleFunc removeHandle,
@@ -125,6 +115,7 @@ void __virEventRegisterImpl(virEventAddHandleFunc addHandle,
                             virEventUpdateTimeoutFunc updateTimeout,
                             virEventRemoveTimeoutFunc removeTimeout);
 
-#define virEventRegisterImpl(ah,rh,at,rt) __virEventRegisterImpl(ah,rh,at,rt)
+#define virEventRegisterTimeoutImpl(at,ut,rt) __virEventRegisterTimeoutImpl((at),(ut),(rt))
+#define virEventRegisterImpl(ah,uh,rh,at,ut,rt) __virEventRegisterImpl((ah),(uh),(rh),(at),(ut),(rt))
 
 #endif /* __VIR_EVENT_H__ */
diff --git a/src/internal.h b/src/internal.h
index a3d48fa..67a3e5b 100644
--- a/src/internal.h
+++ b/src/internal.h
@@ -191,6 +191,18 @@ extern int debugFlag;
 #define VIR_IS_STORAGE_VOL(obj)		((obj) && (obj)->magic==VIR_STORAGE_VOL_MAGIC)
 #define VIR_IS_CONNECTED_STORAGE_VOL(obj)	(VIR_IS_STORAGE_VOL(obj) && VIR_IS_CONNECT((obj)->conn))
 
+/**
+ * Domain Event Callbacks
+ */
+struct _virDomainEventCallbackList {
+    virConnectPtr conn;
+    virConnectDomainEventCallback cb;
+    void *opaque;
+    struct _virDomainEventCallbackList *next;
+};
+
+typedef struct _virDomainEventCallbackList virDomainEventCallbackList;
+
 /*
  * arbitrary limitations
  */
@@ -237,6 +249,12 @@ struct _virConnect {
     virHashTablePtr storagePools;/* hash table for known storage pools */
     virHashTablePtr storageVols;/* hash table for known storage vols */
     int refs;                 /* reference count */
+
+    /* Domain Callbacks */
+    virDomainEventCallbackList *domainEventCallbacks;
+
+    /* link to next conn of this driver type */
+    struct _virConnect *next;
 };
 
 /**
@@ -377,4 +395,13 @@ char *virStringListJoin(const virStringList *list, const char *pre,
                         const char *post, const char *sep);
 void virStringListFree(virStringList *list);
 
+/*
+ * Domain Event Notification
+ */
+
+void virDomainEventCallbackListFree(virDomainEventCallbackList *head);
+
+void virDispatchDomainEvent(virDomainPtr dom, int event);
+void virBroadcastDomainEvent(virDomainPtr dom, int event);
+
 #endif                          /* __VIR_INTERNAL_H__ */
diff --git a/src/libvirt.c b/src/libvirt.c
index e06e9f3..9472646 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -785,6 +785,8 @@ do_open (const char *name,
         if (res == VIR_DRV_OPEN_ERROR) goto failed;
         else if (res == VIR_DRV_OPEN_SUCCESS) {
             ret->driver = virDriverTab[i];
+            ret->next = ret->driver->conns;
+            ret->driver->conns = ret;
             break;
         }
     }
@@ -957,6 +959,19 @@ virConnectClose(virConnectPtr conn)
         conn->networkDriver->close (conn);
     if (conn->storageDriver)
         conn->storageDriver->close (conn);
+    if (conn->domainEventCallbacks)
+        virDomainEventCallbackListFree(conn->domainEventCallbacks);
+
+    /* Remove the connection from the list of active connections */
+    virConnectPtr *last = &conn->driver->conns;
+    while(*last) {
+        virConnectPtr p = *last;
+        if( p == conn ) {
+            *last = p->next;
+            break;
+        }
+        last = &p->next;
+    }
     conn->driver->close (conn);
 
     if (virUnrefConnect(conn) < 0)
@@ -1427,6 +1442,7 @@ virDomainLookupByName(virConnectPtr conn, const char *name)
 int
 virDomainDestroy(virDomainPtr domain)
 {
+    int ret;
     virConnectPtr conn;
 
     DEBUG("domain=%p", domain);
@@ -1442,8 +1458,14 @@ virDomainDestroy(virDomainPtr domain)
         return (-1);
     }
 
-    if (conn->driver->domainDestroy)
-        return conn->driver->domainDestroy (domain);
+    if (conn->driver->domainDestroy) {
+        ret = conn->driver->domainDestroy (domain);
+        if(!ret &&
+            conn->driver->domainEventEmitted &&
+            !conn->driver->domainEventEmitted(VIR_DOMAIN_EVENT_STOPPED))
+            virBroadcastDomainEvent(domain, VIR_DOMAIN_EVENT_STOPPED);
+        return ret;
+    }
 
     virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
     return -1;
@@ -1487,6 +1509,7 @@ virDomainFree(virDomainPtr domain)
 int
 virDomainSuspend(virDomainPtr domain)
 {
+    int ret;
     virConnectPtr conn;
     DEBUG("domain=%p", domain);
 
@@ -1501,8 +1524,14 @@ virDomainSuspend(virDomainPtr domain)
 
     conn = domain->conn;
 
-    if (conn->driver->domainSuspend)
-        return conn->driver->domainSuspend (domain);
+    if (conn->driver->domainSuspend) {
+        ret = conn->driver->domainSuspend (domain);
+        if(!ret &&
+            conn->driver->domainEventEmitted &&
+            !conn->driver->domainEventEmitted(VIR_DOMAIN_EVENT_SUSPENDED))
+            virBroadcastDomainEvent(domain, VIR_DOMAIN_EVENT_SUSPENDED);
+        return ret;
+    }
 
     virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
     return -1;
@@ -1521,6 +1550,7 @@ virDomainSuspend(virDomainPtr domain)
 int
 virDomainResume(virDomainPtr domain)
 {
+    int ret;
     virConnectPtr conn;
     DEBUG("domain=%p", domain);
 
@@ -1535,8 +1565,14 @@ virDomainResume(virDomainPtr domain)
 
     conn = domain->conn;
 
-    if (conn->driver->domainResume)
-        return conn->driver->domainResume (domain);
+    if (conn->driver->domainResume) {
+        ret = conn->driver->domainResume (domain);
+        if(!ret &&
+            conn->driver->domainEventEmitted &&
+            !conn->driver->domainEventEmitted(VIR_DOMAIN_EVENT_RESUMED))
+            virBroadcastDomainEvent(domain, VIR_DOMAIN_EVENT_RESUMED);
+        return ret;
+    }
 
     virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
     return -1;
@@ -1557,6 +1593,7 @@ virDomainResume(virDomainPtr domain)
 int
 virDomainSave(virDomainPtr domain, const char *to)
 {
+    int ret;
     char filepath[4096];
     virConnectPtr conn;
     DEBUG("domain=%p, to=%s", domain, to);
@@ -1595,8 +1632,14 @@ virDomainSave(virDomainPtr domain, const char *to)
 
     }
 
-    if (conn->driver->domainSave)
-        return conn->driver->domainSave (domain, to);
+    if (conn->driver->domainSave) {
+        ret = conn->driver->domainSave (domain, to);
+        if(!ret &&
+            conn->driver->domainEventEmitted &&
+            !conn->driver->domainEventEmitted(VIR_DOMAIN_EVENT_SAVED))
+            virBroadcastDomainEvent(domain, VIR_DOMAIN_EVENT_SAVED);
+        return ret;
+    }
 
     virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
     return -1;
@@ -2805,6 +2848,7 @@ virDomainMemoryPeek (virDomainPtr dom,
  */
 virDomainPtr
 virDomainDefineXML(virConnectPtr conn, const char *xml) {
+    virDomainPtr ret;
     DEBUG("conn=%p, xml=%s", conn, xml);
 
     if (!VIR_IS_CONNECT(conn)) {
@@ -2820,8 +2864,14 @@ virDomainDefineXML(virConnectPtr conn, const char *xml) {
         return (NULL);
     }
 
-    if (conn->driver->domainDefineXML)
-        return conn->driver->domainDefineXML (conn, xml);
+    if (conn->driver->domainDefineXML) {
+        ret = conn->driver->domainDefineXML (conn, xml);
+        if(ret &&
+            conn->driver->domainEventEmitted &&
+            !conn->driver->domainEventEmitted(VIR_DOMAIN_EVENT_ADDED))
+            virBroadcastDomainEvent(ret, VIR_DOMAIN_EVENT_ADDED);
+        return ret;
+    }
 
     virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
     return NULL;
@@ -2838,6 +2888,7 @@ virDomainDefineXML(virConnectPtr conn, const char *xml) {
 int
 virDomainUndefine(virDomainPtr domain) {
     virConnectPtr conn;
+    int ret;
     DEBUG("domain=%p", domain);
 
     if (!VIR_IS_CONNECTED_DOMAIN(domain)) {
@@ -2850,8 +2901,14 @@ virDomainUndefine(virDomainPtr domain) {
         return (-1);
     }
 
-    if (conn->driver->domainUndefine)
-        return conn->driver->domainUndefine (domain);
+    if (conn->driver->domainUndefine) {
+        ret = conn->driver->domainUndefine (domain);
+        if(!ret &&
+            conn->driver->domainEventEmitted &&
+            !conn->driver->domainEventEmitted(VIR_DOMAIN_EVENT_REMOVED))
+            virBroadcastDomainEvent(domain, VIR_DOMAIN_EVENT_REMOVED);
+        return ret;
+    }
 
     virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
     return -1;
@@ -2926,6 +2983,7 @@ virConnectListDefinedDomains(virConnectPtr conn, char **const names,
  */
 int
 virDomainCreate(virDomainPtr domain) {
+    int ret;
     virConnectPtr conn;
     DEBUG("domain=%p", domain);
 
@@ -2943,9 +3001,14 @@ virDomainCreate(virDomainPtr domain) {
         return (-1);
     }
 
-    if (conn->driver->domainCreate)
-        return conn->driver->domainCreate (domain);
-
+    if (conn->driver->domainCreate) {
+        ret = conn->driver->domainCreate (domain);
+        if(!ret &&
+            conn->driver->domainEventEmitted &&
+            !conn->driver->domainEventEmitted(VIR_DOMAIN_EVENT_STARTED))
+            virBroadcastDomainEvent(domain, VIR_DOMAIN_EVENT_STARTED);
+        return ret;
+    }
     virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
     return -1;
 }
@@ -5318,3 +5381,148 @@ void virStringListFree(virStringList *list)
         list = p;
     }
 }
+
+/*
+ * Domain Event Notification
+ */
+
+/**
+ * virDomainEventCallbackListFree:
+ * @head: event callback list head
+ *
+ * Free the memory in the domain event callback list
+ */
+void virDomainEventCallbackListFree(virDomainEventCallbackList *head)
+{
+    while (head) {
+        virDomainEventCallbackList *p = head->next;
+        VIR_FREE(head);
+        head = p;
+    }
+}
+
+/**
+ * virConnectDomainEventRegister:
+ * @conn: pointer to the connection
+ * @cb: callback to the function handling domain events
+ * @opaque: opaque data to pass on to the callback
+ *
+ * Adds a Domain Event Callback
+ *
+ * Returns 0 on success, -1 on failure
+ */
+int virConnectDomainEventRegister(virConnectPtr conn,
+                                  virConnectDomainEventCallback cb,
+                                  void *opaque)
+{
+    int ret = 0;
+    int first = conn->domainEventCallbacks == NULL;
+    virDomainEventCallbackList *newNode;
+
+    if (VIR_ALLOC(newNode) < 0)
+        return -1;
+
+    newNode->next   = conn->domainEventCallbacks;
+    newNode->conn   = conn;
+    newNode->cb     = cb;
+    newNode->opaque = opaque;
+    conn->domainEventCallbacks = newNode;
+
+    /* Registering for a domain callback will enable delivery by default */
+    if (conn->driver && conn->driver->enableEventClass && first)
+        ret = conn->driver->enableEventClass (conn, virDomainEvent, 1);
+
+    DEBUG0("Registered domain event callback");
+    return ret;
+}
+
+/**
+ * virConnectDomainEventDeregister:
+ * @conn: pointer to the connection
+ * @cb: callback to the function handling domain events
+ *
+ * Removes a Domain Event Callback
+ *
+ * Returns 0 on success, -1 on failure
+ */
+int virConnectDomainEventDeregister(virConnectPtr conn, virConnectDomainEventCallback cb)
+{
+    int ret = -1;
+    virDomainEventCallbackList **last = &conn->domainEventCallbacks;
+
+    while(*last) {
+        virDomainEventCallbackList *p = *last;
+        if( p->conn == conn &&
+            p->cb == cb ) {
+            *last = p->next;
+
+            VIR_FREE(p);
+            DEBUG0("Removed domain event callback");
+            ret = 0;
+            break;
+        }
+        last = &p->next;
+    }
+
+    /* De-registering for a domain callback will disable delivery of this event type*/
+    if (conn->driver &&
+        conn->driver->enableEventClass &&
+        !conn->domainEventCallbacks)
+        ret = conn->driver->enableEventClass (conn, virDomainEvent, 0);
+
+    return ret;
+}
+
+/**
+ * virDispatchDomainEvent:
+ * @dom: the domain
+ * @event: the domain event code
+ *
+ * Internal function by which drivers to dispatch domain events.
+ */
+void virDispatchDomainEvent(virDomainPtr dom,
+                            int event)
+{
+    virDomainEventCallbackList *p = dom->conn->domainEventCallbacks;
+    DEBUG("Dispatching callbacks for event %d to %p", event, dom->conn);
+    while(p) {
+        DEBUG("   Calling cb %p", p->cb);
+        (p->cb)(dom->conn, dom, event, p->opaque);
+        p = p->next;
+    }
+    DEBUG("Done dispatching events to %p", dom->conn);
+}
+
+/**
+ * virDispatchDomainEvent:
+ * @dom: the domain
+ * @event: the domain event code
+ *
+ * Internal function by which drivers to broadcast domain events.
+ */
+void virBroadcastDomainEvent(virDomainPtr dom,
+                            int event)
+{
+    virDomainPtr dom_bc;
+    virConnectPtr conn = dom->conn->driver->conns;
+    if(!conn) {
+        DEBUG0("Trying to dispatch to null connection list");
+        return;
+    }
+
+    while(conn) {
+        if(conn != dom->conn ) {
+            dom_bc = virDomainLookupByName(conn, dom->name);
+        } else {
+            dom_bc = dom;
+        }
+
+        if(dom_bc)
+            virDispatchDomainEvent(dom_bc, event);
+
+        if(dom_bc != dom)
+            virDomainFree(dom_bc);
+
+        conn = conn->next;
+    }
+}
diff --git a/src/libvirt_sym.version b/src/libvirt_sym.version
index b8c470c..243d4a7 100644
--- a/src/libvirt_sym.version
+++ b/src/libvirt_sym.version
@@ -146,6 +146,10 @@
 	virStorageVolGetXMLDesc;
 	virStorageVolGetPath;
 
+        virEventRegisterHandleImpl;
+        virConnectDomainEventRegister;
+        virConnectDomainEventDeregister;
+
         /* Symbols with __ are private only
            for use by the libvirtd daemon.
            They are not part of stable ABI
diff --git a/src/lxc_driver.c b/src/lxc_driver.c
index 30c3cab..ea80530 100644
--- a/src/lxc_driver.c
+++ b/src/lxc_driver.c
@@ -1238,6 +1238,7 @@ static virDriver lxcDriver = {
     VIR_DRV_LXC, /* the number virDrvNo */
     "LXC", /* the name of the driver */
     LIBVIR_VERSION_NUMBER, /* the version of the backend */
+    NULL,/* conns */
     lxcProbe, /* probe */
     lxcOpen, /* open */
     lxcClose, /* close */
@@ -1294,6 +1295,8 @@ static virDriver lxcDriver = {
     NULL, /* domainMemoryPeek */
     NULL, /* nodeGetCellsFreeMemory */
     NULL, /* getFreeMemory */
+    NULL, /* enableEventClass */
+    NULL, /* domainEventSupported */
 };
 
 static virStateDriver lxcStateDriver = {
diff --git a/src/openvz_driver.c b/src/openvz_driver.c
index f68841e..a437818 100644
--- a/src/openvz_driver.c
+++ b/src/openvz_driver.c
@@ -958,6 +958,7 @@ static virDriver openvzDriver = {
     VIR_DRV_OPENVZ,
     "OPENVZ",
     LIBVIR_VERSION_NUMBER,
+    NULL,/* conns */
     openvzProbe, /* probe */
     openvzOpen, /* open */
     openvzClose, /* close */
@@ -1014,6 +1015,8 @@ static virDriver openvzDriver = {
     NULL, /* domainMemoryPeek */
     NULL, /* nodeGetCellsFreeMemory */
     NULL, /* nodeGetFreeMemory */
+    NULL, /* enableEventClass */
+    NULL, /* domainEventSupported */
 };
 
 int openvzRegister(void) {
diff --git a/src/qemu_conf.h b/src/qemu_conf.h
index 88dfade..4d22119 100644
--- a/src/qemu_conf.h
+++ b/src/qemu_conf.h
@@ -68,6 +68,7 @@ struct qemud_driver {
     char *vncListen;
 
     virCapsPtr caps;
+    virDriverPtr vir_driver;
 };
 
 
diff --git a/src/qemu_driver.c b/src/qemu_driver.c
index a88cb75..daabfa5 100644
--- a/src/qemu_driver.c
+++ b/src/qemu_driver.c
@@ -837,6 +837,8 @@ static int qemudNextFreeVNCPort(struct qemud_driver *driver ATTRIBUTE_UNUSED) {
     return -1;
 }
 
+static virDomainPtr qemudDomainLookupByName(virConnectPtr conn, const char *name);
+
 static int qemudStartVMDaemon(virConnectPtr conn,
                               struct qemud_driver *driver,
                               virDomainObjPtr vm,
@@ -850,6 +852,7 @@ static int qemudStartVMDaemon(virConnectPtr conn,
     unsigned int qemuCmdFlags;
     fd_set keepfd;
     const char *emulator;
+    virDomainPtr dom;
 
     FD_ZERO(&keepfd);
 
@@ -998,6 +1001,11 @@ static int qemudStartVMDaemon(virConnectPtr conn,
             qemudShutdownVMDaemon(conn, driver, vm);
             return -1;
         }
+        dom = qemudDomainLookupByName(conn,vm->def->name);
+        if(dom)
+            virBroadcastDomainEvent(dom, VIR_DOMAIN_EVENT_STARTED);
+        else
+            DEBUG0("Warning - dom is NULL at domain start");
     }
 
     return ret;
@@ -1032,11 +1040,22 @@ static int qemudVMData(struct qemud_driver *driver ATTRIBUTE_UNUSED,
 
 static void qemudShutdownVMDaemon(virConnectPtr conn ATTRIBUTE_UNUSED,
                                   struct qemud_driver *driver, virDomainObjPtr vm) {
+    virConnectPtr dconn;
     if (!virDomainIsActive(vm))
         return;
 
     qemudLog(QEMUD_INFO, _("Shutting down VM '%s'\n"), vm->def->name);
 
+    if( driver && driver->vir_driver) {
+        dconn = driver->vir_driver->conns;
+
+        if (dconn) {
+            virDomainPtr dom = qemudDomainLookupByName(dconn, vm->def->name);
+            /* Note dom should never be NULL here.  Just being paranoid ... */
+            if (dom)
+                virBroadcastDomainEvent(dom, VIR_DOMAIN_EVENT_STOPPED);
+        }
+    }
     kill(vm->pid, SIGTERM);
 
     qemudVMData(driver, vm, vm->stdout_fd);
@@ -2127,6 +2146,7 @@ static int qemudDomainSuspend(virDomainPtr dom) {
     }
     vm->state = VIR_DOMAIN_PAUSED;
     qemudDebug("Reply %s", info);
+    virBroadcastDomainEvent(dom, VIR_DOMAIN_EVENT_SUSPENDED);
     VIR_FREE(info);
     return 0;
 }
@@ -2155,6 +2175,7 @@ static int qemudDomainResume(virDomainPtr dom) {
     }
     vm->state = VIR_DOMAIN_RUNNING;
     qemudDebug("Reply %s", info);
+    virBroadcastDomainEvent(dom, VIR_DOMAIN_EVENT_RESUMED);
     VIR_FREE(info);
     return 0;
 }
@@ -2196,7 +2217,7 @@ static int qemudDomainDestroy(virDomainPtr dom) {
     if (!vm->persistent)
         virDomainRemoveInactive(&driver->domains,
                                 vm);
-
+    virBroadcastDomainEvent(dom, VIR_DOMAIN_EVENT_STOPPED);
     return 0;
 }
 
@@ -2527,7 +2548,7 @@ static int qemudDomainSave(virDomainPtr dom,
     if (!vm->persistent)
         virDomainRemoveInactive(&driver->domains,
                                 vm);
-
+    virBroadcastDomainEvent(dom, VIR_DOMAIN_EVENT_SAVED);
     return 0;
 }
 
@@ -2728,6 +2749,7 @@ static int qemudDomainRestore(virConnectPtr conn,
     struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
     virDomainDefPtr def;
     virDomainObjPtr vm;
+    virDomainPtr    dom;
     int fd;
     int ret;
     char *xml;
@@ -2834,6 +2856,11 @@ static int qemudDomainRestore(virConnectPtr conn,
         vm->state = VIR_DOMAIN_RUNNING;
     }
 
+    dom = virDomainLookupByID(conn, def->id);
+    if(dom) {
+        virBroadcastDomainEvent(dom, VIR_DOMAIN_EVENT_RESTORED);
+        VIR_FREE(dom);
+    }
     return 0;
 }
 
@@ -4008,10 +4035,38 @@ static int qemudNetworkSetAutostart(virNetworkPtr net,
     return 0;
 }
 
+static int qemudDomainEventSupported(virDomainEventType evt)
+{
+    switch(evt) {
+        case VIR_DOMAIN_EVENT_STARTED:
+        case VIR_DOMAIN_EVENT_STOPPED:
+        case VIR_DOMAIN_EVENT_SUSPENDED:
+        case VIR_DOMAIN_EVENT_RESUMED:
+        case VIR_DOMAIN_EVENT_SAVED:
+        case VIR_DOMAIN_EVENT_RESTORED:
+            DEBUG("%s: %d", __FUNCTION__, (int)evt);
+            return true;
+        default:
+            return false;
+    }
+    return false;
+}
+
+static int qemudEnableEventClass(virConnectPtr conn,
+                                 virEventClass event_class ATTRIBUTE_UNUSED,
+                                 int enable ATTRIBUTE_UNUSED)
+{
+    struct qemud_driver *d = conn->privateData;
+    d->vir_driver = conn->driver;
+
+    return 0;
+}
+
 static virDriver qemuDriver = {
     VIR_DRV_QEMU,
     "QEMU",
     LIBVIR_VERSION_NUMBER,
+    NULL,/* conns */
     qemudProbe, /* probe */
     qemudOpen, /* open */
     qemudClose, /* close */
@@ -4078,6 +4133,8 @@ static virDriver qemuDriver = {
     NULL, /* nodeGetCellsFreeMemory */
     NULL, /* getFreeMemory */
 #endif
+    qemudEnableEventClass, /* enableEventClass */
+    qemudDomainEventSupported, /* domainEventSupported */
 };
 
 static virNetworkDriver qemuNetworkDriver = {
diff --git a/src/remote_internal.c b/src/remote_internal.c
index 06b0f4f..2501e1f 100644
--- a/src/remote_internal.c
+++ b/src/remote_internal.c
@@ -34,6 +34,7 @@
 #include <signal.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <sys/poll.h>
 #include <fcntl.h>
 
 #ifdef HAVE_SYS_WAIT_H
@@ -73,6 +74,7 @@
 #include "remote_protocol.h"
 #include "memory.h"
 #include "util.h"
+#include "event.h"
 
 /* Per-connection private data. */
 #define MAGIC 999               /* private_data->magic if OK */
@@ -91,6 +93,7 @@ struct private_data {
     int localUses;              /* Ref count for private data */
     char *hostname;             /* Original hostname */
     FILE *debugLog;             /* Debug remote protocol */
+    PTHREAD_MUTEX_T (lock);     /* Lock to handle async RPC calls */
 #if HAVE_SASL
     sasl_conn_t *saslconn;      /* SASL context */
     const char *saslDecoded;
@@ -156,6 +159,8 @@ static void make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr do
 static void make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr net_src);
 static void make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr vol_src);
 static void make_nonnull_storage_vol (remote_nonnull_storage_vol *vol_dst, virStorageVolPtr vol_src);
+static void remoteDomainEventFired(int fd, int event, void *data);
+static void remoteDomainProcessEvent(virConnectPtr conn, XDR *xdr);
 
 /*----------------------------------------------------------------------*/
 
@@ -680,6 +685,15 @@ doRemoteOpen (virConnectPtr conn,
               (xdrproc_t) xdr_void, (char *) NULL) == -1)
         goto failed;
 
+    pthread_mutex_init(&priv->lock, NULL);
+    DEBUG0("Adding Handler for remote events");
+    /* Set up a callback to listen on the socket data */
+    if (virEventAddHandle(priv->sock,
+                          POLLIN | POLLERR | POLLHUP,
+                          remoteDomainEventFired,
+                          conn) < 0) {
+        DEBUG0("virEventAddHandle failed: No addHandleImpl defined. continuing without events.");
+    }
     /* Successful. */
     retcode = VIR_DRV_OPEN_SUCCESS;
 
@@ -4289,6 +4303,25 @@ remoteAuthPolkit (virConnectPtr conn, struct private_data *priv, int in_open,
 }
 #endif /* HAVE_POLKIT */
 
+static int remoteEventsEnableEventClass (virConnectPtr conn,
+                                         virEventClass event_class,
+                                         int enable)
+{
+    remote_events_enable_args args;
+    remote_events_enable_ret ret;
+
+    args.event_class = event_class;
+    args.enable = enable;
+
+    memset (&ret, 0, sizeof ret);
+    if (call ( conn, conn->privateData, 0, REMOTE_PROC_EVENTS_ENABLE,
+              (xdrproc_t) xdr_remote_events_enable_args, (char *) &args,
+              (xdrproc_t) xdr_remote_events_enable_ret, (char *) &ret) == -1)
+        return -1;
+
+    return 0;
+}
+
 /*----------------------------------------------------------------------*/
 
 static int really_write (virConnectPtr conn, struct private_data *priv,
@@ -4362,19 +4395,30 @@ call (virConnectPtr conn, struct private_data *priv,
     }
     xdr_destroy (&xdr);
 
+    /* Lock on the connection semaphore, so we do not pull
+     * data off the wire if an async event fires while we
+     * are waiting on the response */
+    pthread_mutex_lock(&priv->lock);
+
     /* Send length word followed by header+args. */
     if (really_write (conn, priv, flags & REMOTE_CALL_IN_OPEN, buffer2, sizeof buffer2) == -1 ||
-        really_write (conn, priv, flags & REMOTE_CALL_IN_OPEN, buffer, len-4) == -1)
+        really_write (conn, priv, flags & REMOTE_CALL_IN_OPEN, buffer, len-4) == -1) {
+        pthread_mutex_unlock(&priv->lock);
         return -1;
+        }
 
+retry_read:
     /* Read and deserialise length word. */
-    if (really_read (conn, priv, flags & REMOTE_CALL_IN_OPEN, buffer2, sizeof buffer2) == -1)
+    if (really_read (conn, priv, flags & REMOTE_CALL_IN_OPEN, buffer2, sizeof buffer2) == -1) {
+        pthread_mutex_unlock(&priv->lock);
         return -1;
+    }
 
     xdrmem_create (&xdr, buffer2, sizeof buffer2, XDR_DECODE);
     if (!xdr_int (&xdr, &len)) {
         error (flags & REMOTE_CALL_IN_OPEN ? NULL : conn,
                VIR_ERR_RPC, _("xdr_int (length word, reply)"));
+        pthread_mutex_unlock(&priv->lock);
         return -1;
     }
     xdr_destroy (&xdr);
@@ -4385,18 +4429,22 @@ call (virConnectPtr conn, struct private_data *priv,
     if (len < 0 || len > REMOTE_MESSAGE_MAX) {
         error (flags & REMOTE_CALL_IN_OPEN ? NULL : conn,
                VIR_ERR_RPC, _("packet received from server too large"));
+        pthread_mutex_unlock(&priv->lock);
         return -1;
     }
 
     /* Read reply header and what follows (either a ret or an error). */
-    if (really_read (conn, priv, flags & REMOTE_CALL_IN_OPEN, buffer, len) == -1)
+    if (really_read (conn, priv, flags & REMOTE_CALL_IN_OPEN, buffer, len) == -1) {
+        pthread_mutex_unlock(&priv->lock);
         return -1;
+    }
 
     /* Deserialise reply header. */
     xdrmem_create (&xdr, buffer, len, XDR_DECODE);
     if (!xdr_remote_message_header (&xdr, &hdr)) {
         error (flags & REMOTE_CALL_IN_OPEN ? NULL : conn,
                VIR_ERR_RPC, _("invalid header in reply"));
+        pthread_mutex_unlock(&priv->lock);
         return -1;
     }
 
@@ -4407,6 +4455,7 @@ call (virConnectPtr conn, struct private_data *priv,
                          VIR_ERR_RPC, VIR_ERR_ERROR, NULL, NULL, NULL, 0, 0,
                          _("unknown program (received %x, expected %x)"),
                          hdr.prog, REMOTE_PROGRAM);
+        pthread_mutex_unlock(&priv->lock);
         return -1;
     }
     if (hdr.vers != REMOTE_PROTOCOL_VERSION) {
@@ -4415,19 +4464,30 @@ call (virConnectPtr conn, struct private_data *priv,
                          VIR_ERR_RPC, VIR_ERR_ERROR, NULL, NULL, NULL, 0, 0,
                          _("unknown protocol version (received %x, expected %x)"),
                          hdr.vers, REMOTE_PROTOCOL_VERSION);
+        pthread_mutex_unlock(&priv->lock);
         return -1;
     }
 
-    /* If we extend the server to actually send asynchronous messages, then
-     * we'll need to change this so that it can recognise an asynch
-     * message being received at this point.
-     */
+    if (hdr.proc == REMOTE_PROC_EVENTS_DOMAIN_EVENT &&
+        hdr.direction == REMOTE_MESSAGE) {
+        /* An async message has come in while we were waiting for the
+         * response. Process it to pull it off the wire, and try again
+         */
+        DEBUG0("Encountered an event while waiting for a response");
+
+        remoteDomainProcessEvent(conn, &xdr);
+
+        DEBUG0("Retrying read");
+        xdr_destroy (&xdr);
+        goto retry_read;
+    }
     if (hdr.proc != proc_nr) {
         __virRaiseError (flags & REMOTE_CALL_IN_OPEN ? NULL : conn,
                          NULL, NULL, VIR_FROM_REMOTE,
                          VIR_ERR_RPC, VIR_ERR_ERROR, NULL, NULL, NULL, 0, 0,
                          _("unknown procedure (received %x, expected %x)"),
                          hdr.proc, proc_nr);
+        pthread_mutex_unlock(&priv->lock);
         return -1;
     }
     if (hdr.direction != REMOTE_REPLY) {
@@ -4436,6 +4496,7 @@ call (virConnectPtr conn, struct private_data *priv,
                          VIR_ERR_RPC, VIR_ERR_ERROR, NULL, NULL, NULL, 0, 0,
                          _("unknown direction (received %x, expected %x)"),
                          hdr.direction, REMOTE_REPLY);
+        pthread_mutex_unlock(&priv->lock);
         return -1;
     }
     if (hdr.serial != serial) {
@@ -4443,6 +4504,7 @@ call (virConnectPtr conn, struct private_data *priv,
                          VIR_ERR_RPC, VIR_ERR_ERROR, NULL, NULL, NULL, 0, 0,
                          _("unknown serial (received %x, expected %x)"),
                          hdr.serial, serial);
+        pthread_mutex_unlock(&priv->lock);
         return -1;
     }
 
@@ -4458,6 +4520,7 @@ call (virConnectPtr conn, struct private_data *priv,
             return -1;
         }
         xdr_destroy (&xdr);
+        pthread_mutex_unlock(&priv->lock);
         return 0;
 
     case REMOTE_ERROR:
@@ -4465,6 +4528,7 @@ call (virConnectPtr conn, struct private_data *priv,
         if (!xdr_remote_error (&xdr, &rerror)) {
             error (flags & REMOTE_CALL_IN_OPEN ? NULL : conn,
                    VIR_ERR_RPC, _("unmarshalling remote_error"));
+            pthread_mutex_unlock(&priv->lock);
             return -1;
         }
         xdr_destroy (&xdr);
@@ -4475,10 +4539,12 @@ call (virConnectPtr conn, struct private_data *priv,
             rerror.code == VIR_ERR_RPC &&
             rerror.level == VIR_ERR_ERROR &&
             STRPREFIX(*rerror.message, "unknown procedure")) {
+            pthread_mutex_unlock(&priv->lock);
             return -2;
         }
         server_error (flags & REMOTE_CALL_IN_OPEN ? NULL : conn, &rerror);
         xdr_free ((xdrproc_t) xdr_remote_error, (char *) &rerror);
+        pthread_mutex_unlock(&priv->lock);
         return -1;
 
     default:
@@ -4487,6 +4553,7 @@ call (virConnectPtr conn, struct private_data *priv,
                          _("unknown status (received %x)"),
                          hdr.status);
         xdr_destroy (&xdr);
+        pthread_mutex_unlock(&priv->lock);
         return -1;
     }
 }
@@ -4872,6 +4939,7 @@ static virDriver driver = {
     .domainMemoryPeek = remoteDomainMemoryPeek,
     .nodeGetCellsFreeMemory = remoteNodeGetCellsFreeMemory,
     .getFreeMemory = remoteNodeGetFreeMemory,
+    .enableEventClass = remoteEventsEnableEventClass
 };
 
 static virNetworkDriver network_driver = {
@@ -4957,3 +5025,99 @@ remoteRegister (void)
 
     return 0;
 }
+
+/**
+ * remoteDomainProcessEvent
+ *
+ * Read the data off the wire, and process the event
+ */
+void remoteDomainProcessEvent(virConnectPtr conn,
+                              XDR *xdr)
+{
+    remote_events_domain_event_ret ret;
+    memset (&ret, 0, sizeof ret);
+
+    virDomainPtr dom;
+    /* unmarshall parameters, and process it*/
+    if (! xdr_remote_events_domain_event_ret(xdr, &ret) ) {
+        error (conn, VIR_ERR_RPC, _("remoteDomainProcessEvent: unmarshalling ret"));
+        return;
+    }
+
+    dom = get_nonnull_domain(conn,ret.dom);
+    virDispatchDomainEvent(dom, ret.event);
+}
+
+/** remoteDomainEventFired:
+ *
+ * The callback for monitoring the remote socket
+ * for event data
+ */
+void remoteDomainEventFired(int fd ATTRIBUTE_UNUSED,
+                             int event ATTRIBUTE_UNUSED,
+                             void *opaque)
+{
+    char buffer[REMOTE_MESSAGE_MAX];
+    char buffer2[4];
+    struct remote_message_header hdr;
+    XDR xdr;
+    int len;
+
+    virConnectPtr        conn = opaque;
+    struct private_data *priv = conn->privateData;
+
+     /* This may be a response to a command, or it
+     *  may be a domain event.
+     *  grab a lock on the connection so we don't stomp on
+     *  command replys
+     */
+    DEBUG("%s : Event fired - grabbing lock", __FUNCTION__);
+    pthread_mutex_lock(&priv->lock);
+
+    /* Read and deserialise length word. */
+    if (really_read (conn, priv, 0, buffer2, sizeof buffer2) == -1) {
+        pthread_mutex_unlock(&priv->lock);
+        return;
+    }
+
+    xdrmem_create (&xdr, buffer2, sizeof buffer2, XDR_DECODE);
+    if (!xdr_int (&xdr, &len)) {
+        error (conn, VIR_ERR_RPC, _("xdr_int (length word, reply)"));
+        pthread_mutex_unlock(&priv->lock);
+        return;
+    }
+    xdr_destroy (&xdr);
+
+    /* Length includes length word - adjust to real length to read. */
+    len -= 4;
+
+    if (len < 0 || len > REMOTE_MESSAGE_MAX) {
+        error (conn, VIR_ERR_RPC, _("packet received from server too large"));
+        pthread_mutex_unlock(&priv->lock);
+        return;
+    }
+
+    /* Read reply header and what follows (either a ret or an error). */
+    if (really_read (conn, priv, 0, buffer, len) == -1) {
+        error (conn, VIR_ERR_RPC, _("error reading buffer from memory"));
+        return;
+    }
+
+    /* Deserialise reply header. */
+    xdrmem_create (&xdr, buffer, len, XDR_DECODE);
+    if (!xdr_remote_message_header (&xdr, &hdr)) {
+        error (conn, VIR_ERR_RPC, _("invalid header in event firing"));
+        pthread_mutex_unlock(&priv->lock);
+        return;
+    }
+
+    if (hdr.proc == REMOTE_PROC_EVENTS_DOMAIN_EVENT &&
+        hdr.direction == REMOTE_MESSAGE) {
+        DEBUG0("Encountered an async event");
+        remoteDomainProcessEvent(conn, &xdr);
+    } else {
+        DEBUG0("invalid proc in event firing");
+        error (conn, VIR_ERR_RPC, _("invalid proc in event firing"));
+    }
+    pthread_mutex_unlock(&priv->lock);
+}
\ No newline at end of file
diff --git a/src/test.c b/src/test.c
index 69c9090..ad5ea74 100644
--- a/src/test.c
+++ b/src/test.c
@@ -1539,6 +1539,7 @@ static virDriver testDriver = {
     VIR_DRV_TEST,
     "Test",
     LIBVIR_VERSION_NUMBER,
+    NULL,/* conns */
     NULL, /* probe */
     testOpen, /* open */
     testClose, /* close */
@@ -1595,6 +1596,8 @@ static virDriver testDriver = {
     NULL, /* domainMemoryPeek */
     testNodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
     NULL, /* getFreeMemory */
+    NULL, /* enableEventClass */
+    NULL, /* domainEventSupported */
 };
 
 static virNetworkDriver testNetworkDriver = {
