Added a D-Bus filter to find out when flimflamd dies, so that we can clean up and exit.

dhcpcd-dbus.c

 /*
  * dhcpcd-dbus
  * Copyright 2009 Roy Marples <roy@marples.name>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 455 matching lines @@
         dbus_message_unref(reply);
         return DBUS_HANDLER_RESULT_HANDLED;
 }
 
 static DBusHandlerResult
 msg_handler(DBusConnection *con, DBusMessage *msg, _unused void *data)
 {
 #define IsMethod(msg, method) \
         dbus_message_is_method_call(msg, DHCPCD_SERVICE, method)
         if (dbus_message_is_method_call(msg, DBUS_INTERFACE_INTROSPECTABLE,
-                                        "Introspect")) {
+                                        "Introspect")) {
                 return introspect(con, msg);
         } else if (IsMethod(msg, "GetVersion")) {
                 return version(con, msg, VERSION);
         } else if (IsMethod(msg, "GetInterfaces")) {
                 return dhcpcd_get_interfaces(con, msg);
         } else if (IsMethod(msg, "GetStatus")) {
                 return return_status(con, msg);
         } else if (IsMethod(msg, "Rebind")) {
                 start_interface(ifaces);
                 return dbus_ack(con, msg);
@@ skipping 58 matching lines @@
 
 static void
 remove_watch(DBusWatch *watch, _unused void *data)
 {
         int fd;
 
         fd = dbus_watch_get_unix_fd(watch);
         delete_event(fd);
 }
 
+static DBusHandlerResult dhcpcd_dbus_filter(DBusConnection *conn,
+                                            DBusMessage *msg,
+                                            void *user_data)
+{
+        const char *service = NULL;
+        const char *old_owner = NULL;
+        const char *new_owner = NULL;
+
+        if (!dbus_message_is_signal(msg, DBUS_INTERFACE_DBUS,
+                                    "NameOwnerChanged"))
+                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+        if (!dbus_message_get_args(msg, NULL,
+                                   DBUS_TYPE_STRING, &service,
+                                   DBUS_TYPE_STRING, &old_owner,
+                                   DBUS_TYPE_STRING, &new_owner,
+                                   DBUS_TYPE_INVALID)) {
+                syslog(LOG_ERR,
+                       "Invalid arguments for NameOwnerChanged signal");
+                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+        }
+        if (strcmp(service, "org.chromium.flimflam") == 0 &&
+            strlen(new_owner) == 0) {

[kobi, 2010/07/27 18:07:02]

I think it is better to check new_owner against null || '\0'

+                syslog(LOG_INFO, "exiting because flimflamd has died");
+                stop_interface(ifaces);
+                exit(EXIT_FAILURE);
+        }
+        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+static const char *service_watch_rule = "interface=" DBUS_INTERFACE_DBUS
+                                        ",type=signal,member=NameOwnerChanged";
+
 void
 dhcpcd_dbus_close(void)
 {
         if (connection) {
+                dbus_bus_remove_match(connection, service_watch_rule, NULL);
+                dbus_connection_remove_filter(connection,
+                                              dhcpcd_dbus_filter,
+                                              NULL);
                 dbus_connection_unref(connection);
                 connection = NULL;
         }
 }
 
 int
 dhcpcd_dbus_init(void)
 {
         DBusObjectPathVTable vt = {
                 NULL, &msg_handler, NULL, NULL, NULL, NULL
@@ skipping 17 matching lines @@
         {
                 syslog(LOG_ERR, "dbus: failed to set watch functions");
                 return -1;
         }
         if (!dbus_connection_register_object_path(connection,
                 DHCPCD_PATH, &vt, NULL))
         {
                 syslog(LOG_ERR, "dbus: failed to register object path");
                 return -1;
         }
+        dbus_connection_add_filter(connection, dhcpcd_dbus_filter, NULL, NULL);
+        dbus_bus_add_match(connection, service_watch_rule, &err);
+        if (dbus_error_is_set(&err)) {
+                syslog(LOG_ERR, "Cannot add rule: %s", err.message);
+                return -1;
+        }
         return 0;
 }
 
 int
 configure(struct interface *ifp)
 {
         if (ifp->state->new != NULL) {
                 /* push state over d-bus */
                 dhcpcd_dbus_configure(ifp, ifp->state->reason);
 
                 if (write_lease(ifp, ifp->state->new) == -1)
                         syslog(LOG_ERR, "write_lease: %m");
         }
         return 0;
 }
 
 int
 run_script(const struct interface *ifp)
 {
         return 0;
 }