5 * Copyright (C) 2007-2010 Intel Corporation. All rights reserved.
6 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
33 #define CONNMAN_API_SUBJECT_TO_CHANGE
34 #include <connman/plugin.h>
35 #include <connman/element.h>
36 #include <connman/device.h>
37 #include <connman/network.h>
38 #include <connman/ipconfig.h>
39 #include <connman/dbus.h>
40 #include <connman/inet.h>
41 #include <connman/technology.h>
42 #include <connman/log.h>
46 #define OFONO_SERVICE "org.ofono"
48 #define OFONO_MANAGER_INTERFACE OFONO_SERVICE ".Manager"
49 #define OFONO_MODEM_INTERFACE OFONO_SERVICE ".Modem"
50 #define OFONO_GPRS_INTERFACE OFONO_SERVICE ".ConnectionManager"
51 #define OFONO_CONTEXT_INTERFACE OFONO_SERVICE ".ConnectionContext"
52 #define OFONO_SIM_INTERFACE OFONO_SERVICE ".SimManager"
53 #define OFONO_REGISTRATION_INTERFACE OFONO_SERVICE ".NetworkRegistration"
55 #define PROPERTY_CHANGED "PropertyChanged"
56 #define GET_PROPERTIES "GetProperties"
57 #define SET_PROPERTY "SetProperty"
58 #define CONTEXT_ADDED "ContextAdded"
59 #define CONTEXT_REMOVED "ContextRemoved"
60 #define ADD_CONTEXT "AddContext"
61 #define GET_MODEMS "GetModems"
62 #define MODEM_ADDED "ModemAdded"
63 #define MODEM_REMOVED "ModemRemoved"
68 static DBusConnection *connection;
70 static GHashTable *modem_hash = NULL;
72 static GHashTable *network_hash;
76 struct connman_device *device;
81 gboolean pending_online;
82 dbus_bool_t requested_online;
85 /* org.ofono.ConnectionManager properties */
88 dbus_bool_t roaming_allowed;
90 connman_bool_t registered;
91 connman_bool_t roaming;
92 uint8_t strength, has_strength;
97 struct connman_network *network;
99 enum connman_ipconfig_method ipv4_method;
100 struct connman_ipaddress ipv4_address;
102 enum connman_ipconfig_method ipv6_method;
103 struct connman_ipaddress ipv6_address;
106 static int modem_probe(struct connman_device *device)
108 DBG("device %p", device);
113 static void modem_remove(struct connman_device *device)
115 DBG("device %p", device);
118 static int call_ofono(const char *path,
119 const char *interface, const char *method,
120 DBusPendingCallNotifyFunction notify, void *user_data,
121 DBusFreeFunction free_function,
124 DBusMessage *message;
125 DBusPendingCall *call;
129 DBG("path %s %s.%s", path, interface, method);
134 message = dbus_message_new_method_call(OFONO_SERVICE, path,
139 dbus_message_set_auto_start(message, FALSE);
142 ok = dbus_message_append_args_valist(message, type, va);
148 if (dbus_connection_send_with_reply(connection, message,
149 &call, TIMEOUT) == FALSE) {
150 connman_error("Failed to call %s.%s", interface, method);
151 dbus_message_unref(message);
156 connman_error("D-Bus connection not available");
157 dbus_message_unref(message);
161 dbus_pending_call_set_notify(call, notify, user_data, free_function);
163 dbus_message_unref(message);
168 static void set_property_reply(DBusPendingCall *call, void *user_data)
172 char const *name = user_data;
176 dbus_error_init(&error);
178 reply = dbus_pending_call_steal_reply(call);
180 if (dbus_set_error_from_message(&error, reply)) {
181 connman_error("SetProperty(%s) %s %s", name,
182 error.name, error.message);
183 dbus_error_free(&error);
186 dbus_message_unref(reply);
188 dbus_pending_call_unref(call);
191 static int set_property(const char *path, const char *interface,
192 const char *property, int type, void *value,
193 DBusPendingCallNotifyFunction notify, void *user_data,
194 DBusFreeFunction free_function)
196 DBusMessage *message;
197 DBusMessageIter iter;
198 DBusPendingCall *call;
200 DBG("path %s %s.%s", path, interface, property);
202 g_assert(notify == NULL ? free_function == NULL : 1);
207 message = dbus_message_new_method_call(OFONO_SERVICE, path,
208 interface, SET_PROPERTY);
212 dbus_message_set_auto_start(message, FALSE);
214 dbus_message_iter_init_append(message, &iter);
215 connman_dbus_property_append_basic(&iter, property, type, value);
217 if (dbus_connection_send_with_reply(connection, message,
218 &call, TIMEOUT) == FALSE) {
219 connman_error("Failed to change \"%s\" property on %s",
220 property, interface);
221 dbus_message_unref(message);
226 connman_error("D-Bus connection not available");
227 dbus_message_unref(message);
231 if (notify == NULL) {
232 notify = set_property_reply;
233 user_data = (void *)property;
234 free_function = NULL;
237 dbus_pending_call_set_notify(call, notify, user_data, free_function);
239 dbus_message_unref(message);
244 static void update_modem_online(struct modem_data *modem,
245 connman_bool_t online)
247 DBG("modem %p path %s online %d", modem, modem->path, online);
249 modem->online = online;
250 modem->requested_online = online;
251 modem->pending_online = FALSE;
254 connman_device_set_powered(modem->device, online);
257 static void set_online_reply(DBusPendingCall *call, void *user_data)
259 struct modem_data *modem;
264 DBG("path %s", (char *)user_data);
266 if (modem_hash == NULL)
269 modem = g_hash_table_lookup(modem_hash, user_data);
273 reply = dbus_pending_call_steal_reply(call);
275 dbus_error_init(&error);
277 if (dbus_set_error_from_message(&error, reply)) {
278 connman_error("SetProperty(Online) %s %s",
279 error.name, error.message);
280 dbus_error_free(&error);
282 result = modem->online;
284 result = modem->requested_online;
286 if (modem->pending_online)
287 update_modem_online(modem, result);
289 dbus_message_unref(reply);
291 dbus_pending_call_unref(call);
294 static int modem_change_online(char const *path, dbus_bool_t online)
296 struct modem_data *modem = g_hash_table_lookup(modem_hash, path);
301 if (modem->online == online)
304 modem->requested_online = online;
306 return set_property(path, OFONO_MODEM_INTERFACE, "Online",
307 DBUS_TYPE_BOOLEAN, &online,
309 (void *)g_strdup(path), g_free);
312 static int modem_enable(struct connman_device *device)
314 const char *path = connman_device_get_string(device, "Path");
316 DBG("device %p, path, %s", device, path);
318 return modem_change_online(path, TRUE);
321 static int modem_disable(struct connman_device *device)
323 const char *path = connman_device_get_string(device, "Path");
325 DBG("device %p path %s", device, path);
327 return modem_change_online(path, FALSE);
330 static struct connman_device_driver modem_driver = {
332 .type = CONNMAN_DEVICE_TYPE_CELLULAR,
333 .probe = modem_probe,
334 .remove = modem_remove,
335 .enable = modem_enable,
336 .disable = modem_disable,
339 static void modem_remove_device(struct modem_data *modem)
341 DBG("modem %p path %s device %p", modem, modem->path, modem->device);
343 if (modem->device == NULL)
346 connman_device_remove_all_networks(modem->device);
347 connman_device_unregister(modem->device);
348 connman_device_unref(modem->device);
350 modem->device = NULL;
353 static void remove_modem(gpointer data)
355 struct modem_data *modem = data;
357 modem_remove_device(modem);
360 g_free(modem->operator);
365 static void remove_network(gpointer data)
367 struct network_info *info = data;
369 connman_network_unregister(info->network);
370 connman_network_unref(info->network);
375 static char *get_ident(const char *path)
382 pos = strrchr(path, '/');
389 static void create_service(struct connman_network *network)
396 path = connman_network_get_string(network, "Path");
398 group = get_ident(path);
400 connman_network_set_group(network, group);
403 static int network_probe(struct connman_network *network)
408 static gboolean pending_network_is_available(struct connman_network *network)
410 /* Modem or network may be removed */
411 if (network == NULL || connman_network_get_device(network) == NULL) {
412 DBG("Modem or network was removed");
419 static void set_connected(struct network_info *info,
420 connman_bool_t connected)
422 DBG("network %p connected %d", info->network, connected);
424 switch (info->ipv4_method) {
425 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
426 case CONNMAN_IPCONFIG_METHOD_OFF:
427 case CONNMAN_IPCONFIG_METHOD_MANUAL:
428 case CONNMAN_IPCONFIG_METHOD_AUTO:
431 case CONNMAN_IPCONFIG_METHOD_FIXED:
432 connman_network_set_ipv4_method(info->network,
434 connman_network_set_ipaddress(info->network,
435 &info->ipv4_address);
439 case CONNMAN_IPCONFIG_METHOD_DHCP:
440 connman_network_set_ipv4_method(info->network,
446 switch (info->ipv6_method) {
447 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
448 case CONNMAN_IPCONFIG_METHOD_OFF:
449 case CONNMAN_IPCONFIG_METHOD_MANUAL:
450 case CONNMAN_IPCONFIG_METHOD_DHCP:
451 case CONNMAN_IPCONFIG_METHOD_AUTO:
454 case CONNMAN_IPCONFIG_METHOD_FIXED:
455 connman_network_set_ipv6_method(info->network,
457 connman_network_set_ipaddress(info->network,
458 &info->ipv6_address);
463 connman_network_set_connected(info->network, connected);
466 static void set_active_reply(DBusPendingCall *call, void *user_data)
468 char const *path = user_data;
471 struct network_info *info;
473 info = g_hash_table_lookup(network_hash, path);
475 reply = dbus_pending_call_steal_reply(call);
480 DBG("path %s network %p", path, info->network);
482 if (!pending_network_is_available(info->network))
485 dbus_error_init(&error);
487 if (dbus_set_error_from_message(&error, reply)) {
488 connman_error("SetProperty(Active) %s %s",
489 error.name, error.message);
491 if (connman_network_get_index(info->network) < 0)
492 connman_network_set_error(info->network,
493 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
495 dbus_error_free(&error);
496 } else if (connman_network_get_index(info->network) >= 0)
497 set_connected(info, TRUE);
500 dbus_message_unref(reply);
502 dbus_pending_call_unref(call);
505 static int set_network_active(struct connman_network *network)
507 dbus_bool_t value = TRUE;
508 const char *path = connman_network_get_string(network, "Path");
510 DBG("network %p, path %s", network, path);
512 return set_property(path, OFONO_CONTEXT_INTERFACE,
513 "Active", DBUS_TYPE_BOOLEAN, &value,
514 set_active_reply, g_strdup(path), g_free);
517 static int set_network_inactive(struct connman_network *network)
520 dbus_bool_t value = FALSE;
521 const char *path = connman_network_get_string(network, "Path");
523 DBG("network %p, path %s", network, path);
525 err = set_property(path, OFONO_CONTEXT_INTERFACE,
526 "Active", DBUS_TYPE_BOOLEAN, &value,
529 if (err == -EINPROGRESS)
535 static int network_connect(struct connman_network *network)
537 struct connman_device *device;
538 struct modem_data *modem;
540 DBG("network %p", network);
542 device = connman_network_get_device(network);
546 modem = connman_device_get_data(device);
550 if (modem->registered == FALSE)
553 if (modem->powered == FALSE)
556 if (modem->roaming_allowed == FALSE && modem->roaming == TRUE)
559 return set_network_active(network);
562 static int network_disconnect(struct connman_network *network)
564 DBG("network %p", network);
566 if (connman_network_get_index(network) < 0)
569 connman_network_set_associating(network, FALSE);
571 return set_network_inactive(network);
574 static void network_remove(struct connman_network *network)
576 char const *path = connman_network_get_string(network, "Path");
578 DBG("network %p path %s", network, path);
580 g_hash_table_remove(network_hash, path);
583 static struct connman_network_driver network_driver = {
585 .type = CONNMAN_NETWORK_TYPE_CELLULAR,
586 .probe = network_probe,
587 .remove = network_remove,
588 .connect = network_connect,
589 .disconnect = network_disconnect,
592 static void get_dns(DBusMessageIter *array, struct network_info *info)
594 DBusMessageIter entry;
595 gchar *nameservers = NULL, *nameservers_old = NULL;
600 dbus_message_iter_recurse(array, &entry);
602 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
605 dbus_message_iter_get_basic(&entry, &dns);
609 if (nameservers == NULL) {
611 nameservers = g_strdup(dns);
614 nameservers_old = nameservers;
615 nameservers = g_strdup_printf("%s %s",
616 nameservers_old, dns);
617 g_free(nameservers_old);
620 dbus_message_iter_next(&entry);
623 connman_network_set_nameservers(info->network, nameservers);
628 static void update_ipv4_settings(DBusMessageIter *array,
629 struct network_info *info)
631 DBusMessageIter dict;
632 char *address = NULL, *netmask = NULL, *gateway = NULL;
633 const char *interface = NULL;
635 DBG("network %p", info->network);
637 if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
640 dbus_message_iter_recurse(array, &dict);
642 while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
643 DBusMessageIter entry, value;
644 const char *key, *val;
646 dbus_message_iter_recurse(&dict, &entry);
647 dbus_message_iter_get_basic(&entry, &key);
651 dbus_message_iter_next(&entry);
652 dbus_message_iter_recurse(&entry, &value);
654 if (g_str_equal(key, "Interface") == TRUE) {
657 dbus_message_iter_get_basic(&value, &interface);
659 DBG("interface %s", interface);
661 index = connman_inet_ifindex(interface);
663 connman_network_set_index(info->network, index);
665 connman_error("Can not find interface %s",
669 } else if (g_str_equal(key, "Method") == TRUE) {
672 dbus_message_iter_get_basic(&value, &method);
674 if (g_strcmp0(method, "static") == 0) {
677 CONNMAN_IPCONFIG_METHOD_FIXED;
678 } else if (g_strcmp0(method, "dhcp") == 0) {
681 CONNMAN_IPCONFIG_METHOD_DHCP;
684 } else if (g_str_equal(key, "Address") == TRUE) {
685 dbus_message_iter_get_basic(&value, &val);
687 address = g_strdup(val);
689 DBG("address %s", address);
690 } else if (g_str_equal(key, "Netmask") == TRUE) {
691 dbus_message_iter_get_basic(&value, &val);
693 netmask = g_strdup(val);
695 DBG("netmask %s", netmask);
696 } else if (g_str_equal(key, "DomainNameServers") == TRUE) {
698 get_dns(&value, info);
699 } else if (g_str_equal(key, "Gateway") == TRUE) {
700 dbus_message_iter_get_basic(&value, &val);
702 gateway = g_strdup(val);
704 DBG("gateway %s", gateway);
707 dbus_message_iter_next(&dict);
711 if (info->ipv4_method == CONNMAN_IPCONFIG_METHOD_FIXED) {
712 connman_ipaddress_set_ipv4(&info->ipv4_address, address,
716 /* deactive, oFono send NULL inteface before deactive signal */
717 if (interface == NULL)
718 connman_network_set_index(info->network, -1);
725 static void update_ipv6_settings(DBusMessageIter *array,
726 struct network_info *info)
728 DBusMessageIter dict;
729 char *address = NULL, *gateway = NULL;
730 unsigned char prefix_length;
731 const char *interface = NULL;
733 DBG("network %p", info->network);
735 if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
738 dbus_message_iter_recurse(array, &dict);
740 info->ipv6_method = CONNMAN_IPCONFIG_METHOD_FIXED;
742 while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
743 DBusMessageIter entry, value;
744 const char *key, *val;
746 dbus_message_iter_recurse(&dict, &entry);
747 dbus_message_iter_get_basic(&entry, &key);
751 dbus_message_iter_next(&entry);
752 dbus_message_iter_recurse(&entry, &value);
754 if (g_str_equal(key, "Interface") == TRUE) {
757 dbus_message_iter_get_basic(&value, &interface);
759 DBG("interface %s", interface);
761 index = connman_inet_ifindex(interface);
763 connman_network_set_index(info->network, index);
765 connman_error("Can not find interface %s",
769 } else if (g_str_equal(key, "Address") == TRUE) {
770 dbus_message_iter_get_basic(&value, &val);
772 address = g_strdup(val);
774 DBG("address %s", address);
775 } else if (g_str_equal(key, "PrefixLength") == TRUE) {
776 dbus_message_iter_get_basic(&value, &prefix_length);
778 DBG("prefix length %d", prefix_length);
779 } else if (g_str_equal(key, "DomainNameServers") == TRUE) {
781 get_dns(&value, info);
782 } else if (g_str_equal(key, "Gateway") == TRUE) {
783 dbus_message_iter_get_basic(&value, &val);
785 gateway = g_strdup(val);
787 DBG("gateway %s", gateway);
790 dbus_message_iter_next(&dict);
793 connman_ipaddress_set_ipv6(&info->ipv6_address, address,
794 prefix_length, gateway);
796 /* deactive, oFono send NULL inteface before deactive signal */
797 if (interface == NULL)
798 connman_network_set_index(info->network, -1);
804 static int add_network(struct connman_device *device,
805 const char *path, DBusMessageIter *dict)
807 struct modem_data *modem = connman_device_get_data(device);
808 struct connman_network *network;
809 struct network_info *info;
811 const char *hash_path;
812 dbus_bool_t active = FALSE;
814 DBG("modem %p device %p path %s", modem, device, path);
816 ident = get_ident(path);
818 network = connman_device_get_network(device, ident);
822 info = g_hash_table_lookup(network_hash, path);
824 DBG("path %p already exists with device %p", path,
825 connman_network_get_device(info->network));
826 if (connman_network_get_device(info->network))
828 g_hash_table_remove(network_hash, path);
831 network = connman_network_create(ident, CONNMAN_NETWORK_TYPE_CELLULAR);
835 connman_network_register(network);
837 info = g_try_new0(struct network_info, 1);
839 connman_network_unregister(network);
840 connman_network_unref(network);
844 connman_ipaddress_clear(&info->ipv4_address);
845 connman_ipaddress_clear(&info->ipv6_address);
846 info->network = network;
848 connman_network_set_string(network, "Path", path);
849 hash_path = connman_network_get_string(network, "Path");
850 if (hash_path == NULL) {
851 connman_network_unref(network);
856 create_service(network);
858 connman_network_ref(network);
859 g_hash_table_insert(network_hash, (char *) hash_path, info);
861 connman_network_set_available(network, TRUE);
862 connman_network_set_index(network, -1);
865 connman_network_set_name(network, modem->operator);
867 if (modem->has_strength)
868 connman_network_set_strength(network, modem->strength);
870 connman_network_set_roaming(network, modem->roaming);
872 while (dbus_message_iter_get_arg_type(dict) == DBUS_TYPE_DICT_ENTRY) {
873 DBusMessageIter entry, value;
876 dbus_message_iter_recurse(dict, &entry);
877 dbus_message_iter_get_basic(&entry, &key);
879 dbus_message_iter_next(&entry);
880 dbus_message_iter_recurse(&entry, &value);
882 if (g_str_equal(key, "Type")) {
885 dbus_message_iter_get_basic(&value, &type);
886 if (g_strcmp0(type, "internet") != 0) {
887 DBG("path %p type %s", path, type);
890 } else if (g_str_equal(key, "Settings"))
891 update_ipv4_settings(&value, info);
892 else if (g_str_equal(key, "IPv6.Settings"))
893 update_ipv6_settings(&value, info);
894 else if (g_str_equal(key, "Active") == TRUE)
895 dbus_message_iter_get_basic(&value, &active);
897 dbus_message_iter_next(dict);
900 if (connman_device_add_network(device, network) != 0)
903 /* Connect only if requested to do so */
904 if (active && connman_network_get_connecting(network) == TRUE)
905 set_connected(info, active);
910 connman_network_unregister(network);
911 connman_network_unref(network);
912 g_hash_table_remove(network_hash, hash_path);
916 static void check_networks_reply(DBusPendingCall *call, void *user_data)
918 char *path = user_data;
919 struct modem_data *modem;
921 DBusMessageIter array, entry, value, properties;
923 DBG("path %s", path);
925 modem = g_hash_table_lookup(modem_hash, path);
928 if (modem->device == NULL)
931 reply = dbus_pending_call_steal_reply(call);
933 if (dbus_message_has_signature(reply, "a(oa{sv})") == FALSE)
936 dbus_message_iter_init(reply, &array);
938 dbus_message_iter_recurse(&array, &entry);
940 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRUCT) {
941 char const *network_path;
943 dbus_message_iter_recurse(&entry, &value);
944 dbus_message_iter_get_basic(&value, &network_path);
946 dbus_message_iter_next(&value);
947 dbus_message_iter_recurse(&value, &properties);
949 add_network(modem->device, network_path, &properties);
951 dbus_message_iter_next(&entry);
955 dbus_message_unref(reply);
957 dbus_pending_call_unref(call);
960 static void check_networks(struct modem_data *modem)
962 char const *path = modem->path;
964 DBG("modem %p path %s", modem, path);
966 call_ofono(path, OFONO_GPRS_INTERFACE, "GetContexts",
967 check_networks_reply, g_strdup(path), g_free,
971 static void modem_clear_network_errors(struct modem_data *modem)
973 struct connman_device *device = modem->device;
980 g_hash_table_iter_init(&i, network_hash);
982 while (g_hash_table_iter_next(&i, NULL, &value)) {
983 struct network_info *info = value;
985 if (connman_network_get_device(info->network) == device)
986 connman_network_clear_error(info->network);
990 static void modem_operator_name_changed(struct modem_data *modem,
993 struct connman_device *device = modem->device;
1000 if (modem->operator != NULL)
1001 g_free(modem->operator);
1002 modem->operator = g_strdup(name);
1004 for (g_hash_table_iter_init(&i, network_hash);
1005 g_hash_table_iter_next(&i, NULL, &value);) {
1006 struct network_info *info = value;
1008 if (connman_network_get_device(info->network) == device) {
1009 connman_network_set_name(info->network, name);
1010 connman_network_update(info->network);
1015 static void modem_strength_changed(struct modem_data *modem, uint8_t strength)
1017 struct connman_device *device = modem->device;
1021 modem->strength = strength;
1022 modem->has_strength = TRUE;
1027 for (g_hash_table_iter_init(&i, network_hash);
1028 g_hash_table_iter_next(&i, NULL, &value);) {
1029 struct network_info *info = value;
1031 if (connman_network_get_device(info->network) == device) {
1032 connman_network_set_strength(info->network, strength);
1033 connman_network_update(info->network);
1038 static void modem_roaming_changed(struct modem_data *modem,
1041 struct connman_device *device = modem->device;
1042 connman_bool_t roaming = FALSE;
1043 connman_bool_t registered = FALSE;
1044 connman_bool_t was_roaming = modem->roaming;
1048 if (g_str_equal(status, "roaming"))
1050 else if (g_str_equal(status, "registered"))
1053 registered = registered || roaming;
1055 if (modem->roaming == roaming && modem->registered == registered)
1058 modem->registered = registered;
1059 modem->roaming = roaming;
1061 if (roaming == was_roaming)
1067 g_hash_table_iter_init(&i, network_hash);
1069 while (g_hash_table_iter_next(&i, NULL, &value)) {
1070 struct network_info *info = value;
1072 if (connman_network_get_device(info->network) == device) {
1073 connman_network_set_roaming(info->network, roaming);
1074 connman_network_update(info->network);
1079 static void modem_registration_removed(struct modem_data *modem)
1081 modem->registered = FALSE;
1082 modem->roaming = FALSE;
1085 static void modem_registration_changed(struct modem_data *modem,
1086 DBusMessageIter *entry)
1088 DBusMessageIter iter;
1091 connman_uint8_t strength;
1092 char const *name, *status, *mcc_s;
1094 dbus_message_iter_get_basic(entry, &key);
1098 dbus_message_iter_next(entry);
1100 dbus_message_iter_recurse(entry, &iter);
1102 type = dbus_message_iter_get_arg_type(&iter);
1103 if (type != DBUS_TYPE_BYTE && type != DBUS_TYPE_STRING)
1106 if (g_str_equal(key, "Name") && type == DBUS_TYPE_STRING) {
1107 dbus_message_iter_get_basic(&iter, &name);
1108 modem_operator_name_changed(modem, name);
1109 } else if (g_str_equal(key, "Strength") && type == DBUS_TYPE_BYTE) {
1110 dbus_message_iter_get_basic(&iter, &strength);
1111 modem_strength_changed(modem, strength);
1112 } else if (g_str_equal(key, "Status") && type == DBUS_TYPE_STRING) {
1113 dbus_message_iter_get_basic(&iter, &status);
1114 modem_roaming_changed(modem, status);
1115 } else if (g_str_equal(key, "MobileCountryCode") &&
1116 type == DBUS_TYPE_STRING) {
1120 dbus_message_iter_get_basic(&iter, &mcc_s);
1126 alpha2 = mcc_country_codes[mcc - 200];
1127 connman_technology_set_regdom(alpha2);
1132 static gboolean reg_changed(DBusConnection *connection,
1133 DBusMessage *message, void *user_data)
1135 const char *path = dbus_message_get_path(message);
1136 struct modem_data *modem;
1137 DBusMessageIter iter;
1139 DBG("path %s", path);
1141 modem = g_hash_table_lookup(modem_hash, path);
1145 if (dbus_message_iter_init(message, &iter))
1146 modem_registration_changed(modem, &iter);
1151 static void check_registration_reply(DBusPendingCall *call, void *user_data)
1153 char const *path = user_data;
1154 struct modem_data *modem;
1156 DBusMessageIter array, dict, entry;
1158 DBG("path %s", path);
1160 modem = g_hash_table_lookup(modem_hash, path);
1164 reply = dbus_pending_call_steal_reply(call);
1166 if (dbus_message_iter_init(reply, &array) == FALSE)
1169 if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_ARRAY)
1172 dbus_message_iter_recurse(&array, &dict);
1173 while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
1174 dbus_message_iter_recurse(&dict, &entry);
1175 modem_registration_changed(modem, &entry);
1176 dbus_message_iter_next(&dict);
1180 dbus_message_unref(reply);
1182 dbus_pending_call_unref(call);
1185 static void check_registration(struct modem_data *modem)
1187 char const *path = modem->path;
1189 DBG("modem %p path %s", modem, path);
1191 call_ofono(path, OFONO_REGISTRATION_INTERFACE, GET_PROPERTIES,
1192 check_registration_reply, g_strdup(path), g_free,
1196 static void modem_gprs_changed(struct modem_data *modem,
1197 DBusMessageIter *entry)
1199 DBusMessageIter iter;
1204 dbus_message_iter_get_basic(entry, &key);
1208 dbus_message_iter_next(entry);
1210 dbus_message_iter_recurse(entry, &iter);
1212 type = dbus_message_iter_get_arg_type(&iter);
1214 if (type != DBUS_TYPE_BOOLEAN)
1217 dbus_message_iter_get_basic(&iter, &value);
1219 if (g_str_equal(key, "Attached") == TRUE) {
1220 DBG("Attached %d", value);
1222 modem->attached = value;
1225 modem_clear_network_errors(modem);
1226 } else if (g_str_equal(key, "Powered") == TRUE) {
1227 DBG("Powered %d", value);
1229 modem->powered = value;
1230 } else if (g_str_equal(key, "RoamingAllowed") == TRUE) {
1231 DBG("RoamingAllowed %d", value);
1233 modem->roaming_allowed = value;
1237 static void check_gprs_reply(DBusPendingCall *call, void *user_data)
1239 char const *path = user_data;
1240 struct modem_data *modem;
1242 DBusMessageIter array, dict, entry;
1244 DBG("path %s", path);
1246 modem = g_hash_table_lookup(modem_hash, path);
1250 reply = dbus_pending_call_steal_reply(call);
1252 if (dbus_message_iter_init(reply, &array) == FALSE)
1255 if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_ARRAY)
1258 dbus_message_iter_recurse(&array, &dict);
1259 while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
1260 dbus_message_iter_recurse(&dict, &entry);
1261 modem_gprs_changed(modem, &entry);
1262 dbus_message_iter_next(&dict);
1266 dbus_message_unref(reply);
1268 dbus_pending_call_unref(call);
1270 check_networks(modem);
1273 static void check_gprs(struct modem_data *modem)
1275 char const *path = modem->path;
1277 DBG("modem %p path %s", modem, path);
1279 call_ofono(path, OFONO_GPRS_INTERFACE, GET_PROPERTIES,
1280 check_gprs_reply, g_strdup(path), g_free,
1284 static void add_device(const char *path, const char *imsi)
1286 struct modem_data *modem;
1287 struct connman_device *device;
1289 DBG("path %s imsi %s", path, imsi);
1297 modem = g_hash_table_lookup(modem_hash, path);
1301 if (modem->device) {
1302 if (!g_strcmp0(imsi, connman_device_get_ident(modem->device)))
1305 modem_remove_device(modem);
1308 if (strlen(imsi) == 0)
1311 device = connman_device_create(imsi, CONNMAN_DEVICE_TYPE_CELLULAR);
1315 connman_device_set_ident(device, imsi);
1317 connman_device_set_string(device, "Path", path);
1319 connman_device_set_data(device, modem);
1321 if (connman_device_register(device) < 0) {
1322 connman_device_unref(device);
1326 modem->device = device;
1329 check_registration(modem);
1331 if (modem->has_gprs)
1335 static void sim_properties_reply(DBusPendingCall *call, void *user_data)
1337 const char *path = user_data;
1338 const char *imsi = NULL;
1340 DBusMessageIter array, dict;
1342 DBG("path %s", path);
1344 reply = dbus_pending_call_steal_reply(call);
1346 if (dbus_message_iter_init(reply, &array) == FALSE)
1349 if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_ARRAY)
1352 dbus_message_iter_recurse(&array, &dict);
1354 while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
1355 DBusMessageIter entry, value;
1358 dbus_message_iter_recurse(&dict, &entry);
1359 dbus_message_iter_get_basic(&entry, &key);
1361 dbus_message_iter_next(&entry);
1362 dbus_message_iter_recurse(&entry, &value);
1364 if (g_str_equal(key, "SubscriberIdentity")) {
1365 dbus_message_iter_get_basic(&value, &imsi);
1366 add_device(path, imsi);
1369 dbus_message_iter_next(&dict);
1373 dbus_message_unref(reply);
1375 dbus_pending_call_unref(call);
1378 static void get_imsi(const char *path)
1380 DBG("path %s", path);
1382 call_ofono(path, OFONO_SIM_INTERFACE, GET_PROPERTIES,
1383 sim_properties_reply, g_strdup(path), g_free,
1387 static int gprs_change_powered(const char *path, dbus_bool_t powered)
1389 DBG("path %s powered %d", path, powered);
1391 return set_property(path, OFONO_GPRS_INTERFACE, "Powered",
1392 DBUS_TYPE_BOOLEAN, &powered,
1396 static int modem_change_powered(const char *path, dbus_bool_t powered)
1398 DBG("path %s powered %d", path, powered);
1400 return set_property(path, OFONO_MODEM_INTERFACE, "Powered",
1401 DBUS_TYPE_BOOLEAN, &powered,
1406 static gboolean modem_has_interface(DBusMessageIter *array,
1407 char const *interface)
1409 DBusMessageIter entry;
1411 dbus_message_iter_recurse(array, &entry);
1413 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
1414 const char *element;
1416 dbus_message_iter_get_basic(&entry, &element);
1418 if (g_strcmp0(interface, element) == 0)
1421 dbus_message_iter_next(&entry);
1427 static gboolean modem_has_sim(DBusMessageIter *array)
1429 return modem_has_interface(array, OFONO_SIM_INTERFACE);
1432 static gboolean modem_has_reg(DBusMessageIter *array)
1434 return modem_has_interface(array, OFONO_REGISTRATION_INTERFACE);
1437 static gboolean modem_has_gprs(DBusMessageIter *array)
1439 return modem_has_interface(array, OFONO_GPRS_INTERFACE);
1442 static void add_modem(const char *path, DBusMessageIter *prop)
1444 struct modem_data *modem;
1445 dbus_bool_t powered = FALSE;
1446 dbus_bool_t online = FALSE;
1447 dbus_bool_t locked = FALSE;
1448 gboolean has_sim = FALSE;
1449 gboolean has_reg = FALSE;
1450 gboolean has_gprs = FALSE;
1452 modem = g_hash_table_lookup(modem_hash, path);
1457 modem = g_try_new0(struct modem_data, 1);
1461 modem->path = g_strdup(path);
1462 modem->device = NULL;
1463 modem->available = TRUE;
1465 g_hash_table_insert(modem_hash, g_strdup(path), modem);
1467 while (dbus_message_iter_get_arg_type(prop) == DBUS_TYPE_DICT_ENTRY) {
1468 DBusMessageIter entry, value;
1471 dbus_message_iter_recurse(prop, &entry);
1472 dbus_message_iter_get_basic(&entry, &key);
1474 dbus_message_iter_next(&entry);
1475 dbus_message_iter_recurse(&entry, &value);
1477 if (g_str_equal(key, "Powered") == TRUE)
1478 dbus_message_iter_get_basic(&value, &powered);
1479 else if (g_str_equal(key, "Lockdown") == TRUE)
1480 dbus_message_iter_get_basic(&value, &locked);
1481 else if (g_str_equal(key, "Interfaces") == TRUE) {
1482 has_sim = modem_has_sim(&value);
1483 has_reg = modem_has_reg(&value);
1484 has_gprs = modem_has_gprs(&value);
1487 dbus_message_iter_next(prop);
1494 modem_change_powered(path, TRUE);
1496 modem->has_sim = has_sim;
1497 modem->has_reg = has_reg;
1498 modem->has_gprs = has_gprs;
1500 update_modem_online(modem, online);
1506 static void manager_modems_reply(DBusPendingCall *call, void *user_data)
1510 DBusMessageIter array, dict;
1514 reply = dbus_pending_call_steal_reply(call);
1516 if (dbus_message_has_signature(reply, "a(oa{sv})") == FALSE)
1519 dbus_error_init(&error);
1521 if (dbus_set_error_from_message(&error, reply)) {
1522 connman_error("ModemManager.GetModems() %s %s",
1523 error.name, error.message);
1524 dbus_error_free(&error);
1528 if (dbus_message_iter_init(reply, &array) == FALSE)
1531 dbus_message_iter_recurse(&array, &dict);
1533 while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_STRUCT) {
1534 DBusMessageIter value, properties;
1535 const char *modem_path;
1537 dbus_message_iter_recurse(&dict, &value);
1538 dbus_message_iter_get_basic(&value, &modem_path);
1540 dbus_message_iter_next(&value);
1541 dbus_message_iter_recurse(&value, &properties);
1544 add_modem(modem_path, &properties);
1546 dbus_message_iter_next(&dict);
1550 dbus_message_unref(reply);
1552 dbus_pending_call_unref(call);
1555 static void ofono_connect(DBusConnection *connection, void *user_data)
1557 DBG("connection %p", connection);
1559 modem_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
1560 g_free, remove_modem);
1562 network_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
1563 NULL, remove_network);
1565 call_ofono("/", OFONO_MANAGER_INTERFACE, GET_MODEMS,
1566 manager_modems_reply, NULL, NULL,
1570 static void ofono_disconnect(DBusConnection *connection, void *user_data)
1572 DBG("connection %p", connection);
1574 if (modem_hash == NULL)
1577 g_hash_table_destroy(modem_hash);
1582 static gboolean modem_changed(DBusConnection *connection, DBusMessage *message,
1585 const char *path = dbus_message_get_path(message);
1586 struct modem_data *modem;
1587 DBusMessageIter iter, value;
1590 DBG("path %s", path);
1592 modem = g_hash_table_lookup(modem_hash, path);
1596 if (dbus_message_iter_init(message, &iter) == FALSE)
1599 dbus_message_iter_get_basic(&iter, &key);
1601 dbus_message_iter_next(&iter);
1602 dbus_message_iter_recurse(&iter, &value);
1604 if (g_str_equal(key, "Powered") == TRUE) {
1605 dbus_bool_t powered;
1607 dbus_message_iter_get_basic(&value, &powered);
1608 if (powered == TRUE)
1611 modem->has_sim = FALSE;
1612 modem->has_reg = FALSE;
1613 modem->has_gprs = FALSE;
1615 modem_remove_device(modem);
1616 } else if (g_str_equal(key, "Online") == TRUE) {
1619 dbus_message_iter_get_basic(&value, &online);
1621 update_modem_online(modem, online);
1622 } else if (g_str_equal(key, "Lockdown") == TRUE) {
1625 dbus_message_iter_get_basic(&value, &locked);
1628 modem_change_powered(path, TRUE);
1630 } else if (g_str_equal(key, "Interfaces") == TRUE) {
1631 gboolean has_sim = modem_has_sim(&value);
1632 gboolean has_reg = modem_has_reg(&value);
1633 gboolean had_reg = modem->has_reg;
1634 gboolean has_gprs = modem_has_gprs(&value);
1635 gboolean had_gprs = modem->has_gprs;
1637 modem->has_sim = has_sim;
1638 modem->has_reg = has_reg;
1639 modem->has_gprs = has_gprs;
1641 if (modem->device == NULL) {
1643 get_imsi(modem->path);
1644 } else if (!has_sim) {
1645 modem_remove_device(modem);
1647 if (has_reg && !had_reg)
1648 check_registration(modem);
1649 else if (had_reg && !has_reg)
1650 modem_registration_removed(modem);
1652 if (has_gprs && !had_gprs) {
1653 gprs_change_powered(modem->path, TRUE);
1662 static gboolean sim_changed(DBusConnection *connection, DBusMessage *message,
1665 const char *path = dbus_message_get_path(message);
1666 struct modem_data *modem;
1667 DBusMessageIter iter, value;
1670 DBG("path %s", path);
1672 modem = g_hash_table_lookup(modem_hash, path);
1676 if (dbus_message_iter_init(message, &iter) == FALSE)
1679 dbus_message_iter_get_basic(&iter, &key);
1681 dbus_message_iter_next(&iter);
1682 dbus_message_iter_recurse(&iter, &value);
1684 if (g_str_equal(key, "SubscriberIdentity") == TRUE) {
1687 dbus_message_iter_get_basic(&value, &imsi);
1689 add_device(path, imsi);
1690 } else if (g_str_equal(key, "Present") == TRUE) {
1691 dbus_bool_t present;
1693 dbus_message_iter_get_basic(&value, &present);
1698 if (modem->device != NULL)
1699 modem_remove_device(modem);
1701 modem->has_gprs = FALSE;
1702 modem->has_reg = FALSE;
1708 static gboolean gprs_changed(DBusConnection *connection, DBusMessage *message,
1711 const char *path = dbus_message_get_path(message);
1712 struct modem_data *modem;
1713 DBusMessageIter iter;
1715 DBG("path %s", path);
1717 modem = g_hash_table_lookup(modem_hash, path);
1721 if (dbus_message_iter_init(message, &iter))
1722 modem_gprs_changed(modem, &iter);
1727 static gboolean context_added(DBusConnection *connection,
1728 DBusMessage *message, void *user_data)
1730 const char *path = dbus_message_get_path(message);
1731 const char *network_path;
1732 struct modem_data *modem;
1733 DBusMessageIter iter, properties;
1735 DBG("path %s", path);
1737 modem = g_hash_table_lookup(modem_hash, path);
1738 if (modem == NULL || modem->device == NULL)
1741 if (dbus_message_iter_init(message, &iter) == FALSE)
1744 dbus_message_iter_get_basic(&iter, &network_path);
1746 dbus_message_iter_next(&iter);
1747 dbus_message_iter_recurse(&iter, &properties);
1749 add_network(modem->device, network_path, &properties);
1754 static gboolean context_removed(DBusConnection *connection,
1755 DBusMessage *message, void *user_data)
1757 const char *path = dbus_message_get_path(message);
1758 const char *network_path, *identifier;
1759 struct modem_data *modem;
1760 struct network_info *info;
1761 DBusMessageIter iter;
1763 DBG("path %s", path);
1765 modem = g_hash_table_lookup(modem_hash, path);
1766 if (modem == NULL || modem->device == NULL)
1769 if (dbus_message_iter_init(message, &iter) == FALSE)
1772 dbus_message_iter_get_basic(&iter, &network_path);
1774 info = g_hash_table_lookup(network_hash, network_path);
1778 identifier = connman_network_get_identifier(info->network);
1779 connman_device_remove_network(modem->device, identifier);
1784 static gboolean modem_added(DBusConnection *connection,
1785 DBusMessage *message, void *user_data)
1787 DBusMessageIter iter, properties;
1788 const char *modem_path;
1792 if (dbus_message_iter_init(message, &iter) == FALSE)
1795 dbus_message_iter_get_basic(&iter, &modem_path);
1797 dbus_message_iter_next(&iter);
1798 dbus_message_iter_recurse(&iter, &properties);
1800 add_modem(modem_path, &properties);
1805 static gboolean modem_removed(DBusConnection *connection,
1806 DBusMessage *message, void *user_data)
1808 DBusMessageIter iter;
1809 const char *modem_path;
1813 if (dbus_message_iter_init(message, &iter) == FALSE)
1816 dbus_message_iter_get_basic(&iter, &modem_path);
1818 g_hash_table_remove(modem_hash, modem_path);
1823 static gboolean context_changed(DBusConnection *connection,
1824 DBusMessage *message, void *user_data)
1826 const char *path = dbus_message_get_path(message);
1827 struct network_info *info;
1828 DBusMessageIter iter, value;
1831 DBG("path %s", path);
1833 info = g_hash_table_lookup(network_hash, path);
1837 if (!pending_network_is_available(info->network)) {
1838 g_hash_table_remove(network_hash, path);
1842 if (dbus_message_iter_init(message, &iter) == FALSE)
1845 dbus_message_iter_get_basic(&iter, &key);
1847 dbus_message_iter_next(&iter);
1848 dbus_message_iter_recurse(&iter, &value);
1852 if (g_str_equal(key, "Settings") == TRUE)
1853 update_ipv4_settings(&value, info);
1854 else if (g_str_equal(key, "IPv6.Settings"))
1855 update_ipv6_settings(&value, info);
1856 else if (g_str_equal(key, "Active") == TRUE) {
1859 dbus_message_iter_get_basic(&value, &active);
1861 if (active == FALSE)
1862 set_connected(info, active);
1864 /* Connect only if requested to do so */
1865 if (active == TRUE &&
1866 connman_network_get_connecting(info->network) == TRUE)
1867 set_connected(info, active);
1874 static guint reg_watch;
1875 static guint sim_watch;
1876 static guint gprs_watch;
1877 static guint context_added_watch;
1878 static guint context_removed_watch;
1879 static guint modem_watch;
1880 static guint modem_added_watch;
1881 static guint modem_removed_watch;
1882 static guint context_watch;
1884 static int ofono_init(void)
1888 connection = connman_dbus_get_connection();
1889 if (connection == NULL)
1892 watch = g_dbus_add_service_watch(connection, OFONO_SERVICE,
1893 ofono_connect, ofono_disconnect, NULL, NULL);
1895 reg_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1896 OFONO_REGISTRATION_INTERFACE,
1901 gprs_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1902 OFONO_GPRS_INTERFACE,
1907 context_added_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1908 OFONO_GPRS_INTERFACE,
1913 context_removed_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1914 OFONO_GPRS_INTERFACE,
1919 modem_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1920 OFONO_MODEM_INTERFACE,
1925 sim_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1926 OFONO_SIM_INTERFACE,
1931 modem_added_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1932 OFONO_MANAGER_INTERFACE,
1937 modem_removed_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1938 OFONO_MANAGER_INTERFACE,
1943 context_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1944 OFONO_CONTEXT_INTERFACE,
1949 if (watch == 0 || gprs_watch == 0 || context_added_watch == 0 ||
1950 context_removed_watch == 0 || modem_watch == 0 ||
1951 reg_watch == 0 || sim_watch == 0 ||
1952 modem_added_watch == 0 || modem_removed_watch == 0 ||
1953 context_watch == 0) {
1958 err = connman_network_driver_register(&network_driver);
1962 err = connman_device_driver_register(&modem_driver);
1964 connman_network_driver_unregister(&network_driver);
1971 g_dbus_remove_watch(connection, watch);
1972 g_dbus_remove_watch(connection, sim_watch);
1973 g_dbus_remove_watch(connection, reg_watch);
1974 g_dbus_remove_watch(connection, gprs_watch);
1975 g_dbus_remove_watch(connection, context_added_watch);
1976 g_dbus_remove_watch(connection, context_removed_watch);
1977 g_dbus_remove_watch(connection, modem_watch);
1978 g_dbus_remove_watch(connection, modem_added_watch);
1979 g_dbus_remove_watch(connection, modem_removed_watch);
1980 g_dbus_remove_watch(connection, context_watch);
1982 dbus_connection_unref(connection);
1987 static void ofono_exit(void)
1989 g_dbus_remove_watch(connection, watch);
1990 g_dbus_remove_watch(connection, sim_watch);
1991 g_dbus_remove_watch(connection, reg_watch);
1992 g_dbus_remove_watch(connection, gprs_watch);
1993 g_dbus_remove_watch(connection, context_added_watch);
1994 g_dbus_remove_watch(connection, context_removed_watch);
1995 g_dbus_remove_watch(connection, modem_watch);
1996 g_dbus_remove_watch(connection, modem_added_watch);
1997 g_dbus_remove_watch(connection, modem_removed_watch);
1998 g_dbus_remove_watch(connection, context_watch);
2000 ofono_disconnect(connection, NULL);
2002 connman_device_driver_unregister(&modem_driver);
2003 connman_network_driver_unregister(&network_driver);
2005 dbus_connection_unref(connection);
2008 CONNMAN_PLUGIN_DEFINE(ofono, "oFono telephony plugin", VERSION,
2009 CONNMAN_PLUGIN_PRIORITY_DEFAULT, ofono_init, ofono_exit)