5 * Copyright (C) 2007-2009 Intel Corporation. All rights reserved.
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.
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.
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
32 struct connman_network {
33 struct connman_element element;
34 enum connman_network_type type;
35 enum connman_network_protocol protocol;
36 connman_bool_t connected;
37 connman_uint8_t strength;
42 struct connman_network_driver *driver;
45 struct connman_device *device;
56 static DBusMessage *get_properties(DBusConnection *conn,
57 DBusMessage *msg, void *data)
59 struct connman_network *network = data;
61 DBusMessageIter array, dict;
65 reply = dbus_message_new_method_return(msg);
69 dbus_message_iter_init_append(reply, &array);
71 dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
72 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
73 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
74 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
76 if (network->name != NULL)
77 connman_dbus_dict_append_variant(&dict, "Name",
78 DBUS_TYPE_STRING, &network->name);
80 connman_dbus_dict_append_variant(&dict, "Connected",
81 DBUS_TYPE_BOOLEAN, &network->connected);
83 if (network->strength > 0)
84 connman_dbus_dict_append_variant(&dict, "Strength",
85 DBUS_TYPE_BYTE, &network->strength);
87 if (network->wifi.ssid != NULL && network->wifi.ssid_len > 0)
88 connman_dbus_dict_append_array(&dict, "WiFi.SSID",
89 DBUS_TYPE_BYTE, &network->wifi.ssid,
90 network->wifi.ssid_len);
92 if (network->wifi.mode != NULL)
93 connman_dbus_dict_append_variant(&dict, "WiFi.Mode",
94 DBUS_TYPE_STRING, &network->wifi.mode);
96 if (network->wifi.security != NULL)
97 connman_dbus_dict_append_variant(&dict, "WiFi.Security",
98 DBUS_TYPE_STRING, &network->wifi.security);
100 if (network->wifi.passphrase != NULL)
101 connman_dbus_dict_append_variant(&dict, "WiFi.Passphrase",
102 DBUS_TYPE_STRING, &network->wifi.passphrase);
104 dbus_message_iter_close_container(&array, &dict);
109 static DBusMessage *set_property(DBusConnection *conn,
110 DBusMessage *msg, void *data)
112 DBusMessageIter iter, value;
115 DBG("conn %p", conn);
117 if (dbus_message_iter_init(msg, &iter) == FALSE)
118 return __connman_error_invalid_arguments(msg);
120 dbus_message_iter_get_basic(&iter, &name);
121 dbus_message_iter_next(&iter);
122 dbus_message_iter_recurse(&iter, &value);
124 if (__connman_security_check_privileges(msg) < 0)
125 return __connman_error_permission_denied(msg);
127 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
130 static DBusMessage *do_connect(DBusConnection *conn,
131 DBusMessage *msg, void *data)
133 struct connman_network *network = data;
136 DBG("conn %p", conn);
138 if (network->driver && network->driver->connect) {
139 err = network->driver->connect(network);
140 if (err < 0 && err != -EINPROGRESS)
141 return __connman_error_failed(msg);
144 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
147 static DBusMessage *do_disconnect(DBusConnection *conn,
148 DBusMessage *msg, void *data)
150 struct connman_network *network = data;
153 DBG("conn %p", conn);
155 if (network->driver && network->driver->disconnect) {
156 err = network->driver->disconnect(network);
157 if (err < 0 && err != -EINPROGRESS)
158 return __connman_error_failed(msg);
161 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
164 static GDBusMethodTable network_methods[] = {
165 { "GetProperties", "", "a{sv}", get_properties },
166 { "SetProperty", "sv", "", set_property },
167 { "Connect", "", "", do_connect },
168 { "Disconnect", "", "", do_disconnect },
172 static GDBusSignalTable network_signals[] = {
173 { "PropertyChanged", "sv" },
177 static DBusConnection *connection;
179 static void emit_networks_signal(void)
183 static int register_interface(struct connman_element *element)
185 struct connman_network *network = element->network;
187 DBG("element %p name %s", element, element->name);
189 if (g_dbus_register_interface(connection, element->path,
190 CONNMAN_NETWORK_INTERFACE,
191 network_methods, network_signals,
192 NULL, network, NULL) == FALSE) {
193 connman_error("Failed to register %s network", element->path);
197 emit_networks_signal();
202 static void unregister_interface(struct connman_element *element)
204 DBG("element %p name %s", element, element->name);
206 emit_networks_signal();
208 g_dbus_unregister_interface(connection, element->path,
209 CONNMAN_NETWORK_INTERFACE);
212 static GSList *driver_list = NULL;
214 static gint compare_priority(gconstpointer a, gconstpointer b)
216 const struct connman_network_driver *driver1 = a;
217 const struct connman_network_driver *driver2 = b;
219 return driver2->priority - driver1->priority;
223 * connman_network_driver_register:
224 * @driver: network driver definition
226 * Register a new network driver
228 * Returns: %0 on success
230 int connman_network_driver_register(struct connman_network_driver *driver)
232 DBG("driver %p name %s", driver, driver->name);
234 driver_list = g_slist_insert_sorted(driver_list, driver,
241 * connman_network_driver_unregister:
242 * @driver: network driver definition
244 * Remove a previously registered network driver
246 void connman_network_driver_unregister(struct connman_network_driver *driver)
248 DBG("driver %p name %s", driver, driver->name);
250 driver_list = g_slist_remove(driver_list, driver);
253 static void network_destruct(struct connman_element *element)
255 struct connman_network *network = element->network;
257 DBG("element %p name %s", element, element->name);
259 g_free(network->wifi.ssid);
260 g_free(network->wifi.mode);
261 g_free(network->wifi.security);
262 g_free(network->wifi.passphrase);
264 g_free(network->path);
265 g_free(network->name);
266 g_free(network->identifier);
270 * connman_network_create:
271 * @identifier: network identifier (for example an unqiue name)
273 * Allocate a new network and assign the #identifier to it.
275 * Returns: a newly-allocated #connman_network structure
277 struct connman_network *connman_network_create(const char *identifier,
278 enum connman_network_type type)
280 struct connman_network *network;
282 DBG("identifier %s type %d", identifier, type);
284 network = g_try_new0(struct connman_network, 1);
288 DBG("network %p", network);
290 network->element.refcount = 1;
292 network->element.name = g_strdup(identifier);
293 network->element.type = CONNMAN_ELEMENT_TYPE_NETWORK;
294 network->element.index = -1;
297 case CONNMAN_NETWORK_TYPE_UNKNOWN:
298 case CONNMAN_NETWORK_TYPE_VENDOR:
299 network->element.subtype = CONNMAN_ELEMENT_SUBTYPE_UNKNOWN;
301 case CONNMAN_NETWORK_TYPE_WIFI:
302 network->element.subtype = CONNMAN_ELEMENT_SUBTYPE_WIFI;
304 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
305 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
306 network->element.subtype = CONNMAN_ELEMENT_SUBTYPE_BLUETOOTH;
308 case CONNMAN_NETWORK_TYPE_HSO:
309 network->element.subtype = CONNMAN_ELEMENT_SUBTYPE_CELLULAR;
313 network->element.network = network;
314 network->element.destruct = network_destruct;
316 network->type = type;
317 network->identifier = g_strdup(identifier);
323 * connman_network_ref:
324 * @network: network structure
326 * Increase reference counter of network
328 struct connman_network *connman_network_ref(struct connman_network *network)
330 if (connman_element_ref(&network->element) == NULL)
337 * connman_network_unref:
338 * @network: network structure
340 * Decrease reference counter of network
342 void connman_network_unref(struct connman_network *network)
344 connman_element_unref(&network->element);
348 * connman_network_get_identifier:
349 * @network: network structure
351 * Get identifier of network
353 const char *connman_network_get_identifier(struct connman_network *network)
355 return network->identifier;
359 * connman_network_set_path:
360 * @network: network structure
363 * Set path name of network
365 void connman_network_set_path(struct connman_network *network, const char *path)
367 g_free(network->element.devpath);
368 network->element.devpath = g_strdup(path);
370 g_free(network->path);
371 network->path = g_strdup(path);
375 * connman_network_get_path:
376 * @network: network structure
378 * Get path name of network
380 const char *connman_network_get_path(struct connman_network *network)
382 return network->path;
386 * connman_network_set_index:
387 * @network: network structure
388 * @index: index number
390 * Set index number of network
392 void connman_network_set_index(struct connman_network *network, int index)
394 network->element.index = index;
398 * connman_network_get_index:
399 * @network: network structure
401 * Get index number of network
403 int connman_network_get_index(struct connman_network *network)
405 return network->element.index;
409 * connman_network_set_protocol:
410 * @network: network structure
411 * @protocol: network protocol
413 * Change protocol of network
415 void connman_network_set_protocol(struct connman_network *network,
416 enum connman_network_protocol protocol)
418 network->protocol = protocol;
422 * connman_network_set_connected:
423 * @network: network structure
424 * @connected: connected state
426 * Change connected state of network
428 int connman_network_set_connected(struct connman_network *network,
429 connman_bool_t connected)
431 DBG("network %p connected %d", network, connected);
433 if (network->connected == connected)
436 network->connected = connected;
438 if (connected == TRUE) {
439 struct connman_element *element;
440 enum connman_element_type type = CONNMAN_ELEMENT_TYPE_UNKNOWN;
442 switch (network->protocol) {
443 case CONNMAN_NETWORK_PROTOCOL_UNKNOWN:
445 case CONNMAN_NETWORK_PROTOCOL_IP:
446 type = CONNMAN_ELEMENT_TYPE_DHCP;
448 case CONNMAN_NETWORK_PROTOCOL_PPP:
449 type = CONNMAN_ELEMENT_TYPE_PPP;
453 element = connman_element_create(NULL);
454 if (element != NULL) {
455 element->type = type;
456 element->subtype = network->element.subtype;
457 element->index = network->element.index;
459 if (connman_element_register(element,
460 &network->element) < 0)
461 connman_element_unref(element);
464 connman_element_unregister_children(&network->element);
470 * connman_network_set_string:
471 * @network: network structure
472 * @key: unique identifier
473 * @value: string value
475 * Set string value for specific key
477 int connman_network_set_string(struct connman_network *network,
478 const char *key, const char *value)
480 DBG("network %p key %s value %s", network, key, value);
482 if (g_str_equal(key, "Name") == TRUE) {
483 g_free(network->name);
484 network->name = g_strdup(value);
485 } else if (g_str_equal(key, "WiFi.Mode") == TRUE) {
486 g_free(network->wifi.mode);
487 network->wifi.mode = g_strdup(value);
488 } else if (g_str_equal(key, "WiFi.Security") == TRUE) {
489 g_free(network->wifi.security);
490 network->wifi.security = g_strdup(value);
497 * connman_network_set_uint8:
498 * @network: network structure
499 * @key: unique identifier
500 * @value: integer value
502 * Set integer value for specific key
504 int connman_network_set_uint8(struct connman_network *network,
505 const char *key, connman_uint8_t value)
507 DBG("network %p key %s value %d", network, key, value);
509 if (g_str_equal(key, "Strength") == TRUE)
510 network->strength = value;
516 * connman_network_set_blob:
517 * @network: network structure
518 * @key: unique identifier
522 * Set binary blob value for specific key
524 int connman_network_set_blob(struct connman_network *network,
525 const char *key, const void *data, unsigned int size)
527 DBG("network %p key %s size %d", network, key, size);
529 if (g_str_equal(key, "WiFi.SSID") == TRUE) {
530 g_free(network->wifi.ssid);
531 network->wifi.ssid = g_try_malloc(size);
532 if (network->wifi.ssid != NULL) {
533 memcpy(network->wifi.ssid, data, size);
534 network->wifi.ssid_len = size;
536 network->wifi.ssid_len = 0;
542 void __connman_network_set_device(struct connman_network *network,
543 struct connman_device *device)
545 network->device = device;
549 * connman_network_get_device:
550 * @network: network structure
552 * Get parent device of network
554 struct connman_device *connman_network_get_device(struct connman_network *network)
556 return network->device;
560 * connman_network_get_data:
561 * @network: network structure
563 * Get private network data pointer
565 void *connman_network_get_data(struct connman_network *network)
567 return network->driver_data;
571 * connman_network_set_data:
572 * @network: network structure
573 * @data: data pointer
575 * Set private network data pointer
577 void connman_network_set_data(struct connman_network *network, void *data)
579 network->driver_data = data;
582 static gboolean match_driver(struct connman_network *network,
583 struct connman_network_driver *driver)
585 if (network->type == driver->type ||
586 driver->type == CONNMAN_NETWORK_TYPE_UNKNOWN)
592 static int network_probe(struct connman_element *element)
594 struct connman_network *network = element->network;
598 DBG("element %p name %s", element, element->name);
603 for (list = driver_list; list; list = list->next) {
604 struct connman_network_driver *driver = list->data;
606 if (match_driver(network, driver) == FALSE)
609 DBG("driver %p name %s", driver, driver->name);
611 if (driver->probe(network) == 0) {
612 network->driver = driver;
617 if (network->driver == NULL)
620 err = register_interface(element);
622 if (network->driver->remove)
623 network->driver->remove(network);
630 static void network_remove(struct connman_element *element)
632 struct connman_network *network = element->network;
634 DBG("element %p name %s", element, element->name);
639 if (network->driver == NULL)
642 unregister_interface(element);
644 if (network->driver->remove)
645 network->driver->remove(network);
648 static struct connman_driver network_driver = {
650 .type = CONNMAN_ELEMENT_TYPE_NETWORK,
651 .priority = CONNMAN_DRIVER_PRIORITY_LOW,
652 .probe = network_probe,
653 .remove = network_remove,
656 static int network_load(struct connman_network *network)
658 DBG("network %p", network);
663 static int network_save(struct connman_network *network)
665 DBG("network %p", network);
670 static struct connman_storage network_storage = {
672 .priority = CONNMAN_STORAGE_PRIORITY_LOW,
673 .network_load = network_load,
674 .network_save = network_save,
677 int __connman_network_init(void)
681 connection = connman_dbus_get_connection();
683 if (connman_storage_register(&network_storage) < 0)
684 connman_error("Failed to register network storage");
686 return connman_driver_register(&network_driver);
689 void __connman_network_cleanup(void)
693 connman_driver_unregister(&network_driver);
695 connman_storage_unregister(&network_storage);
697 dbus_connection_unref(connection);