5 * Copyright (C) 2007-2010 Intel Corporation. All rights reserved.
6 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
7 * Copyright (C) 2011 BWM Car IT GmbH. All rights reserved.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
35 #define CONNMAN_API_SUBJECT_TO_CHANGE
36 #include <connman/plugin.h>
37 #include <connman/device.h>
38 #include <connman/network.h>
39 #include <connman/inet.h>
40 #include <connman/dbus.h>
41 #include <connman/log.h>
42 #include <connman/technology.h>
46 #define uninitialized_var(x) x = x
48 #define OFONO_SERVICE "org.ofono"
50 #define OFONO_MANAGER_INTERFACE OFONO_SERVICE ".Manager"
51 #define OFONO_MODEM_INTERFACE OFONO_SERVICE ".Modem"
52 #define OFONO_SIM_INTERFACE OFONO_SERVICE ".SimManager"
53 #define OFONO_NETREG_INTERFACE OFONO_SERVICE ".NetworkRegistration"
54 #define OFONO_CM_INTERFACE OFONO_SERVICE ".ConnectionManager"
55 #define OFONO_CONTEXT_INTERFACE OFONO_SERVICE ".ConnectionContext"
56 #define OFONO_CDMA_CM_INTERFACE OFONO_SERVICE ".cdma.ConnectionManager"
57 #define OFONO_CDMA_NETREG_INTERFACE OFONO_SERVICE ".cdma.NetworkRegistration"
59 #define MODEM_ADDED "ModemAdded"
60 #define MODEM_REMOVED "ModemRemoved"
61 #define PROPERTY_CHANGED "PropertyChanged"
62 #define CONTEXT_ADDED "ContextAdded"
63 #define CONTEXT_REMOVED "ContextRemoved"
65 #define GET_PROPERTIES "GetProperties"
66 #define SET_PROPERTY "SetProperty"
67 #define GET_MODEMS "GetModems"
68 #define GET_CONTEXTS "GetContexts"
74 OFONO_API_NETREG = 0x2,
76 OFONO_API_CDMA_NETREG = 0x8,
77 OFONO_API_CDMA_CM = 0x10,
81 * The way this plugin works is following:
83 * powered -> SubscriberIdentity or Online = True -> gprs, context ->
84 * attached -> netreg -> ready
86 * Enabling and disabling modems are steered through the rfkill
87 * interface. That means when ConnMan toggles the rfkill bit oFono
88 * will add or remove the modems.
90 * ConnMan will always power up (set Powered and Online) the
91 * modems. No need to power them down because this will be done
92 * through the rfkill inteface.
95 static DBusConnection *connection;
97 static GHashTable *modem_hash;
98 static GHashTable *context_hash;
100 struct network_context {
104 enum connman_ipconfig_method ipv4_method;
105 struct connman_ipaddress *ipv4_address;
106 char *ipv4_nameservers;
108 enum connman_ipconfig_method ipv6_method;
109 struct connman_ipaddress *ipv6_address;
110 char *ipv6_nameservers;
116 struct connman_device *device;
117 struct connman_network *network;
119 struct network_context *context;
121 /* Modem Interface */
123 connman_bool_t powered;
124 connman_bool_t online;
126 connman_bool_t ignore;
128 connman_bool_t set_powered;
129 connman_bool_t set_online;
131 /* CDMA ConnectionManager Interface */
132 connman_bool_t cdma_cm_powered;
134 /* ConnectionManager Interface */
135 connman_bool_t attached;
136 connman_bool_t cm_powered;
138 connman_bool_t set_cm_powered;
140 /* ConnectionContext Interface */
141 connman_bool_t active;
142 connman_bool_t set_active;
144 /* SimManager Interface */
147 /* Netreg Interface */
150 uint8_t data_strength; /* 1xEVDO signal strength */
151 connman_bool_t roaming;
154 DBusPendingCall *call_set_property;
155 DBusPendingCall *call_get_properties;
156 DBusPendingCall *call_get_contexts;
159 static char *get_ident(const char *path)
166 pos = strrchr(path, '/');
173 static struct network_context *network_context_alloc(const char *path)
175 struct network_context *context;
177 context = g_try_new0(struct network_context, 1);
181 context->path = g_strdup(path);
184 context->ipv4_method = CONNMAN_IPCONFIG_METHOD_UNKNOWN;
185 context->ipv4_address = NULL;
186 context->ipv4_nameservers = NULL;
188 context->ipv6_method = CONNMAN_IPCONFIG_METHOD_UNKNOWN;
189 context->ipv6_address = NULL;
190 context->ipv6_nameservers = NULL;
195 static void network_context_free(struct network_context *context)
197 g_free(context->path);
199 connman_ipaddress_free(context->ipv4_address);
200 g_free(context->ipv4_nameservers);
202 connman_ipaddress_free(context->ipv6_address);
203 g_free(context->ipv6_nameservers);
208 static void set_connected(struct modem_data *modem)
210 connman_bool_t setip = FALSE;
212 DBG("%s", modem->path);
214 connman_network_set_index(modem->network, modem->context->index);
216 switch (modem->context->ipv4_method) {
217 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
218 case CONNMAN_IPCONFIG_METHOD_OFF:
219 case CONNMAN_IPCONFIG_METHOD_MANUAL:
220 case CONNMAN_IPCONFIG_METHOD_AUTO:
223 case CONNMAN_IPCONFIG_METHOD_FIXED:
224 connman_network_set_ipv4_method(modem->network,
225 modem->context->ipv4_method);
226 connman_network_set_ipaddress(modem->network,
227 modem->context->ipv4_address);
228 connman_network_set_nameservers(modem->network,
229 modem->context->ipv4_nameservers);
233 case CONNMAN_IPCONFIG_METHOD_DHCP:
234 connman_network_set_ipv4_method(modem->network,
235 modem->context->ipv4_method);
240 switch (modem->context->ipv6_method) {
241 case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
242 case CONNMAN_IPCONFIG_METHOD_OFF:
243 case CONNMAN_IPCONFIG_METHOD_MANUAL:
244 case CONNMAN_IPCONFIG_METHOD_DHCP:
245 case CONNMAN_IPCONFIG_METHOD_AUTO:
248 case CONNMAN_IPCONFIG_METHOD_FIXED:
249 connman_network_set_ipv6_method(modem->network,
250 modem->context->ipv6_method);
251 connman_network_set_ipaddress(modem->network,
252 modem->context->ipv6_address);
258 connman_network_set_connected(modem->network, TRUE);
261 static void set_disconnected(struct modem_data *modem)
263 DBG("%s", modem->path);
265 connman_network_set_connected(modem->network, FALSE);
268 typedef void (*set_property_cb)(struct modem_data *data,
269 connman_bool_t success);
270 typedef void (*get_properties_cb)(struct modem_data *data,
271 DBusMessageIter *dict);
273 struct property_info {
274 struct modem_data *modem;
276 const char *interface;
277 const char *property;
278 set_property_cb set_property_cb;
279 get_properties_cb get_properties_cb;
282 static void set_property_reply(DBusPendingCall *call, void *user_data)
284 struct property_info *info = user_data;
287 connman_bool_t success = TRUE;
289 DBG("%s path %s %s.%s", info->modem->path,
290 info->path, info->interface, info->property);
292 info->modem->call_set_property = NULL;
294 dbus_error_init(&error);
296 reply = dbus_pending_call_steal_reply(call);
298 if (dbus_set_error_from_message(&error, reply)) {
299 connman_error("Failed to change property: %s %s.%s: %s %s",
300 info->path, info->interface, info->property,
301 error.name, error.message);
302 dbus_error_free(&error);
306 if (info->set_property_cb != NULL)
307 (*info->set_property_cb)(info->modem, success);
309 dbus_message_unref(reply);
311 dbus_pending_call_unref(call);
314 static int set_property(struct modem_data *modem,
315 const char *path, const char *interface,
316 const char *property, int type, void *value,
317 set_property_cb notify)
319 DBusMessage *message;
320 DBusMessageIter iter;
321 struct property_info *info;
323 DBG("%s path %s %s.%s", modem->path, path, interface, property);
325 if (modem->call_set_property != NULL) {
326 connman_error("Pending SetProperty");
330 message = dbus_message_new_method_call(OFONO_SERVICE, path,
331 interface, SET_PROPERTY);
335 dbus_message_iter_init_append(message, &iter);
336 connman_dbus_property_append_basic(&iter, property, type, value);
338 if (dbus_connection_send_with_reply(connection, message,
339 &modem->call_set_property, TIMEOUT) == FALSE) {
340 connman_error("Failed to change property: %s %s.%s",
341 path, interface, property);
342 dbus_message_unref(message);
346 if (modem->call_set_property == NULL) {
347 connman_error("D-Bus connection not available");
348 dbus_message_unref(message);
352 info = g_try_new0(struct property_info, 1);
354 dbus_message_unref(message);
360 info->interface = interface;
361 info->property = property;
362 info->set_property_cb = notify;
364 dbus_pending_call_set_notify(modem->call_set_property,
365 set_property_reply, info, g_free);
367 dbus_message_unref(message);
372 static void get_properties_reply(DBusPendingCall *call, void *user_data)
374 struct property_info *info = user_data;
375 DBusMessageIter array, dict;
379 DBG("%s path %s %s", info->modem->path, info->path, info->interface);
381 info->modem->call_get_properties = NULL;
383 dbus_error_init(&error);
385 reply = dbus_pending_call_steal_reply(call);
387 if (dbus_set_error_from_message(&error, reply)) {
388 connman_error("Failed to get properties: %s %s: %s %s",
389 info->path, info->interface,
390 error.name, error.message);
391 dbus_error_free(&error);
396 if (dbus_message_iter_init(reply, &array) == FALSE)
399 if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_ARRAY)
402 dbus_message_iter_recurse(&array, &dict);
404 if (info->get_properties_cb != NULL)
405 (*info->get_properties_cb)(info->modem, &dict);
409 dbus_message_unref(reply);
411 dbus_pending_call_unref(call);
414 static int get_properties(const char *path, const char *interface,
415 get_properties_cb notify,
416 struct modem_data *modem)
418 DBusMessage *message;
419 struct property_info *info;
421 DBG("%s path %s %s", modem->path, path, interface);
423 if (modem->call_get_properties != NULL) {
424 connman_error("Pending GetProperties");
428 message = dbus_message_new_method_call(OFONO_SERVICE, path,
429 interface, GET_PROPERTIES);
433 if (dbus_connection_send_with_reply(connection, message,
434 &modem->call_get_properties, TIMEOUT) == FALSE) {
435 connman_error("Failed to call %s.GetProperties()", interface);
436 dbus_message_unref(message);
440 if (modem->call_get_properties == NULL) {
441 connman_error("D-Bus connection not available");
442 dbus_message_unref(message);
446 info = g_try_new0(struct property_info, 1);
448 dbus_message_unref(message);
454 info->interface = interface;
455 info->get_properties_cb = notify;
457 dbus_pending_call_set_notify(modem->call_get_properties,
458 get_properties_reply, info, g_free);
460 dbus_message_unref(message);
465 static void context_set_active_reply(struct modem_data *modem,
466 connman_bool_t success)
468 DBG("%s", modem->path);
470 if (success == TRUE) {
472 * Don't handle do anything on success here. oFono will send
473 * the change via PropertyChanged singal.
479 * Active = True might fail due a timeout. That means oFono
480 * still tries to go online. If we retry to set Active = True,
481 * we just get a InProgress error message. Should we power
482 * cycle the modem in such cases?
485 connman_network_set_error(modem->network,
486 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
489 static int context_set_active(struct modem_data *modem)
491 dbus_bool_t active = TRUE;
493 DBG("%s", modem->path);
495 return set_property(modem, modem->context->path,
496 OFONO_CONTEXT_INTERFACE,
497 "Active", DBUS_TYPE_BOOLEAN,
499 context_set_active_reply);
502 static int context_set_inactive(struct modem_data *modem)
504 dbus_bool_t active = FALSE;
507 DBG("%s", modem->path);
509 err = set_property(modem, modem->context->path,
510 OFONO_CONTEXT_INTERFACE,
511 "Active", DBUS_TYPE_BOOLEAN,
514 if (err == -EINPROGRESS)
520 static void cdma_cm_set_powered_reply(struct modem_data *modem,
521 connman_bool_t success)
523 DBG("%s", modem->path);
525 if (success == TRUE) {
527 * Don't handle do anything on success here. oFono will send
528 * the change via PropertyChanged singal.
534 * Powered = True might fail due a timeout. That means oFono
535 * still tries to go online. If we retry to set Powered = True,
536 * we just get a InProgress error message. Should we power
537 * cycle the modem in such cases?
540 connman_network_set_error(modem->network,
541 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
544 static int cdma_cm_set_powered(struct modem_data *modem)
546 dbus_bool_t powered = TRUE;
548 DBG("%s", modem->path);
550 return set_property(modem, modem->path, OFONO_CDMA_CM_INTERFACE,
551 "Powered", DBUS_TYPE_BOOLEAN, &powered,
552 cdma_cm_set_powered_reply);
555 static int cdma_cm_shutdown(struct modem_data *modem)
557 dbus_bool_t powered = FALSE;
560 DBG("%s", modem->path);
562 err = set_property(modem, modem->path, OFONO_CDMA_CM_INTERFACE,
563 "Powered", DBUS_TYPE_BOOLEAN, &powered, NULL);
564 if (err == -EINPROGRESS)
570 static void modem_set_online_reply(struct modem_data *modem,
571 connman_bool_t success)
573 DBG("%s", modem->path);
575 if (success == TRUE) {
577 * Don't handle do anything on success here. oFono will send
578 * the change via PropertyChanged singal.
583 modem->set_online = FALSE;
586 static int modem_set_online(struct modem_data *modem)
588 DBG("%s", modem->path);
590 modem->set_online = TRUE;
592 return set_property(modem, modem->path,
593 OFONO_MODEM_INTERFACE,
594 "Online", DBUS_TYPE_BOOLEAN,
596 modem_set_online_reply);
599 static void cm_set_powered_reply(struct modem_data *modem,
600 connman_bool_t success)
602 DBG("%s", modem->path);
604 if (success == TRUE) {
606 * Don't handle do anything on success here. oFono will send
607 * the change via PropertyChanged singal.
612 modem->set_cm_powered = FALSE;
615 static int cm_set_powered(struct modem_data *modem)
617 DBG("%s", modem->path);
619 modem->set_cm_powered = TRUE;
621 return set_property(modem, modem->path,
623 "Powered", DBUS_TYPE_BOOLEAN,
624 &modem->set_cm_powered,
625 cm_set_powered_reply);
628 static int modem_set_powered(struct modem_data *modem)
630 DBG("%s", modem->path);
632 modem->set_powered = TRUE;
634 return set_property(modem, modem->path,
635 OFONO_MODEM_INTERFACE,
636 "Powered", DBUS_TYPE_BOOLEAN,
641 static int modem_set_unpowered(struct modem_data *modem)
643 DBG("%s", modem->path);
645 modem->set_powered = FALSE;
647 return set_property(modem, modem->path,
648 OFONO_MODEM_INTERFACE,
649 "Powered", DBUS_TYPE_BOOLEAN,
654 static connman_bool_t has_interface(uint8_t interfaces,
657 if ((interfaces & api) == api)
663 static uint8_t extract_interfaces(DBusMessageIter *array)
665 DBusMessageIter entry;
666 uint8_t interfaces = 0;
668 dbus_message_iter_recurse(array, &entry);
670 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
673 dbus_message_iter_get_basic(&entry, &name);
675 if (g_str_equal(name, OFONO_SIM_INTERFACE) == TRUE)
676 interfaces |= OFONO_API_SIM;
677 else if (g_str_equal(name, OFONO_NETREG_INTERFACE) == TRUE)
678 interfaces |= OFONO_API_NETREG;
679 else if (g_str_equal(name, OFONO_CM_INTERFACE) == TRUE)
680 interfaces |= OFONO_API_CM;
681 else if (g_str_equal(name, OFONO_CDMA_CM_INTERFACE) == TRUE)
682 interfaces |= OFONO_API_CDMA_CM;
683 else if (g_str_equal(name, OFONO_CDMA_NETREG_INTERFACE) == TRUE)
684 interfaces |= OFONO_API_CDMA_NETREG;
686 dbus_message_iter_next(&entry);
692 static char *extract_nameservers(DBusMessageIter *array)
694 DBusMessageIter entry;
695 char *nameservers = NULL;
698 dbus_message_iter_recurse(array, &entry);
700 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
701 const char *nameserver;
703 dbus_message_iter_get_basic(&entry, &nameserver);
705 if (nameservers == NULL) {
706 nameservers = g_strdup(nameserver);
709 nameservers = g_strdup_printf("%s %s", tmp, nameserver);
713 dbus_message_iter_next(&entry);
719 static void extract_ipv4_settings(DBusMessageIter *array,
720 struct network_context *context)
722 DBusMessageIter dict;
723 char *address = NULL, *netmask = NULL, *gateway = NULL;
724 char *nameservers = NULL;
725 const char *interface = NULL;
728 if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
731 dbus_message_iter_recurse(array, &dict);
733 while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
734 DBusMessageIter entry, value;
735 const char *key, *val;
737 dbus_message_iter_recurse(&dict, &entry);
738 dbus_message_iter_get_basic(&entry, &key);
740 dbus_message_iter_next(&entry);
741 dbus_message_iter_recurse(&entry, &value);
743 if (g_str_equal(key, "Interface") == TRUE) {
744 dbus_message_iter_get_basic(&value, &interface);
746 DBG("Interface %s", interface);
748 index = connman_inet_ifindex(interface);
750 DBG("index %d", index);
751 } else if (g_str_equal(key, "Method") == TRUE) {
752 dbus_message_iter_get_basic(&value, &val);
754 DBG("Method %s", val);
756 if (g_strcmp0(val, "static") == 0) {
757 context->ipv4_method = CONNMAN_IPCONFIG_METHOD_FIXED;
758 } else if (g_strcmp0(val, "dhcp") == 0) {
759 context->ipv4_method = CONNMAN_IPCONFIG_METHOD_DHCP;
762 } else if (g_str_equal(key, "Address") == TRUE) {
763 dbus_message_iter_get_basic(&value, &val);
765 address = g_strdup(val);
767 DBG("Address %s", address);
768 } else if (g_str_equal(key, "Netmask") == TRUE) {
769 dbus_message_iter_get_basic(&value, &val);
771 netmask = g_strdup(val);
773 DBG("Netmask %s", netmask);
774 } else if (g_str_equal(key, "DomainNameServers") == TRUE) {
775 nameservers = extract_nameservers(&value);
777 DBG("Nameservers %s", nameservers);
778 } else if (g_str_equal(key, "Gateway") == TRUE) {
779 dbus_message_iter_get_basic(&value, &val);
781 gateway = g_strdup(val);
783 DBG("Gateway %s", gateway);
786 dbus_message_iter_next(&dict);
792 if (context->ipv4_method != CONNMAN_IPCONFIG_METHOD_FIXED)
795 context->ipv4_address = connman_ipaddress_alloc(CONNMAN_IPCONFIG_TYPE_IPV4);
796 if (context->ipv4_address == NULL)
799 context->index = index;
800 connman_ipaddress_set_ipv4(context->ipv4_address, address,
803 context->ipv4_nameservers = nameservers;
806 if (context->ipv4_nameservers != nameservers)
814 static void extract_ipv6_settings(DBusMessageIter *array,
815 struct network_context *context)
817 DBusMessageIter dict;
818 char *address = NULL, *gateway = NULL;
819 unsigned char prefix_length;
820 char *nameservers = NULL;
821 const char *interface = NULL;
824 if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
827 dbus_message_iter_recurse(array, &dict);
829 while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
830 DBusMessageIter entry, value;
831 const char *key, *val;
833 dbus_message_iter_recurse(&dict, &entry);
834 dbus_message_iter_get_basic(&entry, &key);
836 dbus_message_iter_next(&entry);
837 dbus_message_iter_recurse(&entry, &value);
839 if (g_str_equal(key, "Interface") == TRUE) {
840 dbus_message_iter_get_basic(&value, &interface);
842 DBG("Interface %s", interface);
844 index = connman_inet_ifindex(interface);
846 DBG("index %d", index);
847 } else if (g_str_equal(key, "Address") == TRUE) {
848 dbus_message_iter_get_basic(&value, &val);
850 address = g_strdup(val);
852 DBG("Address %s", address);
853 } else if (g_str_equal(key, "PrefixLength") == TRUE) {
854 dbus_message_iter_get_basic(&value, &prefix_length);
856 DBG("prefix length %d", prefix_length);
857 } else if (g_str_equal(key, "DomainNameServers") == TRUE) {
858 nameservers = extract_nameservers(&value);
860 DBG("Nameservers %s", nameservers);
861 } else if (g_str_equal(key, "Gateway") == TRUE) {
862 dbus_message_iter_get_basic(&value, &val);
864 gateway = g_strdup(val);
866 DBG("Gateway %s", gateway);
869 dbus_message_iter_next(&dict);
875 context->ipv6_method = CONNMAN_IPCONFIG_METHOD_FIXED;
877 context->ipv6_address =
878 connman_ipaddress_alloc(CONNMAN_IPCONFIG_TYPE_IPV6);
879 if (context->ipv6_address == NULL)
882 context->index = index;
883 connman_ipaddress_set_ipv6(context->ipv6_address, address,
884 prefix_length, gateway);
886 context->ipv6_nameservers = nameservers;
889 if (context->ipv6_nameservers != nameservers)
896 static connman_bool_t ready_to_create_device(struct modem_data *modem)
899 * There are three different modem types which behave slightly
901 * - GSM modems will expose the SIM interface then the
903 * - DUN modems will expose first a unique serial number (BDADDR)
904 * and then the CM interface.
905 * - CDMA modems will expose CM first and sometime later
906 * a unique serial number.
908 * This functions tests if we have the necessary information gathered
909 * before we are able to create a device.
912 if (modem->device != NULL)
915 if (modem->imsi != NULL || modem->serial != NULL)
921 static void create_device(struct modem_data *modem)
923 struct connman_device *device;
924 char *uninitialized_var(ident);
926 DBG("%s", modem->path);
928 if (modem->imsi != NULL)
930 else if (modem->serial != NULL)
931 ident = modem->serial;
933 if (connman_dbus_validate_ident(ident) == FALSE)
934 ident = connman_dbus_encode_string(ident);
936 ident = g_strdup(ident);
938 device = connman_device_create(ident, CONNMAN_DEVICE_TYPE_CELLULAR);
942 DBG("device %p", device);
944 connman_device_set_ident(device, ident);
946 connman_device_set_string(device, "Path", modem->path);
948 connman_device_set_data(device, modem);
950 if (connman_device_register(device) < 0) {
951 connman_error("Failed to register cellular device");
952 connman_device_unref(device);
956 modem->device = device;
962 static void destroy_device(struct modem_data *modem)
964 DBG("%s", modem->path);
966 connman_device_set_powered(modem->device, FALSE);
968 if (modem->network != NULL) {
969 connman_device_remove_network(modem->device, modem->network);
970 connman_network_unref(modem->network);
971 modem->network = NULL;
974 connman_device_unregister(modem->device);
975 connman_device_unref(modem->device);
977 modem->device = NULL;
980 static void add_network(struct modem_data *modem)
984 DBG("%s", modem->path);
986 if (modem->network != NULL)
989 modem->network = connman_network_create(modem->context->path,
990 CONNMAN_NETWORK_TYPE_CELLULAR);
991 if (modem->network == NULL)
994 DBG("network %p", modem->network);
996 connman_network_set_data(modem->network, modem);
998 connman_network_set_string(modem->network, "Path",
999 modem->context->path);
1001 connman_network_set_index(modem->network, modem->context->index);
1003 if (modem->name != NULL)
1004 connman_network_set_name(modem->network, modem->name);
1006 connman_network_set_name(modem->network, "");
1008 connman_network_set_strength(modem->network, modem->strength);
1010 group = get_ident(modem->context->path);
1011 connman_network_set_group(modem->network, group);
1013 connman_network_set_available(modem->network, TRUE);
1015 connman_network_set_bool(modem->network, "Roaming",
1018 if (connman_device_add_network(modem->device, modem->network) < 0) {
1019 connman_network_unref(modem->network);
1020 modem->network = NULL;
1025 static int add_cm_context(struct modem_data *modem, const char *context_path,
1026 DBusMessageIter *dict)
1028 const char *context_type;
1029 struct network_context *context = NULL;
1030 connman_bool_t active = FALSE;
1032 DBG("%s context path %s", modem->path, context_path);
1034 if (modem->context != NULL) {
1036 * We have already assigned a context to this modem
1037 * and we do only support one Internet context.
1042 context = network_context_alloc(context_path);
1043 if (context == NULL)
1046 while (dbus_message_iter_get_arg_type(dict) == DBUS_TYPE_DICT_ENTRY) {
1047 DBusMessageIter entry, value;
1050 dbus_message_iter_recurse(dict, &entry);
1051 dbus_message_iter_get_basic(&entry, &key);
1053 dbus_message_iter_next(&entry);
1054 dbus_message_iter_recurse(&entry, &value);
1056 if (g_str_equal(key, "Type") == TRUE) {
1057 dbus_message_iter_get_basic(&value, &context_type);
1059 DBG("%s context %s type %s", modem->path,
1060 context_path, context_type);
1061 } else if (g_str_equal(key, "Settings") == TRUE) {
1062 DBG("%s Settings", modem->path);
1064 extract_ipv4_settings(&value, context);
1065 } else if (g_str_equal(key, "IPv6.Settings") == TRUE) {
1066 DBG("%s IPv6.Settings", modem->path);
1068 extract_ipv6_settings(&value, context);
1069 } else if (g_str_equal(key, "Active") == TRUE) {
1070 dbus_message_iter_get_basic(&value, &active);
1072 DBG("%s Active %d", modem->path, active);
1075 dbus_message_iter_next(dict);
1078 if (g_strcmp0(context_type, "internet") != 0) {
1079 network_context_free(context);
1083 modem->context = context;
1084 modem->active = active;
1086 g_hash_table_replace(context_hash, g_strdup(context_path), modem);
1091 static void remove_cm_context(struct modem_data *modem,
1092 const char *context_path)
1094 if (modem->context == NULL)
1097 g_hash_table_remove(context_hash, context_path);
1099 network_context_free(modem->context);
1100 modem->context = NULL;
1103 static gboolean context_changed(DBusConnection *connection,
1104 DBusMessage *message,
1107 const char *context_path = dbus_message_get_path(message);
1108 struct modem_data *modem = NULL;
1109 DBusMessageIter iter, value;
1112 DBG("context_path %s", context_path);
1114 modem = g_hash_table_lookup(context_hash, context_path);
1118 if (dbus_message_iter_init(message, &iter) == FALSE)
1121 dbus_message_iter_get_basic(&iter, &key);
1123 dbus_message_iter_next(&iter);
1124 dbus_message_iter_recurse(&iter, &value);
1127 * oFono guarantees the ordering of Settings and
1128 * Active. Settings will always be send before Active = True.
1129 * That means we don't have to order here.
1131 if (g_str_equal(key, "Settings") == TRUE) {
1132 DBG("%s Settings", modem->path);
1134 extract_ipv4_settings(&value, modem->context);
1135 } else if (g_str_equal(key, "IPv6.Settings") == TRUE) {
1136 DBG("%s IPv6.Settings", modem->path);
1138 extract_ipv6_settings(&value, modem->context);
1139 } else if (g_str_equal(key, "Active") == TRUE) {
1140 dbus_message_iter_get_basic(&value, &modem->active);
1142 DBG("%s Active %d", modem->path, modem->active);
1144 if (modem->active == TRUE)
1145 set_connected(modem);
1147 set_disconnected(modem);
1153 static void cm_get_contexts_reply(DBusPendingCall *call, void *user_data)
1155 struct modem_data *modem = user_data;
1156 DBusMessageIter array, dict, entry, value;
1160 DBG("%s", modem->path);
1162 modem->call_get_contexts = NULL;
1164 reply = dbus_pending_call_steal_reply(call);
1166 dbus_error_init(&error);
1168 if (dbus_set_error_from_message(&error, reply) == TRUE) {
1169 connman_error("%s", error.message);
1170 dbus_error_free(&error);
1174 if (dbus_message_iter_init(reply, &array) == FALSE)
1177 if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_ARRAY)
1180 dbus_message_iter_recurse(&array, &dict);
1182 while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_STRUCT) {
1183 const char *context_path;
1185 dbus_message_iter_recurse(&dict, &entry);
1186 dbus_message_iter_get_basic(&entry, &context_path);
1188 dbus_message_iter_next(&entry);
1189 dbus_message_iter_recurse(&entry, &value);
1191 if (add_cm_context(modem, context_path, &value) == 0)
1194 dbus_message_iter_next(&dict);
1198 dbus_message_unref(reply);
1200 dbus_pending_call_unref(call);
1203 static int cm_get_contexts(struct modem_data *modem)
1205 DBusMessage *message;
1207 DBG("%s", modem->path);
1209 if (modem->call_get_contexts != NULL)
1212 message = dbus_message_new_method_call(OFONO_SERVICE, modem->path,
1213 OFONO_CM_INTERFACE, GET_CONTEXTS);
1214 if (message == NULL)
1217 if (dbus_connection_send_with_reply(connection, message,
1218 &modem->call_get_contexts, TIMEOUT) == FALSE) {
1219 connman_error("Failed to call GetContexts()");
1220 dbus_message_unref(message);
1224 if (modem->call_get_contexts == NULL) {
1225 connman_error("D-Bus connection not available");
1226 dbus_message_unref(message);
1230 dbus_pending_call_set_notify(modem->call_get_contexts,
1231 cm_get_contexts_reply,
1234 dbus_message_unref(message);
1236 return -EINPROGRESS;
1239 static gboolean cm_context_added(DBusConnection *connection,
1240 DBusMessage *message,
1243 const char *path = dbus_message_get_path(message);
1245 struct modem_data *modem;
1246 DBusMessageIter iter, properties;
1250 modem = g_hash_table_lookup(modem_hash, context_path);
1254 if (dbus_message_iter_init(message, &iter) == FALSE)
1257 dbus_message_iter_get_basic(&iter, &context_path);
1259 dbus_message_iter_next(&iter);
1260 dbus_message_iter_recurse(&iter, &properties);
1262 if (add_cm_context(modem, context_path, &properties) != 0)
1268 static gboolean cm_context_removed(DBusConnection *connection,
1269 DBusMessage *message,
1272 const char *path = dbus_message_get_path(message);
1273 const char *context_path;
1274 struct modem_data *modem;
1275 DBusMessageIter iter;
1277 DBG("context path %s", path);
1279 if (dbus_message_iter_init(message, &iter) == FALSE)
1282 dbus_message_iter_get_basic(&iter, &context_path);
1284 modem = g_hash_table_lookup(context_hash, context_path);
1288 remove_cm_context(modem, context_path);
1293 static void netreg_update_name(struct modem_data *modem,
1294 DBusMessageIter* value)
1298 dbus_message_iter_get_basic(value, &name);
1300 DBG("%s Name %s", modem->path, name);
1302 g_free(modem->name);
1303 modem->name = g_strdup(name);
1305 if (modem->network == NULL)
1308 connman_network_set_name(modem->network, modem->name);
1309 connman_network_update(modem->network);
1312 static void netreg_update_strength(struct modem_data *modem,
1313 DBusMessageIter *value)
1315 dbus_message_iter_get_basic(value, &modem->strength);
1317 DBG("%s Strength %d", modem->path, modem->strength);
1319 if (modem->network == NULL)
1324 * We don't have 2 signal notifications we always report the strength
1325 * signal. data_strength is always equal to 0.
1328 * In the case we have a data_strength signal (from 1xEVDO network)
1329 * we don't need to update the value with strength signal (from 1xCDMA)
1330 * because the modem is registered to 1xEVDO network for data call.
1331 * In case we have no data_strength signal (not registered to 1xEVDO
1332 * network), we must report the strength signal (registered to 1xCDMA
1333 * network e.g slow mode).
1335 if (modem->data_strength != 0)
1338 connman_network_set_strength(modem->network, modem->strength);
1339 connman_network_update(modem->network);
1342 /* Retrieve 1xEVDO Data Strength signal */
1343 static void netreg_update_datastrength(struct modem_data *modem,
1344 DBusMessageIter *value)
1346 dbus_message_iter_get_basic(value, &modem->data_strength);
1348 DBG("%s Data Strength %d", modem->path, modem->data_strength);
1350 if (modem->network == NULL)
1354 * CDMA modem is not registered to 1xEVDO network, let
1355 * update_signal_strength() reporting the value on the Strength signal
1358 if (modem->data_strength == 0)
1361 connman_network_set_strength(modem->network, modem->data_strength);
1362 connman_network_update(modem->network);
1365 static void netreg_update_roaming(struct modem_data *modem,
1366 DBusMessageIter *value)
1369 connman_bool_t roaming;
1371 dbus_message_iter_get_basic(value, &status);
1373 if (g_str_equal(status, "roaming") == TRUE)
1378 if (roaming == modem->roaming)
1381 modem->roaming = roaming;
1383 if (modem->network == NULL)
1386 connman_network_set_bool(modem->network,
1387 "Roaming", modem->roaming);
1388 connman_network_update(modem->network);
1391 static void netreg_update_regdom(struct modem_data *modem,
1392 DBusMessageIter *value)
1394 char *mobile_country_code;
1398 dbus_message_iter_get_basic(value, &mobile_country_code);
1400 DBG("%s MobileContryCode %s", modem->path, mobile_country_code);
1403 mcc = atoi(mobile_country_code);
1407 alpha2 = mcc_country_codes[mcc - 200];
1408 connman_technology_set_regdom(alpha2);
1411 static gboolean netreg_changed(DBusConnection *connection, DBusMessage *message,
1414 const char *path = dbus_message_get_path(message);
1415 struct modem_data *modem;
1416 DBusMessageIter iter, value;
1419 modem = g_hash_table_lookup(modem_hash, path);
1423 if (modem->ignore == TRUE)
1426 if (dbus_message_iter_init(message, &iter) == FALSE)
1429 dbus_message_iter_get_basic(&iter, &key);
1431 dbus_message_iter_next(&iter);
1432 dbus_message_iter_recurse(&iter, &value);
1434 if (g_str_equal(key, "Name") == TRUE)
1435 netreg_update_name(modem, &value);
1436 else if (g_str_equal(key, "Strength") == TRUE)
1437 netreg_update_strength(modem, &value);
1438 else if (g_str_equal(key, "Status") == TRUE)
1439 netreg_update_roaming(modem, &value);
1440 else if (g_str_equal(key, "MobileCountryCode") == TRUE)
1441 netreg_update_regdom(modem, &value);
1446 static void netreg_properties_reply(struct modem_data *modem,
1447 DBusMessageIter *dict)
1449 DBG("%s", modem->path);
1451 while (dbus_message_iter_get_arg_type(dict) == DBUS_TYPE_DICT_ENTRY) {
1452 DBusMessageIter entry, value;
1455 dbus_message_iter_recurse(dict, &entry);
1456 dbus_message_iter_get_basic(&entry, &key);
1458 dbus_message_iter_next(&entry);
1459 dbus_message_iter_recurse(&entry, &value);
1461 if (g_str_equal(key, "Name") == TRUE)
1462 netreg_update_name(modem, &value);
1463 else if (g_str_equal(key, "Strength") == TRUE)
1464 netreg_update_strength(modem, &value);
1465 else if (g_str_equal(key, "Status") == TRUE)
1466 netreg_update_roaming(modem, &value);
1467 else if (g_str_equal(key, "MobileCountryCode") == TRUE)
1468 netreg_update_regdom(modem, &value);
1470 dbus_message_iter_next(dict);
1473 if (modem->context == NULL) {
1475 * netgreg_get_properties() was issued after we got
1476 * cm_get_contexts_reply() where we create the
1477 * context. Though before we got the
1478 * netreg_properties_reply the context was removed
1479 * again. Therefore we have to skip the network
1487 if (modem->active == TRUE)
1488 set_connected(modem);
1491 static int netreg_get_properties(struct modem_data *modem)
1493 return get_properties(modem->path, OFONO_NETREG_INTERFACE,
1494 netreg_properties_reply, modem);
1497 static void add_cdma_network(struct modem_data *modem)
1499 /* Be sure that device is created before adding CDMA network */
1500 if (modem->device == NULL)
1504 * CDMA modems don't need contexts for data call, however the current
1505 * add_network() logic needs one, so we create one to proceed.
1507 if (modem->context == NULL)
1508 modem->context = network_context_alloc(modem->path);
1512 if (modem->cdma_cm_powered == TRUE)
1513 set_connected(modem);
1516 static gboolean cdma_netreg_changed(DBusConnection *connection,
1517 DBusMessage *message,
1520 const char *path = dbus_message_get_path(message);
1521 struct modem_data *modem;
1522 DBusMessageIter iter, value;
1527 modem = g_hash_table_lookup(modem_hash, path);
1531 if (modem->ignore == TRUE)
1534 if (dbus_message_iter_init(message, &iter) == FALSE)
1537 dbus_message_iter_get_basic(&iter, &key);
1539 dbus_message_iter_next(&iter);
1540 dbus_message_iter_recurse(&iter, &value);
1542 if (g_str_equal(key, "Name") == TRUE)
1543 netreg_update_name(modem, &value);
1544 else if (g_str_equal(key, "Strength") == TRUE)
1545 netreg_update_strength(modem, &value);
1546 else if (g_str_equal(key, "DataStrength") == TRUE)
1547 netreg_update_datastrength(modem, &value);
1548 else if (g_str_equal(key, "Status") == TRUE)
1549 netreg_update_roaming(modem, &value);
1551 add_cdma_network(modem);
1556 static void cdma_netreg_properties_reply(struct modem_data *modem,
1557 DBusMessageIter *dict)
1559 DBG("%s", modem->path);
1561 while (dbus_message_iter_get_arg_type(dict) == DBUS_TYPE_DICT_ENTRY) {
1562 DBusMessageIter entry, value;
1565 dbus_message_iter_recurse(dict, &entry);
1566 dbus_message_iter_get_basic(&entry, &key);
1568 dbus_message_iter_next(&entry);
1569 dbus_message_iter_recurse(&entry, &value);
1571 if (g_str_equal(key, "Name") == TRUE)
1572 netreg_update_name(modem, &value);
1573 else if (g_str_equal(key, "Strength") == TRUE)
1574 netreg_update_strength(modem, &value);
1575 else if (g_str_equal(key, "DataStrength") == TRUE)
1576 netreg_update_datastrength(modem, &value);
1577 else if (g_str_equal(key, "Status") == TRUE)
1578 netreg_update_roaming(modem, &value);
1580 dbus_message_iter_next(dict);
1583 add_cdma_network(modem);
1586 static int cdma_netreg_get_properties(struct modem_data *modem)
1588 return get_properties(modem->path, OFONO_CDMA_NETREG_INTERFACE,
1589 cdma_netreg_properties_reply, modem);
1592 static void cm_update_attached(struct modem_data *modem,
1593 DBusMessageIter *value)
1595 dbus_message_iter_get_basic(value, &modem->attached);
1597 DBG("%s Attached %d", modem->path, modem->attached);
1599 if (modem->attached == FALSE)
1602 if (has_interface(modem->interfaces,
1603 OFONO_API_NETREG) == FALSE) {
1607 netreg_get_properties(modem);
1610 static void cm_update_powered(struct modem_data *modem,
1611 DBusMessageIter *value)
1613 dbus_message_iter_get_basic(value, &modem->cm_powered);
1615 DBG("%s ConnnectionManager Powered %d", modem->path,
1618 if (modem->cm_powered == TRUE)
1621 cm_set_powered(modem);
1624 static gboolean cm_changed(DBusConnection *connection, DBusMessage *message,
1627 const char *path = dbus_message_get_path(message);
1628 struct modem_data *modem;
1629 DBusMessageIter iter, value;
1632 modem = g_hash_table_lookup(modem_hash, path);
1636 if (modem->ignore == TRUE)
1639 if (dbus_message_iter_init(message, &iter) == FALSE)
1642 dbus_message_iter_get_basic(&iter, &key);
1644 dbus_message_iter_next(&iter);
1645 dbus_message_iter_recurse(&iter, &value);
1647 if (g_str_equal(key, "Attached") == TRUE)
1648 cm_update_attached(modem, &value);
1649 else if (g_str_equal(key, "Powered") == TRUE)
1650 cm_update_powered(modem, &value);
1655 static void cdma_cm_update_powered(struct modem_data *modem,
1656 DBusMessageIter *value)
1658 dbus_message_iter_get_basic(value, &modem->cdma_cm_powered);
1660 DBG("%s CDMA cm Powered %d", modem->path, modem->cdma_cm_powered);
1662 if (modem->network == NULL)
1665 if (modem->cdma_cm_powered == TRUE)
1666 set_connected(modem);
1668 set_disconnected(modem);
1671 static void cdma_cm_update_settings(struct modem_data *modem,
1672 DBusMessageIter *value)
1674 DBG("%s Settings", modem->path);
1676 if (modem->context != NULL)
1679 extract_ipv4_settings(value, modem->context);
1682 static gboolean cdma_cm_changed(DBusConnection *connection,
1683 DBusMessage *message, void *user_data)
1685 const char *path = dbus_message_get_path(message);
1686 struct modem_data *modem;
1687 DBusMessageIter iter, value;
1690 modem = g_hash_table_lookup(modem_hash, path);
1694 if (modem->online == TRUE && modem->network == NULL)
1695 cdma_netreg_get_properties(modem);
1697 if (dbus_message_iter_init(message, &iter) == FALSE)
1700 dbus_message_iter_get_basic(&iter, &key);
1702 dbus_message_iter_next(&iter);
1703 dbus_message_iter_recurse(&iter, &value);
1705 if (g_str_equal(key, "Powered") == TRUE)
1706 cdma_cm_update_powered(modem, &value);
1707 if (g_str_equal(key, "Settings") == TRUE)
1708 cdma_cm_update_settings(modem, &value);
1713 static void cm_properties_reply(struct modem_data *modem, DBusMessageIter *dict)
1715 DBG("%s", modem->path);
1717 while (dbus_message_iter_get_arg_type(dict) == DBUS_TYPE_DICT_ENTRY) {
1718 DBusMessageIter entry, value;
1721 dbus_message_iter_recurse(dict, &entry);
1722 dbus_message_iter_get_basic(&entry, &key);
1724 dbus_message_iter_next(&entry);
1725 dbus_message_iter_recurse(&entry, &value);
1727 if (g_str_equal(key, "Attached") == TRUE)
1728 cm_update_attached(modem, &value);
1729 else if (g_str_equal(key, "Powered") == TRUE)
1730 cm_update_powered(modem, &value);
1732 dbus_message_iter_next(dict);
1736 static int cm_get_properties(struct modem_data *modem)
1738 return get_properties(modem->path, OFONO_CM_INTERFACE,
1739 cm_properties_reply, modem);
1742 static void cdma_cm_properties_reply(struct modem_data *modem,
1743 DBusMessageIter *dict)
1745 DBG("%s", modem->path);
1747 if (modem->online == TRUE)
1748 cdma_netreg_get_properties(modem);
1750 while (dbus_message_iter_get_arg_type(dict) == DBUS_TYPE_DICT_ENTRY) {
1751 DBusMessageIter entry, value;
1754 dbus_message_iter_recurse(dict, &entry);
1755 dbus_message_iter_get_basic(&entry, &key);
1757 dbus_message_iter_next(&entry);
1758 dbus_message_iter_recurse(&entry, &value);
1760 if (g_str_equal(key, "Powered") == TRUE)
1761 cdma_cm_update_powered(modem, &value);
1762 if (g_str_equal(key, "Settings") == TRUE)
1763 cdma_cm_update_settings(modem, &value);
1765 dbus_message_iter_next(dict);
1769 static int cdma_cm_get_properties(struct modem_data *modem)
1771 return get_properties(modem->path, OFONO_CDMA_CM_INTERFACE,
1772 cdma_cm_properties_reply, modem);
1775 static connman_bool_t connection_manager_init(struct modem_data *modem)
1777 if (has_interface(modem->interfaces, OFONO_API_CM) == TRUE) {
1778 if (ready_to_create_device(modem) == TRUE)
1779 create_device(modem);
1781 if (modem->device != NULL) {
1782 cm_get_properties(modem);
1783 cm_get_contexts(modem);
1789 if (has_interface(modem->interfaces, OFONO_API_CDMA_CM) == TRUE) {
1790 if (ready_to_create_device(modem) == TRUE)
1791 create_device(modem);
1793 if (modem->device != NULL)
1794 cdma_cm_get_properties(modem);
1802 static void sim_update_imsi(struct modem_data *modem,
1803 DBusMessageIter* value)
1807 dbus_message_iter_get_basic(value, &imsi);
1809 DBG("%s imsi %s", modem->path, imsi);
1811 g_free(modem->imsi);
1812 modem->imsi = g_strdup(imsi);
1815 static gboolean sim_changed(DBusConnection *connection, DBusMessage *message,
1818 const char *path = dbus_message_get_path(message);
1819 struct modem_data *modem;
1820 DBusMessageIter iter, value;
1823 modem = g_hash_table_lookup(modem_hash, path);
1827 if (modem->ignore == TRUE)
1830 if (dbus_message_iter_init(message, &iter) == FALSE)
1833 dbus_message_iter_get_basic(&iter, &key);
1835 dbus_message_iter_next(&iter);
1836 dbus_message_iter_recurse(&iter, &value);
1838 if (g_str_equal(key, "SubscriberIdentity") == TRUE) {
1839 sim_update_imsi(modem, &value);
1841 if (modem->online == FALSE) {
1842 modem_set_online(modem);
1843 } else if (has_interface(modem->interfaces,
1844 OFONO_API_CM) == TRUE) {
1845 if (ready_to_create_device(modem) == TRUE)
1846 create_device(modem);
1847 } else if (has_interface(modem->interfaces,
1848 OFONO_API_CDMA_CM) == TRUE) {
1849 if (ready_to_create_device(modem) == TRUE)
1850 create_device(modem);
1857 static void sim_properties_reply(struct modem_data *modem,
1858 DBusMessageIter *dict)
1860 DBG("%s", modem->path);
1862 while (dbus_message_iter_get_arg_type(dict) == DBUS_TYPE_DICT_ENTRY) {
1863 DBusMessageIter entry, value;
1866 dbus_message_iter_recurse(dict, &entry);
1867 dbus_message_iter_get_basic(&entry, &key);
1869 dbus_message_iter_next(&entry);
1870 dbus_message_iter_recurse(&entry, &value);
1872 if (g_str_equal(key, "SubscriberIdentity") == TRUE) {
1873 sim_update_imsi(modem, &value);
1875 if (modem->online == FALSE) {
1876 modem_set_online(modem);
1880 connection_manager_init(modem);
1885 dbus_message_iter_next(dict);
1889 static int sim_get_properties(struct modem_data *modem)
1891 return get_properties(modem->path, OFONO_SIM_INTERFACE,
1892 sim_properties_reply, modem);
1895 static gboolean modem_changed(DBusConnection *connection, DBusMessage *message,
1898 const char *path = dbus_message_get_path(message);
1899 struct modem_data *modem;
1900 DBusMessageIter iter, value;
1903 modem = g_hash_table_lookup(modem_hash, path);
1907 if (modem->ignore == TRUE)
1910 if (dbus_message_iter_init(message, &iter) == FALSE)
1913 dbus_message_iter_get_basic(&iter, &key);
1915 dbus_message_iter_next(&iter);
1916 dbus_message_iter_recurse(&iter, &value);
1918 if (g_str_equal(key, "Powered") == TRUE) {
1919 dbus_message_iter_get_basic(&value, &modem->powered);
1921 DBG("%s Powered %d", modem->path, modem->powered);
1923 if (modem->powered == FALSE)
1924 modem_set_powered(modem);
1925 } else if (g_str_equal(key, "Online") == TRUE) {
1926 dbus_message_iter_get_basic(&value, &modem->online);
1928 DBG("%s Online %d", modem->path, modem->online);
1930 if (modem->online == FALSE)
1933 connection_manager_init(modem);
1934 } else if (g_str_equal(key, "Interfaces") == TRUE) {
1935 modem->interfaces = extract_interfaces(&value);
1937 DBG("%s Interfaces 0x%02x", modem->path,
1940 if (has_interface(modem->interfaces, OFONO_API_SIM) == TRUE) {
1941 if (modem->imsi == NULL &&
1942 modem->set_powered == FALSE) {
1944 * Only use do GetProperties() when
1945 * device has not been powered up.
1947 sim_get_properties(modem);
1952 if (connection_manager_init(modem) == FALSE) {
1953 if (modem->context != NULL) {
1954 remove_cm_context(modem,
1955 modem->context->path);
1958 if (modem->device != NULL)
1959 destroy_device(modem);
1964 if (has_interface(modem->interfaces, OFONO_API_NETREG) == TRUE) {
1965 if (modem->attached == TRUE)
1966 netreg_get_properties(modem);
1967 } else if (has_interface(modem->interfaces,
1968 OFONO_API_CDMA_NETREG) == TRUE)
1969 cdma_netreg_get_properties(modem);
1970 } else if (g_str_equal(key, "Serial") == TRUE) {
1973 dbus_message_iter_get_basic(&value, &serial);
1975 g_free(modem->serial);
1976 modem->serial = g_strdup(serial);
1978 DBG("%s Serial %s", modem->path, modem->serial);
1980 connection_manager_init(modem);
1986 static void add_modem(const char *path, DBusMessageIter *prop)
1988 struct modem_data *modem;
1992 modem = g_hash_table_lookup(modem_hash, path);
1993 if (modem != NULL) {
1995 * When oFono powers up we ask for the modems and oFono is
1996 * reporting with modem_added signal the modems. Only
2002 modem = g_try_new0(struct modem_data, 1);
2006 modem->path = g_strdup(path);
2008 g_hash_table_insert(modem_hash, g_strdup(path), modem);
2010 while (dbus_message_iter_get_arg_type(prop) == DBUS_TYPE_DICT_ENTRY) {
2011 DBusMessageIter entry, value;
2014 dbus_message_iter_recurse(prop, &entry);
2015 dbus_message_iter_get_basic(&entry, &key);
2017 dbus_message_iter_next(&entry);
2018 dbus_message_iter_recurse(&entry, &value);
2020 if (g_str_equal(key, "Powered") == TRUE) {
2021 dbus_message_iter_get_basic(&value, &modem->powered);
2023 DBG("%s Powered %d", modem->path, modem->powered);
2024 } else if (g_str_equal(key, "Online") == TRUE) {
2025 dbus_message_iter_get_basic(&value, &modem->online);
2027 DBG("%s Online %d", modem->path, modem->online);
2028 } else if (g_str_equal(key, "Interfaces") == TRUE) {
2029 modem->interfaces = extract_interfaces(&value);
2031 DBG("%s Interfaces 0x%02x", modem->path,
2033 } else if (g_str_equal(key, "Serial") == TRUE) {
2036 dbus_message_iter_get_basic(&value, &serial);
2037 modem->serial = g_strdup(serial);
2039 DBG("%s Serial %s", modem->path, modem->serial);
2040 } else if (g_str_equal(key, "Type") == TRUE) {
2043 dbus_message_iter_get_basic(&value, &type);
2045 DBG("%s Type %s", modem->path, type);
2046 if (g_strcmp0(type, "hardware") != 0) {
2047 DBG("%s Ignore this modem", modem->path);
2048 modem->ignore = TRUE;
2052 dbus_message_iter_next(prop);
2055 if (modem->ignore == TRUE)
2058 if (modem->powered == FALSE)
2059 modem_set_powered(modem);
2060 else if (has_interface(modem->interfaces, OFONO_API_SIM) == TRUE)
2061 sim_get_properties(modem);
2063 connection_manager_init(modem);
2066 static void modem_power_down(gpointer key, gpointer value, gpointer user_data)
2068 struct modem_data *modem = value;
2070 DBG("%s", modem->path);
2072 if (modem->ignore == TRUE)
2075 modem_set_unpowered(modem);
2078 static void remove_modem(gpointer data)
2080 struct modem_data *modem = data;
2082 DBG("%s", modem->path);
2084 if (modem->call_set_property != NULL)
2085 dbus_pending_call_cancel(modem->call_set_property);
2087 if (modem->call_get_properties != NULL)
2088 dbus_pending_call_cancel(modem->call_get_properties);
2090 if (modem->call_get_contexts != NULL)
2091 dbus_pending_call_cancel(modem->call_get_contexts);
2093 if (modem->device != NULL)
2094 destroy_device(modem);
2096 if (modem->context != NULL)
2097 remove_cm_context(modem, modem->context->path);
2099 g_free(modem->serial);
2100 g_free(modem->name);
2101 g_free(modem->imsi);
2102 g_free(modem->path);
2107 static gboolean modem_added(DBusConnection *connection,
2108 DBusMessage *message, void *user_data)
2110 DBusMessageIter iter, properties;
2115 if (dbus_message_iter_init(message, &iter) == FALSE)
2118 dbus_message_iter_get_basic(&iter, &path);
2120 dbus_message_iter_next(&iter);
2121 dbus_message_iter_recurse(&iter, &properties);
2123 add_modem(path, &properties);
2128 static gboolean modem_removed(DBusConnection *connection,
2129 DBusMessage *message, void *user_data)
2131 DBusMessageIter iter;
2136 if (dbus_message_iter_init(message, &iter) == FALSE)
2139 dbus_message_iter_get_basic(&iter, &path);
2141 g_hash_table_remove(modem_hash, path);
2146 static void manager_get_modems_reply(DBusPendingCall *call, void *user_data)
2150 DBusMessageIter array, dict;
2154 reply = dbus_pending_call_steal_reply(call);
2156 dbus_error_init(&error);
2158 if (dbus_set_error_from_message(&error, reply) == TRUE) {
2159 connman_error("%s", error.message);
2160 dbus_error_free(&error);
2164 if (dbus_message_iter_init(reply, &array) == FALSE)
2167 dbus_message_iter_recurse(&array, &dict);
2169 while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_STRUCT) {
2170 DBusMessageIter value, properties;
2173 dbus_message_iter_recurse(&dict, &value);
2174 dbus_message_iter_get_basic(&value, &path);
2176 dbus_message_iter_next(&value);
2177 dbus_message_iter_recurse(&value, &properties);
2179 add_modem(path, &properties);
2181 dbus_message_iter_next(&dict);
2185 dbus_message_unref(reply);
2187 dbus_pending_call_unref(call);
2190 static int manager_get_modems(void)
2192 DBusMessage *message;
2193 DBusPendingCall *call;
2197 message = dbus_message_new_method_call(OFONO_SERVICE, "/",
2198 OFONO_MANAGER_INTERFACE, GET_MODEMS);
2199 if (message == NULL)
2202 if (dbus_connection_send_with_reply(connection, message,
2203 &call, TIMEOUT) == FALSE) {
2204 connman_error("Failed to call GetModems()");
2205 dbus_message_unref(message);
2210 connman_error("D-Bus connection not available");
2211 dbus_message_unref(message);
2215 dbus_pending_call_set_notify(call, manager_get_modems_reply,
2218 dbus_message_unref(message);
2220 return -EINPROGRESS;
2223 static void ofono_connect(DBusConnection *conn, void *user_data)
2227 modem_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
2228 g_free, remove_modem);
2229 if (modem_hash == NULL)
2232 context_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
2234 if (context_hash == NULL) {
2235 g_hash_table_destroy(modem_hash);
2239 manager_get_modems();
2242 static void ofono_disconnect(DBusConnection *conn, void *user_data)
2246 if (modem_hash == NULL || context_hash == NULL)
2249 g_hash_table_destroy(modem_hash);
2252 g_hash_table_destroy(context_hash);
2253 context_hash = NULL;
2256 static int network_probe(struct connman_network *network)
2258 struct modem_data *modem = connman_network_get_data(network);
2260 DBG("%s network %p", modem->path, network);
2265 static void network_remove(struct connman_network *network)
2267 struct modem_data *modem = connman_network_get_data(network);
2269 DBG("%s network %p", modem->path, network);
2272 static int network_connect(struct connman_network *network)
2274 struct modem_data *modem = connman_network_get_data(network);
2276 DBG("%s network %p", modem->path, network);
2278 if (has_interface(modem->interfaces, OFONO_API_CM) == TRUE)
2279 return context_set_active(modem);
2280 else if (has_interface(modem->interfaces, OFONO_API_CDMA_CM) == TRUE)
2281 return cdma_cm_set_powered(modem);
2283 connman_error("Connection manager interface not available");
2288 static int network_disconnect(struct connman_network *network)
2290 struct modem_data *modem = connman_network_get_data(network);
2292 DBG("%s network %p", modem->path, network);
2294 if (has_interface(modem->interfaces, OFONO_API_CM) == TRUE)
2295 return context_set_inactive(modem);
2296 else if (has_interface(modem->interfaces, OFONO_API_CDMA_CM) == TRUE)
2297 return cdma_cm_shutdown(modem);
2299 connman_error("Connection manager interface not available");
2304 static struct connman_network_driver network_driver = {
2306 .type = CONNMAN_NETWORK_TYPE_CELLULAR,
2307 .probe = network_probe,
2308 .remove = network_remove,
2309 .connect = network_connect,
2310 .disconnect = network_disconnect,
2313 static int modem_probe(struct connman_device *device)
2315 struct modem_data *modem = connman_device_get_data(device);
2317 DBG("%s device %p", modem->path, device);
2322 static void modem_remove(struct connman_device *device)
2324 struct modem_data *modem = connman_device_get_data(device);
2326 DBG("%s device %p", modem->path, device);
2329 static int modem_enable(struct connman_device *device)
2331 struct modem_data *modem = connman_device_get_data(device);
2333 DBG("%s device %p", modem->path, device);
2338 static int modem_disable(struct connman_device *device)
2340 struct modem_data *modem = connman_device_get_data(device);
2342 DBG("%s device %p", modem->path, device);
2347 static struct connman_device_driver modem_driver = {
2349 .type = CONNMAN_DEVICE_TYPE_CELLULAR,
2350 .probe = modem_probe,
2351 .remove = modem_remove,
2352 .enable = modem_enable,
2353 .disable = modem_disable,
2357 static guint modem_added_watch;
2358 static guint modem_removed_watch;
2359 static guint modem_watch;
2360 static guint cm_watch;
2361 static guint sim_watch;
2362 static guint context_added_watch;
2363 static guint context_removed_watch;
2364 static guint netreg_watch;
2365 static guint context_watch;
2366 static guint cdma_cm_watch;
2367 static guint cdma_netreg_watch;
2369 static int ofono_init(void)
2375 connection = connman_dbus_get_connection();
2376 if (connection == NULL)
2379 watch = g_dbus_add_service_watch(connection,
2380 OFONO_SERVICE, ofono_connect,
2381 ofono_disconnect, NULL, NULL);
2383 modem_added_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
2384 OFONO_MANAGER_INTERFACE,
2389 modem_removed_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
2390 OFONO_MANAGER_INTERFACE,
2395 modem_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
2396 OFONO_MODEM_INTERFACE,
2401 cm_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
2407 sim_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
2408 OFONO_SIM_INTERFACE,
2413 context_added_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
2419 context_removed_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
2425 context_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
2426 OFONO_CONTEXT_INTERFACE,
2431 netreg_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
2432 OFONO_NETREG_INTERFACE,
2437 cdma_cm_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
2438 OFONO_CDMA_CM_INTERFACE,
2443 cdma_netreg_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
2444 OFONO_CDMA_NETREG_INTERFACE,
2446 cdma_netreg_changed,
2450 if (watch == 0 || modem_added_watch == 0 || modem_removed_watch == 0 ||
2451 modem_watch == 0 || cm_watch == 0 || sim_watch == 0 ||
2452 context_added_watch == 0 ||
2453 context_removed_watch == 0 ||
2454 context_watch == 0 || netreg_watch == 0 ||
2455 cdma_cm_watch == 0 || cdma_netreg_watch == 0) {
2460 err = connman_network_driver_register(&network_driver);
2464 err = connman_device_driver_register(&modem_driver);
2466 connman_network_driver_unregister(&network_driver);
2473 g_dbus_remove_watch(connection, cdma_netreg_watch);
2474 g_dbus_remove_watch(connection, cdma_cm_watch);
2475 g_dbus_remove_watch(connection, netreg_watch);
2476 g_dbus_remove_watch(connection, context_watch);
2477 g_dbus_remove_watch(connection, context_removed_watch);
2478 g_dbus_remove_watch(connection, context_added_watch);
2479 g_dbus_remove_watch(connection, sim_watch);
2480 g_dbus_remove_watch(connection, cm_watch);
2481 g_dbus_remove_watch(connection, modem_watch);
2482 g_dbus_remove_watch(connection, modem_removed_watch);
2483 g_dbus_remove_watch(connection, modem_added_watch);
2484 g_dbus_remove_watch(connection, watch);
2485 dbus_connection_unref(connection);
2490 static void ofono_exit(void)
2494 if (modem_hash != NULL) {
2496 * We should propably wait for the SetProperty() reply
2497 * message, because ...
2499 g_hash_table_foreach(modem_hash, modem_power_down, NULL);
2502 * ... here we will cancel the call.
2504 g_hash_table_destroy(modem_hash);
2508 if (context_hash != NULL) {
2509 g_hash_table_destroy(context_hash);
2510 context_hash = NULL;
2513 connman_device_driver_unregister(&modem_driver);
2514 connman_network_driver_unregister(&network_driver);
2516 g_dbus_remove_watch(connection, cdma_netreg_watch);
2517 g_dbus_remove_watch(connection, cdma_cm_watch);
2518 g_dbus_remove_watch(connection, netreg_watch);
2519 g_dbus_remove_watch(connection, context_watch);
2520 g_dbus_remove_watch(connection, context_removed_watch);
2521 g_dbus_remove_watch(connection, context_added_watch);
2522 g_dbus_remove_watch(connection, sim_watch);
2523 g_dbus_remove_watch(connection, cm_watch);
2524 g_dbus_remove_watch(connection, modem_watch);
2525 g_dbus_remove_watch(connection, modem_added_watch);
2526 g_dbus_remove_watch(connection, modem_removed_watch);
2527 g_dbus_remove_watch(connection, watch);
2529 dbus_connection_unref(connection);
2532 CONNMAN_PLUGIN_DEFINE(ofono, "oFono telephony plugin", VERSION,
2533 CONNMAN_PLUGIN_PRIORITY_DEFAULT, ofono_init, ofono_exit)