vcs.maemo.org Git - connman/blob - src/network.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2008  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2 as
   9  *  published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include "connman.h"
  27
  28 struct connman_network {
  29         struct connman_element element;
  30         enum connman_network_type type;
  31         char *identifier;
  32
  33         struct connman_network_driver *driver;
  34         void *driver_data;
  35 };
  36
  37 static GSList *driver_list = NULL;
  38
  39 static gint compare_priority(gconstpointer a, gconstpointer b)
  40 {
  41         const struct connman_network_driver *driver1 = a;
  42         const struct connman_network_driver *driver2 = b;
  43
  44         return driver2->priority - driver1->priority;
  45 }
  46
  47 /**
  48  * connman_network_driver_register:
  49  * @driver: network driver definition
  50  *
  51  * Register a new network driver
  52  *
  53  * Returns: %0 on success
  54  */
  55 int connman_network_driver_register(struct connman_network_driver *driver)
  56 {
  57         DBG("driver %p name %s", driver, driver->name);
  58
  59         driver_list = g_slist_insert_sorted(driver_list, driver,
  60                                                         compare_priority);
  61
  62         return 0;
  63 }
  64
  65 /**
  66  * connman_network_driver_unregister:
  67  * @driver: network driver definition
  68  *
  69  * Remove a previously registered network driver
  70  */
  71 void connman_network_driver_unregister(struct connman_network_driver *driver)
  72 {
  73         DBG("driver %p name %s", driver, driver->name);
  74
  75         driver_list = g_slist_remove(driver_list, driver);
  76 }
  77
  78 static void network_destruct(struct connman_element *element)
  79 {
  80         struct connman_network *network = element->network;
  81
  82         DBG("element %p name %s", element, element->name);
  83
  84         g_free(network->identifier);
  85 }
  86
  87 /**
  88  * connman_network_create:
  89  * @identifier: network identifier (for example an unqiue name)
  90  *
  91  * Allocate a new network and assign the #identifier to it.
  92  *
  93  * Returns: a newly-allocated #connman_network structure
  94  */
  95 struct connman_network *connman_network_create(const char *identifier,
  96                                                 enum connman_network_type type)
  97 {
  98         struct connman_network *network;
  99
 100         DBG("identifier %s type %d", identifier, type);
 101
 102         network = g_try_new0(struct connman_network, 1);
 103         if (network == NULL)
 104                 return NULL;
 105
 106         DBG("network %p", network);
 107
 108         network->element.refcount = 1;
 109
 110         network->element.name = g_strdup(identifier);
 111         network->element.type = CONNMAN_ELEMENT_TYPE_NETWORK;
 112         network->element.index = -1;
 113
 114         network->element.network = network;
 115         network->element.destruct = network_destruct;
 116
 117         network->type = type;
 118         network->identifier = g_strdup(identifier);
 119
 120         return network;
 121 }
 122
 123 /**
 124  * connman_network_ref:
 125  * @network: network structure
 126  *
 127  * Increase reference counter of  network
 128  */
 129 struct connman_network *connman_network_ref(struct connman_network *network)
 130 {
 131         if (connman_element_ref(&network->element) == NULL)
 132                 return NULL;
 133
 134         return network;
 135 }
 136
 137 /**
 138  * connman_network_unref:
 139  * @network: network structure
 140  *
 141  * Decrease reference counter of network
 142  */
 143 void connman_network_unref(struct connman_network *network)
 144 {
 145         connman_element_unref(&network->element);
 146 }
 147
 148 /**
 149  * connman_network_get_identifier:
 150  * @network: network structure
 151  *
 152  * Get identifier of network
 153  */
 154 const char *connman_network_get_identifier(struct connman_network *network)
 155 {
 156         return network->identifier;
 157 }
 158
 159 /**
 160  * connman_network_get_data:
 161  * @network: network structure
 162  *
 163  * Get private network data pointer
 164  */
 165 void *connman_network_get_data(struct connman_network *network)
 166 {
 167         return network->driver_data;
 168 }
 169
 170 /**
 171  * connman_network_set_data:
 172  * @network: network structure
 173  * @data: data pointer
 174  *
 175  * Set private network data pointer
 176  */
 177 void connman_network_set_data(struct connman_network *network, void *data)
 178 {
 179         network->driver_data = data;
 180 }
 181
 182 static gboolean match_driver(struct connman_network *network,
 183                                         struct connman_network_driver *driver)
 184 {
 185         if (network->type == driver->type ||
 186                         driver->type == CONNMAN_NETWORK_TYPE_UNKNOWN)
 187                 return TRUE;
 188
 189         return FALSE;
 190 }
 191
 192 static int network_probe(struct connman_element *element)
 193 {
 194         struct connman_network *network = element->network;
 195         GSList *list;
 196
 197         DBG("element %p name %s", element, element->name);
 198
 199         if (network == NULL)
 200                 return -ENODEV;
 201
 202         for (list = driver_list; list; list = list->next) {
 203                 struct connman_network_driver *driver = list->data;
 204
 205                 if (match_driver(network, driver) == FALSE)
 206                         continue;
 207
 208                 DBG("driver %p name %s", driver, driver->name);
 209
 210                 if (driver->probe(network) == 0) {
 211                         network->driver = driver;
 212                         break;
 213                 }
 214         }
 215
 216         if (!network->driver)
 217                 return -ENODEV;
 218
 219         return 0;
 220 }
 221
 222 static void network_remove(struct connman_element *element)
 223 {
 224         struct connman_network *network = element->network;
 225
 226         DBG("element %p name %s", element, element->name);
 227
 228         if (network == NULL)
 229                 return;
 230
 231         if (!network->driver)
 232                 return;
 233
 234         if (network->driver->remove)
 235                 network->driver->remove(network);
 236 }
 237
 238 static struct connman_driver network_driver = {
 239         .name           = "network",
 240         .type           = CONNMAN_ELEMENT_TYPE_NETWORK,
 241         .priority       = CONNMAN_DRIVER_PRIORITY_LOW,
 242         .probe          = network_probe,
 243         .remove         = network_remove,
 244 };
 245
 246 int __connman_network_init(void)
 247 {
 248         DBG("");
 249
 250         return connman_driver_register(&network_driver);
 251 }
 252
 253 void __connman_network_cleanup(void)
 254 {
 255         DBG("");
 256
 257         connman_driver_unregister(&network_driver);
 258 }