Register default device and network storage drivers

[connman] / src / network.c

diff --git a/src/network.c b/src/network.c
index 47c203f..e5353f5 100644 (file)
--- a/src/network.c
+++ b/src/network.c
@@ -2,7 +2,7 @@
  *
  *  Connection Manager
  *
- *  Copyright (C) 2007-2008  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2007-2009  Intel Corporation. All rights reserved.
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2 as
@@ -30,6 +30,8 @@
 struct connman_network {
        struct connman_element element;
        enum connman_network_type type;
+       enum connman_network_protocol protocol;
+       gboolean connected;
        char *identifier;
        char *path;
 
@@ -42,6 +44,7 @@ struct connman_network {
 static DBusMessage *get_properties(DBusConnection *conn,
                                        DBusMessage *msg, void *data)
 {
+       struct connman_network *network = data;
        DBusMessage *reply;
        DBusMessageIter array, dict;
 
@@ -58,6 +61,13 @@ static DBusMessage *get_properties(DBusConnection *conn,
                        DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
                        DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
 
+       if (network->identifier != NULL)
+               connman_dbus_dict_append_variant(&dict, "Name",
+                               DBUS_TYPE_STRING, &network->identifier);
+
+       connman_dbus_dict_append_variant(&dict, "Connected",
+                               DBUS_TYPE_BOOLEAN, &network->connected);
+
        dbus_message_iter_close_container(&array, &dict);
 
        return reply;
@@ -87,16 +97,34 @@ static DBusMessage *set_property(DBusConnection *conn,
 static DBusMessage *do_connect(DBusConnection *conn,
                                        DBusMessage *msg, void *data)
 {
+       struct connman_network *network = data;
+       int err;
+
        DBG("conn %p", conn);
 
+       if (network->driver && network->driver->connect) {
+               err = network->driver->connect(network);
+               if (err < 0 && err != -EINPROGRESS)
+                       return __connman_error_failed(msg);
+       }
+
        return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 }
 
 static DBusMessage *do_disconnect(DBusConnection *conn,
                                        DBusMessage *msg, void *data)
 {
+       struct connman_network *network = data;
+       int err;
+
        DBG("conn %p", conn);
 
+       if (network->driver && network->driver->disconnect) {
+               err = network->driver->disconnect(network);
+               if (err < 0 && err != -EINPROGRESS)
+                       return __connman_error_failed(msg);
+       }
+
        return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 }
 
@@ -123,6 +151,8 @@ static int register_interface(struct connman_element *element)
 {
        struct connman_network *network = element->network;
 
+       DBG("element %p name %s", element, element->name);
+
        g_dbus_unregister_interface(connection, element->path,
                                                CONNMAN_NETWORK_INTERFACE);
 
@@ -141,6 +171,8 @@ static int register_interface(struct connman_element *element)
 
 static void unregister_interface(struct connman_element *element)
 {
+       DBG("element %p name %s", element, element->name);
+
        emit_networks_signal();
 
        g_dbus_unregister_interface(connection, element->path,
@@ -225,6 +257,23 @@ struct connman_network *connman_network_create(const char *identifier,
        network->element.type = CONNMAN_ELEMENT_TYPE_NETWORK;
        network->element.index = -1;
 
+       switch (type) {
+       case CONNMAN_NETWORK_TYPE_UNKNOWN:
+       case CONNMAN_NETWORK_TYPE_VENDOR:
+               network->element.subtype = CONNMAN_ELEMENT_SUBTYPE_UNKNOWN;
+               break;
+       case CONNMAN_NETWORK_TYPE_WIFI:
+               network->element.subtype = CONNMAN_ELEMENT_SUBTYPE_WIFI;
+               break;
+       case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
+       case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
+               network->element.subtype = CONNMAN_ELEMENT_SUBTYPE_BLUETOOTH;
+               break;
+       case CONNMAN_NETWORK_TYPE_HSO:
+               network->element.subtype = CONNMAN_ELEMENT_SUBTYPE_CELLULAR;
+               break;
+       }
+
        network->element.network = network;
        network->element.destruct = network_destruct;
 
@@ -297,6 +346,90 @@ const char *connman_network_get_path(struct connman_network *network)
        return network->path;
 }
 
+/**
+ * connman_network_set_index:
+ * @network: network structure
+ * @index: index number
+ *
+ * Set index number of network
+ */
+void connman_network_set_index(struct connman_network *network, int index)
+{
+       network->element.index = index;
+}
+
+/**
+ * connman_network_get_index:
+ * @network: network structure
+ *
+ * Get index number of network
+ */
+int connman_network_get_index(struct connman_network *network)
+{
+       return network->element.index;
+}
+
+/**
+ * connman_network_set_protocol:
+ * @network: network structure
+ * @protocol: network protocol
+ *
+ * Change protocol of network
+ */
+void connman_network_set_protocol(struct connman_network *network,
+                                       enum connman_network_protocol protocol)
+{
+       network->protocol = protocol;
+}
+
+/**
+ * connman_network_set_connected:
+ * @network: network structure
+ * @connected: connected state
+ *
+ * Change connected state of network
+ */
+int connman_network_set_connected(struct connman_network *network,
+                                               connman_bool_t connected)
+{
+       DBG("network %p connected %d", network, connected);
+
+       if (network->connected == connected)
+               return -EALREADY;
+
+       network->connected = connected;
+
+       if (connected == TRUE) {
+               struct connman_element *element;
+               enum connman_element_type type = CONNMAN_ELEMENT_TYPE_UNKNOWN;
+
+               switch (network->protocol) {
+               case CONNMAN_NETWORK_PROTOCOL_UNKNOWN:
+                       return 0;
+               case CONNMAN_NETWORK_PROTOCOL_IP:
+                       type = CONNMAN_ELEMENT_TYPE_DHCP;
+                       break;
+               case CONNMAN_NETWORK_PROTOCOL_PPP:
+                       type = CONNMAN_ELEMENT_TYPE_PPP;
+                       break;
+               }
+
+               element = connman_element_create(NULL);
+               if (element != NULL) {
+                       element->type    = type;
+                       element->subtype = network->element.subtype;
+                       element->index   = network->element.index;
+
+                       if (connman_element_register(element,
+                                                       &network->element) < 0)
+                               connman_element_unref(element);
+               }
+       } else
+               connman_element_unregister_children(&network->element);
+
+       return 0;
+}
+
 void __connman_network_set_device(struct connman_network *network,
                                        struct connman_device *device)
 {
@@ -372,7 +505,7 @@ static int network_probe(struct connman_element *element)
                }
        }
 
-       if (!network->driver)
+       if (network->driver == NULL)
                return -ENODEV;
 
        err = register_interface(element);
@@ -394,7 +527,7 @@ static void network_remove(struct connman_element *element)
        if (network == NULL)
                return;
 
-       if (!network->driver)
+       if (network->driver == NULL)
                return;
 
        unregister_interface(element);
@@ -411,12 +544,20 @@ static struct connman_driver network_driver = {
        .remove         = network_remove,
 };
 
+static struct connman_storage network_storage = {
+       .name           = "network",
+       .priority       = CONNMAN_STORAGE_PRIORITY_LOW,
+};
+
 int __connman_network_init(void)
 {
        DBG("");
 
        connection = connman_dbus_get_connection();
 
+       if (connman_storage_register(&network_storage) < 0)
+               connman_error("Failed to register network storage");
+
        return connman_driver_register(&network_driver);
 }
 
@@ -426,5 +567,7 @@ void __connman_network_cleanup(void)
 
        connman_driver_unregister(&network_driver);
 
+       connman_storage_unregister(&network_storage);
+
        dbus_connection_unref(connection);
 }