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 static DBusConnection *connection = NULL;
34 static GSequence *service_list = NULL;
35 static GHashTable *service_hash = NULL;
37 struct connman_service {
41 enum connman_service_type type;
42 enum connman_service_mode mode;
43 enum connman_service_security security;
44 enum connman_service_state state;
45 enum connman_service_error error;
46 connman_uint8_t strength;
47 connman_bool_t favorite;
48 connman_bool_t hidden;
49 connman_bool_t ignore;
55 struct connman_ipconfig *ipconfig;
56 struct connman_device *device;
57 struct connman_network *network;
62 static void append_path(gpointer value, gpointer user_data)
64 struct connman_service *service = value;
65 DBusMessageIter *iter = user_data;
67 if (service->path == NULL)
70 dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
74 void __connman_service_list(DBusMessageIter *iter)
78 g_sequence_foreach(service_list, append_path, iter);
83 struct connman_service *service;
86 static void compare_path(gpointer value, gpointer user_data)
88 struct connman_service *service = value;
89 struct find_data *data = user_data;
91 if (data->service != NULL)
94 if (g_strcmp0(service->path, data->path) == 0)
95 data->service = service;
98 static struct connman_service *find_service(const char *path)
100 struct find_data data = { .path = path, .service = NULL };
102 DBG("path %s", path);
104 g_sequence_foreach(service_list, compare_path, &data);
109 static const char *type2string(enum connman_service_type type)
112 case CONNMAN_SERVICE_TYPE_UNKNOWN:
114 case CONNMAN_SERVICE_TYPE_ETHERNET:
116 case CONNMAN_SERVICE_TYPE_WIFI:
118 case CONNMAN_SERVICE_TYPE_WIMAX:
120 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
122 case CONNMAN_SERVICE_TYPE_CELLULAR:
129 static const char *mode2string(enum connman_service_mode mode)
132 case CONNMAN_SERVICE_MODE_UNKNOWN:
134 case CONNMAN_SERVICE_MODE_MANAGED:
136 case CONNMAN_SERVICE_MODE_ADHOC:
143 static const char *security2string(enum connman_service_security security)
146 case CONNMAN_SERVICE_SECURITY_UNKNOWN:
148 case CONNMAN_SERVICE_SECURITY_NONE:
150 case CONNMAN_SERVICE_SECURITY_WEP:
152 case CONNMAN_SERVICE_SECURITY_WPA:
154 case CONNMAN_SERVICE_SECURITY_RSN:
161 static const char *state2string(enum connman_service_state state)
164 case CONNMAN_SERVICE_STATE_UNKNOWN:
166 case CONNMAN_SERVICE_STATE_IDLE:
168 case CONNMAN_SERVICE_STATE_CARRIER:
170 case CONNMAN_SERVICE_STATE_ASSOCIATION:
171 return "association";
172 case CONNMAN_SERVICE_STATE_CONFIGURATION:
173 return "configuration";
174 case CONNMAN_SERVICE_STATE_READY:
176 case CONNMAN_SERVICE_STATE_DISCONNECT:
178 case CONNMAN_SERVICE_STATE_FAILURE:
185 static const char *error2string(enum connman_service_error error)
188 case CONNMAN_SERVICE_ERROR_UNKNOWN:
190 case CONNMAN_SERVICE_ERROR_DHCP_FAILED:
191 return "dhcp-failed";
192 case CONNMAN_SERVICE_ERROR_PIN_MISSING:
193 return "pin-missing";
199 static enum connman_service_error string2error(const char *error)
201 if (g_strcmp0(error, "dhcp-failed") == 0)
202 return CONNMAN_SERVICE_ERROR_DHCP_FAILED;
203 else if (g_strcmp0(error, "pin-missing") == 0)
204 return CONNMAN_SERVICE_ERROR_PIN_MISSING;
206 return CONNMAN_SERVICE_ERROR_UNKNOWN;
209 static void state_changed(struct connman_service *service)
212 DBusMessageIter entry, value;
213 const char *str, *key = "State";
215 if (service->path == NULL)
218 str = state2string(service->state);
222 signal = dbus_message_new_signal(service->path,
223 CONNMAN_SERVICE_INTERFACE, "PropertyChanged");
227 dbus_message_iter_init_append(signal, &entry);
229 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
231 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
232 DBUS_TYPE_STRING_AS_STRING, &value);
233 dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &str);
234 dbus_message_iter_close_container(&entry, &value);
236 g_dbus_send_message(connection, signal);
239 static void strength_changed(struct connman_service *service)
242 DBusMessageIter entry, value;
243 const char *key = "Strength";
245 if (service->path == NULL)
248 if (service->strength == 0)
251 signal = dbus_message_new_signal(service->path,
252 CONNMAN_SERVICE_INTERFACE, "PropertyChanged");
256 dbus_message_iter_init_append(signal, &entry);
258 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
260 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
261 DBUS_TYPE_BYTE_AS_STRING, &value);
262 dbus_message_iter_append_basic(&value, DBUS_TYPE_BYTE,
264 dbus_message_iter_close_container(&entry, &value);
266 g_dbus_send_message(connection, signal);
269 static DBusMessage *get_properties(DBusConnection *conn,
270 DBusMessage *msg, void *user_data)
272 struct connman_service *service = user_data;
274 DBusMessageIter array, dict;
277 DBG("service %p", service);
279 reply = dbus_message_new_method_return(msg);
283 dbus_message_iter_init_append(reply, &array);
285 dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
286 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
287 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
288 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
290 str = type2string(service->type);
292 connman_dbus_dict_append_variant(&dict, "Type",
293 DBUS_TYPE_STRING, &str);
295 str = mode2string(service->mode);
297 connman_dbus_dict_append_variant(&dict, "Mode",
298 DBUS_TYPE_STRING, &str);
300 str = security2string(service->security);
302 connman_dbus_dict_append_variant(&dict, "Security",
303 DBUS_TYPE_STRING, &str);
305 str = state2string(service->state);
307 connman_dbus_dict_append_variant(&dict, "State",
308 DBUS_TYPE_STRING, &str);
310 str = error2string(service->error);
312 connman_dbus_dict_append_variant(&dict, "Error",
313 DBUS_TYPE_STRING, &str);
315 if (service->strength > 0)
316 connman_dbus_dict_append_variant(&dict, "Strength",
317 DBUS_TYPE_BYTE, &service->strength);
319 connman_dbus_dict_append_variant(&dict, "Favorite",
320 DBUS_TYPE_BOOLEAN, &service->favorite);
322 if (service->name != NULL)
323 connman_dbus_dict_append_variant(&dict, "Name",
324 DBUS_TYPE_STRING, &service->name);
326 if (service->passphrase != NULL &&
327 __connman_security_check_privilege(msg,
328 CONNMAN_SECURITY_PRIVILEGE_SECRET) == 0)
329 connman_dbus_dict_append_variant(&dict, "Passphrase",
330 DBUS_TYPE_STRING, &service->passphrase);
332 __connman_ipconfig_append_ipv4(service->ipconfig, &dict, "IPv4.");
334 dbus_message_iter_close_container(&array, &dict);
339 static DBusMessage *set_property(DBusConnection *conn,
340 DBusMessage *msg, void *user_data)
342 struct connman_service *service = user_data;
343 DBusMessageIter iter, value;
347 DBG("service %p", service);
349 if (dbus_message_iter_init(msg, &iter) == FALSE)
350 return __connman_error_invalid_arguments(msg);
352 dbus_message_iter_get_basic(&iter, &name);
353 dbus_message_iter_next(&iter);
354 dbus_message_iter_recurse(&iter, &value);
356 if (__connman_security_check_privilege(msg,
357 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
358 return __connman_error_permission_denied(msg);
360 type = dbus_message_iter_get_arg_type(&value);
362 if (g_str_equal(name, "Passphrase") == TRUE) {
363 const char *passphrase;
365 if (type != DBUS_TYPE_STRING)
366 return __connman_error_invalid_arguments(msg);
368 if (__connman_security_check_privilege(msg,
369 CONNMAN_SECURITY_PRIVILEGE_SECRET) < 0)
370 return __connman_error_permission_denied(msg);
372 dbus_message_iter_get_basic(&value, &passphrase);
374 g_free(service->passphrase);
375 service->passphrase = g_strdup(passphrase);
377 if (service->network != NULL)
378 connman_network_set_string(service->network,
379 "WiFi.Passphrase", service->passphrase);
381 __connman_storage_save_service(service);
382 } else if (g_str_has_prefix(name, "IPv4.") == TRUE) {
385 err = __connman_ipconfig_set_ipv4(service->ipconfig,
388 return __connman_error_failed(msg, -err);
390 return __connman_error_invalid_property(msg);
392 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
395 static DBusMessage *clear_property(DBusConnection *conn,
396 DBusMessage *msg, void *user_data)
398 struct connman_service *service = user_data;
401 DBG("service %p", service);
403 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name,
406 if (__connman_security_check_privilege(msg,
407 CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
408 return __connman_error_permission_denied(msg);
410 if (g_str_equal(name, "Error") == TRUE) {
411 service->state = CONNMAN_SERVICE_STATE_IDLE;
412 service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
413 state_changed(service);
415 g_get_current_time(&service->modified);
416 __connman_storage_save_service(service);
418 return __connman_error_invalid_property(msg);
420 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
423 static connman_bool_t is_connecting(struct connman_service *service)
425 switch (service->state) {
426 case CONNMAN_SERVICE_STATE_UNKNOWN:
427 case CONNMAN_SERVICE_STATE_IDLE:
428 case CONNMAN_SERVICE_STATE_CARRIER:
429 case CONNMAN_SERVICE_STATE_FAILURE:
430 case CONNMAN_SERVICE_STATE_DISCONNECT:
431 case CONNMAN_SERVICE_STATE_READY:
433 case CONNMAN_SERVICE_STATE_ASSOCIATION:
434 case CONNMAN_SERVICE_STATE_CONFIGURATION:
441 static struct connman_service *find_pending_service(void)
443 struct connman_service *service;
446 iter = g_sequence_get_begin_iter(service_list);
448 while (g_sequence_iter_is_end(iter) == FALSE) {
449 service = g_sequence_get(iter);
450 if (service->pending != NULL)
453 iter = g_sequence_iter_next(iter);
459 static connman_bool_t is_ignore(struct connman_service *service)
461 if (service->ignore == TRUE)
464 if (service->state == CONNMAN_SERVICE_STATE_FAILURE)
470 static void __connman_service_auto_connect(void)
472 struct connman_service *service;
477 service = find_pending_service();
481 iter = g_sequence_get_begin_iter(service_list);
482 if (g_sequence_iter_is_end(iter) == TRUE)
485 service = g_sequence_get(iter);
487 while (is_ignore(service) == TRUE) {
488 iter = g_sequence_iter_next(iter);
489 if (g_sequence_iter_is_end(iter))
491 service = g_sequence_get(iter);
494 if (service->favorite == FALSE)
497 if (service->state == CONNMAN_SERVICE_STATE_READY)
500 if (is_connecting(service) == TRUE)
503 if (service->state == CONNMAN_SERVICE_STATE_IDLE)
504 __connman_service_connect(service);
507 static gboolean connect_timeout(gpointer user_data)
509 struct connman_service *service = user_data;
510 connman_bool_t auto_connect = FALSE;
512 DBG("service %p", service);
514 service->timeout = 0;
516 if (service->network != NULL) {
517 connman_bool_t connected;
519 connected = connman_network_get_connected(service->network);
520 if (connected == TRUE) {
521 __connman_service_indicate_state(service,
522 CONNMAN_SERVICE_STATE_READY);
526 __connman_network_disconnect(service->network);
527 } else if (service->device != NULL) {
528 connman_bool_t disconnected;
530 disconnected = connman_device_get_disconnected(service->device);
531 if (disconnected == FALSE) {
532 __connman_service_indicate_state(service,
533 CONNMAN_SERVICE_STATE_READY);
537 __connman_device_disconnect(service->device);
540 if (service->pending != NULL) {
543 reply = __connman_error_operation_timeout(service->pending);
545 g_dbus_send_message(connection, reply);
547 dbus_message_unref(service->pending);
548 service->pending = NULL;
552 __connman_service_indicate_state(service,
553 CONNMAN_SERVICE_STATE_FAILURE);
555 if (auto_connect == TRUE)
556 __connman_service_auto_connect();
561 static DBusMessage *connect_service(DBusConnection *conn,
562 DBusMessage *msg, void *user_data)
564 struct connman_service *service = user_data;
567 DBG("service %p", service);
569 if (service->pending != NULL)
570 return __connman_error_in_progress(msg);
572 service->ignore = FALSE;
574 service->pending = dbus_message_ref(msg);
576 err = __connman_service_connect(service);
578 if (err != -EINPROGRESS) {
579 dbus_message_unref(service->pending);
580 service->pending = NULL;
582 return __connman_error_failed(msg, -err);
588 dbus_message_unref(service->pending);
589 service->pending = NULL;
591 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
594 static DBusMessage *disconnect_service(DBusConnection *conn,
595 DBusMessage *msg, void *user_data)
597 struct connman_service *service = user_data;
600 DBG("service %p", service);
602 if (service->pending != NULL) {
605 reply = __connman_error_operation_aborted(service->pending);
607 g_dbus_send_message(conn, reply);
609 dbus_message_unref(service->pending);
610 service->pending = NULL;
612 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
615 service->ignore = TRUE;
617 err = __connman_service_disconnect(service);
619 if (err != -EINPROGRESS)
620 return __connman_error_failed(msg, -err);
625 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
628 static DBusMessage *remove_service(DBusConnection *conn,
629 DBusMessage *msg, void *user_data)
631 struct connman_service *service = user_data;
633 DBG("service %p", service);
635 if (service->type == CONNMAN_SERVICE_TYPE_ETHERNET)
636 return __connman_error_not_supported(msg);
638 if (service->favorite == FALSE)
639 return __connman_error_not_supported(msg);
641 if (service->network != NULL)
642 __connman_network_disconnect(service->network);
644 g_free(service->passphrase);
645 service->passphrase = NULL;
647 connman_service_set_favorite(service, FALSE);
648 __connman_storage_save_service(service);
650 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
653 static DBusMessage *move_before(DBusConnection *conn,
654 DBusMessage *msg, void *user_data)
656 struct connman_service *service = user_data;
657 struct connman_service *target;
659 GSequenceIter *src, *dst;
661 DBG("service %p", service);
663 dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
666 if (service->favorite == FALSE)
667 return __connman_error_not_supported(msg);
669 target = find_service(path);
670 if (target == NULL || target->favorite == FALSE || target == service)
671 return __connman_error_invalid_service(msg);
673 DBG("target %s", target->identifier);
675 g_get_current_time(&service->modified);
676 __connman_storage_save_service(service);
678 src = g_hash_table_lookup(service_hash, service->identifier);
679 dst = g_hash_table_lookup(service_hash, target->identifier);
681 g_sequence_move(src, dst);
683 __connman_profile_changed();
685 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
688 static DBusMessage *move_after(DBusConnection *conn,
689 DBusMessage *msg, void *user_data)
691 struct connman_service *service = user_data;
692 struct connman_service *target;
695 DBG("service %p", service);
697 dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
700 if (service->favorite == FALSE)
701 return __connman_error_not_supported(msg);
703 target = find_service(path);
704 if (target == NULL || target->favorite == FALSE || target == service)
705 return __connman_error_invalid_service(msg);
707 DBG("target %s", target->identifier);
709 g_get_current_time(&service->modified);
710 __connman_storage_save_service(service);
712 return __connman_error_not_implemented(msg);
715 static GDBusMethodTable service_methods[] = {
716 { "GetProperties", "", "a{sv}", get_properties },
717 { "SetProperty", "sv", "", set_property },
718 { "ClearProperty", "s", "", clear_property },
719 { "Connect", "", "", connect_service,
720 G_DBUS_METHOD_FLAG_ASYNC },
721 { "Disconnect", "", "", disconnect_service },
722 { "Remove", "", "", remove_service },
723 { "MoveBefore", "o", "", move_before },
724 { "MoveAfter", "o", "", move_after },
728 static GDBusSignalTable service_signals[] = {
729 { "PropertyChanged", "sv" },
733 static void service_free(gpointer user_data)
735 struct connman_service *service = user_data;
736 char *path = service->path;
738 DBG("service %p", service);
740 g_hash_table_remove(service_hash, service->identifier);
742 if (service->timeout > 0) {
743 g_source_remove(service->timeout);
744 service->timeout = 0;
747 if (service->pending != NULL) {
748 dbus_message_unref(service->pending);
749 service->pending = NULL;
752 service->path = NULL;
755 __connman_profile_changed();
757 g_dbus_unregister_interface(connection, path,
758 CONNMAN_SERVICE_INTERFACE);
762 if (service->network != NULL)
763 connman_network_unref(service->network);
765 connman_ipconfig_unref(service->ipconfig);
767 g_free(service->profile);
768 g_free(service->name);
769 g_free(service->passphrase);
770 g_free(service->identifier);
775 * __connman_service_put:
776 * @service: service structure
778 * Release service if no longer needed
780 void __connman_service_put(struct connman_service *service)
782 DBG("service %p", service);
784 if (g_atomic_int_dec_and_test(&service->refcount) == TRUE) {
787 iter = g_hash_table_lookup(service_hash, service->identifier);
789 g_sequence_remove(iter);
791 service_free(service);
795 static void __connman_service_initialize(struct connman_service *service)
797 DBG("service %p", service);
799 service->refcount = 1;
801 service->type = CONNMAN_SERVICE_TYPE_UNKNOWN;
802 service->mode = CONNMAN_SERVICE_MODE_UNKNOWN;
803 service->security = CONNMAN_SERVICE_SECURITY_UNKNOWN;
804 service->state = CONNMAN_SERVICE_STATE_UNKNOWN;
806 service->favorite = FALSE;
807 service->hidden = FALSE;
809 service->ignore = FALSE;
815 * connman_service_create:
817 * Allocate a new service.
819 * Returns: a newly-allocated #connman_service structure
821 struct connman_service *connman_service_create(void)
823 struct connman_service *service;
825 service = g_try_new0(struct connman_service, 1);
829 DBG("service %p", service);
831 __connman_service_initialize(service);
833 service->ipconfig = connman_ipconfig_create();
834 if (service->ipconfig == NULL) {
839 connman_ipconfig_set_method(service->ipconfig,
840 CONNMAN_IPCONFIG_METHOD_DHCP);
846 * connman_service_ref:
847 * @service: service structure
849 * Increase reference counter of service
851 struct connman_service *connman_service_ref(struct connman_service *service)
853 g_atomic_int_inc(&service->refcount);
859 * connman_service_unref:
860 * @service: service structure
862 * Decrease reference counter of service
864 void connman_service_unref(struct connman_service *service)
866 __connman_service_put(service);
869 static gint service_compare(gconstpointer a, gconstpointer b,
872 struct connman_service *service_a = (void *) a;
873 struct connman_service *service_b = (void *) b;
875 if (service_a->state != service_b->state) {
876 if (service_a->state == CONNMAN_SERVICE_STATE_READY)
878 if (service_b->state == CONNMAN_SERVICE_STATE_READY)
882 if (service_a->order > service_b->order)
885 if (service_a->order < service_b->order)
888 if (service_a->favorite == TRUE && service_b->favorite == FALSE)
891 if (service_a->favorite == FALSE && service_b->favorite == TRUE)
894 return (gint) service_b->strength - (gint) service_a->strength;
898 * connman_service_set_favorite:
899 * @service: service structure
900 * @favorite: favorite value
902 * Change the favorite setting of service
904 int connman_service_set_favorite(struct connman_service *service,
905 connman_bool_t favorite)
909 iter = g_hash_table_lookup(service_hash, service->identifier);
913 if (service->favorite == favorite)
916 service->favorite = favorite;
918 g_sequence_sort_changed(iter, service_compare, NULL);
920 __connman_profile_changed();
925 int __connman_service_set_carrier(struct connman_service *service,
926 connman_bool_t carrier)
928 DBG("service %p carrier %d", service, carrier);
933 switch (service->type) {
934 case CONNMAN_SERVICE_TYPE_UNKNOWN:
935 case CONNMAN_SERVICE_TYPE_WIFI:
936 case CONNMAN_SERVICE_TYPE_WIMAX:
937 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
938 case CONNMAN_SERVICE_TYPE_CELLULAR:
940 case CONNMAN_SERVICE_TYPE_ETHERNET:
944 if (carrier == FALSE) {
945 service->state = CONNMAN_SERVICE_STATE_DISCONNECT;
946 state_changed(service);
948 service->state = CONNMAN_SERVICE_STATE_IDLE;
949 state_changed(service);
951 service->state = CONNMAN_SERVICE_STATE_CARRIER;
952 state_changed(service);
955 return connman_service_set_favorite(service, carrier);
958 int __connman_service_indicate_state(struct connman_service *service,
959 enum connman_service_state state)
963 DBG("service %p state %d", service, state);
968 if (state == CONNMAN_SERVICE_STATE_CARRIER)
969 return __connman_service_set_carrier(service, TRUE);
971 if (service->state == state)
974 if (service->state == CONNMAN_SERVICE_STATE_IDLE &&
975 state == CONNMAN_SERVICE_STATE_DISCONNECT)
978 if (state == CONNMAN_SERVICE_STATE_IDLE &&
979 service->state != CONNMAN_SERVICE_STATE_DISCONNECT) {
980 service->state = CONNMAN_SERVICE_STATE_DISCONNECT;
981 state_changed(service);
984 service->state = state;
985 state_changed(service);
987 if (state == CONNMAN_SERVICE_STATE_READY) {
988 connman_service_set_favorite(service, TRUE);
990 if (service->timeout > 0) {
991 g_source_remove(service->timeout);
992 service->timeout = 0;
995 if (service->pending != NULL) {
996 g_dbus_send_reply(connection, service->pending,
999 dbus_message_unref(service->pending);
1000 service->pending = NULL;
1003 g_get_current_time(&service->modified);
1004 __connman_storage_save_service(service);
1007 if (state == CONNMAN_SERVICE_STATE_FAILURE) {
1008 if (service->timeout > 0) {
1009 g_source_remove(service->timeout);
1010 service->timeout = 0;
1013 if (service->pending != NULL) {
1016 reply = __connman_error_failed(service->pending, EIO);
1018 g_dbus_send_message(connection, reply);
1020 dbus_message_unref(service->pending);
1021 service->pending = NULL;
1024 g_get_current_time(&service->modified);
1025 __connman_storage_save_service(service);
1027 service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
1029 iter = g_hash_table_lookup(service_hash, service->identifier);
1031 g_sequence_sort_changed(iter, service_compare, NULL);
1033 __connman_profile_changed();
1038 int __connman_service_indicate_error(struct connman_service *service,
1039 enum connman_service_error error)
1041 DBG("service %p error %d", service, error);
1043 if (service == NULL)
1046 service->error = error;
1048 return __connman_service_indicate_state(service,
1049 CONNMAN_SERVICE_STATE_FAILURE);
1052 int __connman_service_indicate_default(struct connman_service *service)
1054 DBG("service %p", service);
1059 int __connman_service_connect(struct connman_service *service)
1063 DBG("service %p", service);
1065 if (service->state == CONNMAN_SERVICE_STATE_READY)
1068 if (service->network != NULL) {
1069 unsigned int ssid_len;
1071 if (connman_network_get_blob(service->network, "WiFi.SSID",
1074 connman_network_set_string(service->network,
1075 "WiFi.Passphrase", service->passphrase);
1077 err = __connman_network_connect(service->network);
1078 } else if (service->device != NULL) {
1079 if (service->favorite == FALSE)
1082 err = __connman_device_connect(service->device);
1087 if (err != -EINPROGRESS)
1090 service->timeout = g_timeout_add_seconds(45,
1091 connect_timeout, service);
1093 return -EINPROGRESS;
1099 int __connman_service_disconnect(struct connman_service *service)
1103 DBG("service %p", service);
1105 if (service->network != NULL) {
1106 err = __connman_network_disconnect(service->network);
1107 } else if (service->device != NULL) {
1108 if (service->favorite == FALSE)
1110 err = __connman_device_disconnect(service->device);
1115 if (err != -EINPROGRESS)
1118 return -EINPROGRESS;
1125 * __connman_service_lookup:
1126 * @identifier: service identifier
1128 * Look up a service by identifier (reference count will not be increased)
1130 static struct connman_service *__connman_service_lookup(const char *identifier)
1132 GSequenceIter *iter;
1134 iter = g_hash_table_lookup(service_hash, identifier);
1136 return g_sequence_get(iter);
1142 * __connman_service_get:
1143 * @identifier: service identifier
1145 * Look up a service by identifier or create a new one if not found
1147 static struct connman_service *__connman_service_get(const char *identifier)
1149 struct connman_service *service;
1150 GSequenceIter *iter;
1152 iter = g_hash_table_lookup(service_hash, identifier);
1154 service = g_sequence_get(iter);
1155 if (service != NULL)
1156 g_atomic_int_inc(&service->refcount);
1160 service = connman_service_create();
1161 if (service == NULL)
1164 DBG("service %p", service);
1166 service->identifier = g_strdup(identifier);
1168 service->profile = g_strdup(__connman_profile_active_ident());
1170 __connman_storage_load_service(service);
1172 iter = g_sequence_insert_sorted(service_list, service,
1173 service_compare, NULL);
1175 g_hash_table_insert(service_hash, service->identifier, iter);
1180 static int service_register(struct connman_service *service)
1182 const char *path = __connman_profile_active_path();
1183 GSequenceIter *iter;
1185 DBG("service %p", service);
1187 if (service->path != NULL)
1190 service->path = g_strdup_printf("%s/%s", path, service->identifier);
1192 DBG("path %s", service->path);
1194 g_dbus_register_interface(connection, service->path,
1195 CONNMAN_SERVICE_INTERFACE,
1196 service_methods, service_signals,
1197 NULL, service, NULL);
1199 __connman_storage_load_service(service);
1201 iter = g_hash_table_lookup(service_hash, service->identifier);
1203 g_sequence_sort_changed(iter, service_compare, NULL);
1205 __connman_profile_changed();
1211 * connman_service_lookup_from_device:
1212 * @device: device structure
1214 * Look up a service by device (reference count will not be increased)
1216 struct connman_service *__connman_service_lookup_from_device(struct connman_device *device)
1218 struct connman_service *service;
1222 ident = __connman_device_get_ident(device);
1226 name = g_strdup_printf("%s_%s",
1227 __connman_device_get_type(device), ident);
1229 service = __connman_service_lookup(name);
1236 static enum connman_service_type convert_device_type(struct connman_device *device)
1238 enum connman_device_type type = connman_device_get_type(device);
1241 case CONNMAN_DEVICE_TYPE_UNKNOWN:
1242 case CONNMAN_DEVICE_TYPE_VENDOR:
1243 case CONNMAN_DEVICE_TYPE_WIFI:
1244 case CONNMAN_DEVICE_TYPE_WIMAX:
1245 case CONNMAN_DEVICE_TYPE_BLUETOOTH:
1246 case CONNMAN_DEVICE_TYPE_GPS:
1247 case CONNMAN_DEVICE_TYPE_MBM:
1248 case CONNMAN_DEVICE_TYPE_HSO:
1249 case CONNMAN_DEVICE_TYPE_NOZOMI:
1250 case CONNMAN_DEVICE_TYPE_HUAWEI:
1251 case CONNMAN_DEVICE_TYPE_NOVATEL:
1253 case CONNMAN_DEVICE_TYPE_ETHERNET:
1254 return CONNMAN_SERVICE_TYPE_ETHERNET;
1257 return CONNMAN_SERVICE_TYPE_UNKNOWN;
1261 * connman_service_create_from_device:
1262 * @device: device structure
1264 * Look up service by device and if not found, create one
1266 struct connman_service *__connman_service_create_from_device(struct connman_device *device)
1268 struct connman_service *service;
1272 ident = __connman_device_get_ident(device);
1276 name = g_strdup_printf("%s_%s",
1277 __connman_device_get_type(device), ident);
1279 service = __connman_service_get(name);
1280 if (service == NULL)
1283 if (service->path != NULL) {
1284 __connman_service_put(service);
1289 service->type = convert_device_type(device);
1291 service->device = device;
1293 service_register(service);
1295 if (service->favorite == TRUE)
1296 __connman_service_auto_connect();
1305 * connman_service_lookup_from_network:
1306 * @network: network structure
1308 * Look up a service by network (reference count will not be increased)
1310 struct connman_service *__connman_service_lookup_from_network(struct connman_network *network)
1312 struct connman_service *service;
1313 const char *ident, *group;
1316 ident = __connman_network_get_ident(network);
1320 group = connman_network_get_group(network);
1324 name = g_strdup_printf("%s_%s_%s",
1325 __connman_network_get_type(network), ident, group);
1327 service = __connman_service_lookup(name);
1334 unsigned int __connman_service_get_order(struct connman_service *service)
1336 GSequenceIter *iter;
1338 if (service == NULL)
1341 if (service->favorite == FALSE)
1344 iter = g_hash_table_lookup(service_hash, service->identifier);
1346 if (g_sequence_iter_get_position(iter) == 0)
1350 return service->order;
1353 static enum connman_service_type convert_network_type(struct connman_network *network)
1355 enum connman_network_type type = connman_network_get_type(network);
1358 case CONNMAN_NETWORK_TYPE_UNKNOWN:
1359 case CONNMAN_NETWORK_TYPE_VENDOR:
1360 case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
1361 case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
1363 case CONNMAN_NETWORK_TYPE_MBM:
1364 case CONNMAN_NETWORK_TYPE_HSO:
1365 return CONNMAN_SERVICE_TYPE_CELLULAR;
1366 case CONNMAN_NETWORK_TYPE_WIFI:
1367 return CONNMAN_SERVICE_TYPE_WIFI;
1368 case CONNMAN_NETWORK_TYPE_WIMAX:
1369 return CONNMAN_SERVICE_TYPE_WIMAX;
1372 return CONNMAN_SERVICE_TYPE_UNKNOWN;
1375 static enum connman_service_mode convert_wifi_mode(const char *mode)
1378 return CONNMAN_SERVICE_MODE_UNKNOWN;
1379 else if (g_str_equal(mode, "managed") == TRUE)
1380 return CONNMAN_SERVICE_MODE_MANAGED;
1381 else if (g_str_equal(mode, "adhoc") == TRUE)
1382 return CONNMAN_SERVICE_MODE_ADHOC;
1384 return CONNMAN_SERVICE_MODE_UNKNOWN;
1387 static enum connman_service_mode convert_wifi_security(const char *security)
1389 if (security == NULL)
1390 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
1391 else if (g_str_equal(security, "none") == TRUE)
1392 return CONNMAN_SERVICE_SECURITY_NONE;
1393 else if (g_str_equal(security, "wep") == TRUE)
1394 return CONNMAN_SERVICE_SECURITY_WEP;
1395 else if (g_str_equal(security, "wpa") == TRUE)
1396 return CONNMAN_SERVICE_SECURITY_WPA;
1397 else if (g_str_equal(security, "rsn") == TRUE)
1398 return CONNMAN_SERVICE_SECURITY_RSN;
1400 return CONNMAN_SERVICE_SECURITY_UNKNOWN;
1403 static void update_from_network(struct connman_service *service,
1404 struct connman_network *network)
1406 connman_uint8_t strength = service->strength;
1407 GSequenceIter *iter;
1410 if (service->state == CONNMAN_SERVICE_STATE_READY)
1413 if (is_connecting(service) == TRUE)
1416 str = connman_network_get_string(network, "Name");
1418 g_free(service->name);
1419 service->name = g_strdup(str);
1420 service->hidden = FALSE;
1422 g_free(service->name);
1423 service->name = NULL;
1424 service->hidden = TRUE;
1427 service->strength = connman_network_get_uint8(network, "Strength");
1429 str = connman_network_get_string(network, "WiFi.Mode");
1430 service->mode = convert_wifi_mode(str);
1432 str = connman_network_get_string(network, "WiFi.Security");
1433 service->security = convert_wifi_security(str);
1435 if (service->strength > strength && service->network != NULL) {
1436 connman_network_unref(service->network);
1437 service->network = NULL;
1439 strength_changed(service);
1442 if (service->network == NULL) {
1443 service->network = connman_network_ref(network);
1445 str = connman_network_get_string(network, "WiFi.Passphrase");
1447 g_free(service->passphrase);
1448 service->passphrase = g_strdup(str);
1452 iter = g_hash_table_lookup(service_hash, service->identifier);
1454 g_sequence_sort_changed(iter, service_compare, NULL);
1458 * connman_service_create_from_network:
1459 * @network: network structure
1461 * Look up service by network and if not found, create one
1463 struct connman_service *__connman_service_create_from_network(struct connman_network *network)
1465 struct connman_service *service;
1466 const char *ident, *group;
1469 service = __connman_service_lookup_from_network(network);
1470 if (service != NULL) {
1471 update_from_network(service, network);
1475 ident = __connman_network_get_ident(network);
1479 group = connman_network_get_group(network);
1483 name = g_strdup_printf("%s_%s_%s",
1484 __connman_network_get_type(network), ident, group);
1486 service = __connman_service_get(name);
1487 if (service == NULL)
1490 if (service->path != NULL) {
1491 update_from_network(service, network);
1493 __connman_profile_changed();
1495 __connman_service_put(service);
1500 service->type = convert_network_type(network);
1502 service->state = CONNMAN_SERVICE_STATE_IDLE;
1504 update_from_network(service, network);
1506 service_register(service);
1508 if (service->favorite == TRUE)
1509 __connman_service_auto_connect();
1517 static int service_load(struct connman_service *service)
1520 gchar *pathname, *data = NULL;
1523 unsigned int ssid_len;
1526 DBG("service %p", service);
1528 if (service->profile == NULL)
1531 pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR, service->profile);
1532 if (pathname == NULL)
1535 keyfile = g_key_file_new();
1537 if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE) {
1544 if (g_key_file_load_from_data(keyfile, data, length,
1545 0, NULL) == FALSE) {
1552 switch (service->type) {
1553 case CONNMAN_SERVICE_TYPE_UNKNOWN:
1554 case CONNMAN_SERVICE_TYPE_ETHERNET:
1556 case CONNMAN_SERVICE_TYPE_WIFI:
1557 if (service->name == NULL) {
1560 name = g_key_file_get_string(keyfile,
1561 service->identifier, "Name", NULL);
1563 g_free(service->name);
1564 service->name = name;
1567 if (service->network != NULL)
1568 connman_network_set_name(service->network,
1572 if (service->network &&
1573 connman_network_get_blob(service->network,
1574 "WiFi.SSID", &ssid_len) == NULL) {
1577 hex_ssid = g_key_file_get_string(keyfile,
1578 service->identifier,
1581 if (hex_ssid != NULL) {
1583 unsigned int i, j = 0, hex;
1584 size_t hex_ssid_len = strlen(hex_ssid);
1586 ssid = g_try_malloc0(hex_ssid_len / 2);
1593 for (i = 0; i < hex_ssid_len; i += 2) {
1594 sscanf(hex_ssid + i, "%02x", &hex);
1598 connman_network_set_blob(service->network,
1599 "WiFi.SSID", ssid, hex_ssid_len / 2);
1606 case CONNMAN_SERVICE_TYPE_WIMAX:
1607 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1608 case CONNMAN_SERVICE_TYPE_CELLULAR:
1609 service->favorite = g_key_file_get_boolean(keyfile,
1610 service->identifier, "Favorite", NULL);
1612 str = g_key_file_get_string(keyfile,
1613 service->identifier, "Failure", NULL);
1615 service->state = CONNMAN_SERVICE_STATE_FAILURE;
1616 service->error = string2error(str);
1621 str = g_key_file_get_string(keyfile,
1622 service->identifier, "Modified", NULL);
1624 g_time_val_from_iso8601(str, &service->modified);
1628 str = g_key_file_get_string(keyfile,
1629 service->identifier, "Passphrase", NULL);
1631 g_free(service->passphrase);
1632 service->passphrase = str;
1635 __connman_ipconfig_load(service->ipconfig, keyfile,
1636 service->identifier, "IPv4.");
1639 g_key_file_free(keyfile);
1644 static int service_save(struct connman_service *service)
1647 gchar *pathname, *data = NULL;
1652 DBG("service %p", service);
1654 if (service->profile == NULL)
1657 pathname = g_strdup_printf("%s/%s.conf", STORAGEDIR, service->profile);
1658 if (pathname == NULL)
1661 keyfile = g_key_file_new();
1663 if (g_file_get_contents(pathname, &data, &length, NULL) == FALSE)
1667 if (g_key_file_load_from_data(keyfile, data, length,
1675 if (service->name != NULL)
1676 g_key_file_set_string(keyfile, service->identifier,
1677 "Name", service->name);
1679 switch (service->type) {
1680 case CONNMAN_SERVICE_TYPE_UNKNOWN:
1681 case CONNMAN_SERVICE_TYPE_ETHERNET:
1683 case CONNMAN_SERVICE_TYPE_WIFI:
1684 if (service->network) {
1685 const unsigned char *ssid;
1686 unsigned int ssid_len = 0;
1688 ssid = connman_network_get_blob(service->network,
1689 "WiFi.SSID", &ssid_len);
1691 if (ssid != NULL && ssid_len > 0 && ssid[0] != '\0') {
1692 char *identifier = service->identifier;
1696 str = g_string_sized_new(ssid_len * 2);
1702 for (i = 0; i < ssid_len; i++)
1703 g_string_append_printf(str,
1706 g_key_file_set_string(keyfile, identifier,
1709 g_string_free(str, TRUE);
1714 case CONNMAN_SERVICE_TYPE_WIMAX:
1715 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
1716 case CONNMAN_SERVICE_TYPE_CELLULAR:
1717 g_key_file_set_boolean(keyfile, service->identifier,
1718 "Favorite", service->favorite);
1720 if (service->state == CONNMAN_SERVICE_STATE_FAILURE) {
1721 const char *failure = error2string(service->error);
1722 if (failure != NULL)
1723 g_key_file_set_string(keyfile,
1724 service->identifier,
1725 "Failure", failure);
1727 g_key_file_remove_key(keyfile, service->identifier,
1733 str = g_time_val_to_iso8601(&service->modified);
1735 g_key_file_set_string(keyfile, service->identifier,
1740 if (service->passphrase != NULL)
1741 g_key_file_set_string(keyfile, service->identifier,
1742 "Passphrase", service->passphrase);
1744 g_key_file_remove_key(keyfile, service->identifier,
1745 "Passphrase", NULL);
1747 __connman_ipconfig_save(service->ipconfig, keyfile,
1748 service->identifier, "IPv4.");
1750 data = g_key_file_to_data(keyfile, &length, NULL);
1752 if (g_file_set_contents(pathname, data, length, NULL) == FALSE)
1753 connman_error("Failed to store service information");
1758 g_key_file_free(keyfile);
1765 static struct connman_storage service_storage = {
1767 .priority = CONNMAN_STORAGE_PRIORITY_LOW,
1768 .service_load = service_load,
1769 .service_save = service_save,
1772 int __connman_service_init(void)
1776 connection = connman_dbus_get_connection();
1778 if (connman_storage_register(&service_storage) < 0)
1779 connman_error("Failed to register service storage");
1781 service_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
1784 service_list = g_sequence_new(service_free);
1789 void __connman_service_cleanup(void)
1793 g_sequence_free(service_list);
1794 service_list = NULL;
1796 g_hash_table_destroy(service_hash);
1797 service_hash = NULL;
1799 connman_storage_unregister(&service_storage);
1801 dbus_connection_unref(connection);