plugins/ofono.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2010  Intel Corporation. All rights reserved.
   6  *  Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
   7  *
   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.
  11  *
  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.
  16  *
  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
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <errno.h>
  28 #include <stdlib.h>
  29
  30 #include <gdbus.h>
  31 #include <string.h>
  32
  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>
  43
  44 #include "mcc.h"
  45
  46 #define OFONO_SERVICE                   "org.ofono"
  47
  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"
  54
  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"
  64
  65
  66 #define TIMEOUT 40000
  67
  68 static DBusConnection *connection;
  69
  70 static GHashTable *modem_hash = NULL;
  71
  72 static GHashTable *network_hash;
  73
  74 struct modem_data {
  75         char *path;
  76         struct connman_device *device;
  77         gboolean has_sim;
  78         gboolean has_reg;
  79         gboolean has_gprs;
  80         gboolean available;
  81         gboolean pending_online;
  82         dbus_bool_t requested_online;
  83         dbus_bool_t online;
  84
  85         /* org.ofono.ConnectionManager properties */
  86         dbus_bool_t powered;
  87         dbus_bool_t attached;
  88         dbus_bool_t roaming_allowed;
  89
  90         connman_bool_t registered;
  91         connman_bool_t roaming;
  92         uint8_t strength, has_strength;
  93 };
  94
  95 struct network_info {
  96         struct connman_network *network;
  97
  98         enum connman_ipconfig_method ipv4_method;
  99         struct connman_ipaddress ipv4_address;
 100
 101         enum connman_ipconfig_method ipv6_method;
 102         struct connman_ipaddress ipv6_address;
 103 };
 104
 105 static int modem_probe(struct connman_device *device)
 106 {
 107         DBG("device %p", device);
 108
 109         return 0;
 110 }
 111
 112 static void modem_remove(struct connman_device *device)
 113 {
 114         DBG("device %p", device);
 115 }
 116
 117 static int call_ofono(const char *path,
 118                         const char *interface, const char *method,
 119                         DBusPendingCallNotifyFunction notify, void *user_data,
 120                         DBusFreeFunction free_function,
 121                         int type, ...)
 122 {
 123         DBusMessage *message;
 124         DBusPendingCall *call;
 125         dbus_bool_t ok;
 126         va_list va;
 127
 128         DBG("path %s %s.%s", path, interface, method);
 129
 130         if (path == NULL)
 131                 return -EINVAL;
 132
 133         message = dbus_message_new_method_call(OFONO_SERVICE, path,
 134                                         interface, method);
 135         if (message == NULL)
 136                 return -ENOMEM;
 137
 138         dbus_message_set_auto_start(message, FALSE);
 139
 140         va_start(va, type);
 141         ok = dbus_message_append_args_valist(message, type, va);
 142         va_end(va);
 143
 144         if (!ok)
 145                 return -ENOMEM;
 146
 147         if (dbus_connection_send_with_reply(connection, message,
 148                                                 &call, TIMEOUT) == FALSE) {
 149                 connman_error("Failed to call %s.%s", interface, method);
 150                 dbus_message_unref(message);
 151                 return -EINVAL;
 152         }
 153
 154         if (call == NULL) {
 155                 connman_error("D-Bus connection not available");
 156                 dbus_message_unref(message);
 157                 return -EINVAL;
 158         }
 159
 160         dbus_pending_call_set_notify(call, notify, user_data, free_function);
 161
 162         dbus_message_unref(message);
 163
 164         return -EINPROGRESS;
 165 }
 166
 167 static void set_property_reply(DBusPendingCall *call, void *user_data)
 168 {
 169         DBusMessage *reply;
 170         DBusError error;
 171         char const *name = user_data;
 172
 173         DBG("");
 174
 175         dbus_error_init(&error);
 176
 177         reply = dbus_pending_call_steal_reply(call);
 178
 179         if (dbus_set_error_from_message(&error, reply)) {
 180                 connman_error("SetProperty(%s) %s %s", name,
 181                                 error.name, error.message);
 182                 dbus_error_free(&error);
 183         }
 184
 185         dbus_message_unref(reply);
 186
 187         dbus_pending_call_unref(call);
 188 }
 189
 190 static int set_property(const char *path, const char *interface,
 191                         const char *property, int type, void *value,
 192                         DBusPendingCallNotifyFunction notify, void *user_data,
 193                         DBusFreeFunction free_function)
 194 {
 195         DBusMessage *message;
 196         DBusMessageIter iter;
 197         DBusPendingCall *call;
 198
 199         DBG("path %s %s.%s", path, interface, property);
 200
 201         g_assert(notify == NULL ? free_function == NULL : 1);
 202
 203         if (path == NULL)
 204                 return -EINVAL;
 205
 206         message = dbus_message_new_method_call(OFONO_SERVICE, path,
 207                                         interface, SET_PROPERTY);
 208         if (message == NULL)
 209                 return -ENOMEM;
 210
 211         dbus_message_set_auto_start(message, FALSE);
 212
 213         dbus_message_iter_init_append(message, &iter);
 214         connman_dbus_property_append_basic(&iter, property, type, value);
 215
 216         if (dbus_connection_send_with_reply(connection, message,
 217                                                 &call, TIMEOUT) == FALSE) {
 218                 connman_error("Failed to change \"%s\" property on %s",
 219                                 property, interface);
 220                 dbus_message_unref(message);
 221                 return -EINVAL;
 222         }
 223
 224         if (call == NULL) {
 225                 connman_error("D-Bus connection not available");
 226                 dbus_message_unref(message);
 227                 return -EINVAL;
 228         }
 229
 230         if (notify == NULL) {
 231                 notify = set_property_reply;
 232                 user_data = (void *)property;
 233                 free_function = NULL;
 234         }
 235
 236         dbus_pending_call_set_notify(call, notify, user_data, free_function);
 237
 238         dbus_message_unref(message);
 239
 240         return -EINPROGRESS;
 241 }
 242
 243 static void update_modem_online(struct modem_data *modem,
 244                                 connman_bool_t online)
 245 {
 246         DBG("modem %p path %s online %d", modem, modem->path, online);
 247
 248         modem->online = online;
 249         modem->requested_online = online;
 250         modem->pending_online = FALSE;
 251
 252         if (modem->device)
 253                 connman_device_set_powered(modem->device, online);
 254 }
 255
 256 static void set_online_reply(DBusPendingCall *call, void *user_data)
 257 {
 258         struct modem_data *modem;
 259         DBusMessage *reply;
 260         DBusError error;
 261         gboolean result;
 262
 263         DBG("path %s", (char *)user_data);
 264
 265         if (modem_hash == NULL)
 266                 return;
 267
 268         modem = g_hash_table_lookup(modem_hash, user_data);
 269         if (modem == NULL)
 270                 return;
 271
 272         reply = dbus_pending_call_steal_reply(call);
 273
 274         dbus_error_init(&error);
 275
 276         if (dbus_set_error_from_message(&error, reply)) {
 277                 connman_error("SetProperty(Online) %s %s",
 278                                 error.name, error.message);
 279                 dbus_error_free(&error);
 280
 281                 result = modem->online;
 282         } else
 283                 result = modem->requested_online;
 284
 285         if (modem->pending_online)
 286                 update_modem_online(modem, result);
 287
 288         dbus_message_unref(reply);
 289
 290         dbus_pending_call_unref(call);
 291 }
 292
 293 static int modem_change_online(char const *path, dbus_bool_t online)
 294 {
 295         struct modem_data *modem = g_hash_table_lookup(modem_hash, path);
 296
 297         if (modem == NULL)
 298                 return -ENODEV;
 299
 300         if (modem->online == online)
 301                 return -EALREADY;
 302
 303         modem->requested_online = online;
 304
 305         return set_property(path, OFONO_MODEM_INTERFACE, "Online",
 306                                 DBUS_TYPE_BOOLEAN, &online,
 307                                 set_online_reply,
 308                                 (void *)g_strdup(path), g_free);
 309 }
 310
 311 static int modem_enable(struct connman_device *device)
 312 {
 313         const char *path = connman_device_get_string(device, "Path");
 314
 315         DBG("device %p, path, %s", device, path);
 316
 317         return modem_change_online(path, TRUE);
 318 }
 319
 320 static int modem_disable(struct connman_device *device)
 321 {
 322         const char *path = connman_device_get_string(device, "Path");
 323
 324         DBG("device %p path %s", device, path);
 325
 326         return modem_change_online(path, FALSE);
 327 }
 328
 329 static struct connman_device_driver modem_driver = {
 330         .name           = "modem",
 331         .type           = CONNMAN_DEVICE_TYPE_CELLULAR,
 332         .probe          = modem_probe,
 333         .remove         = modem_remove,
 334         .enable         = modem_enable,
 335         .disable        = modem_disable,
 336 };
 337
 338 static void modem_remove_device(struct modem_data *modem)
 339 {
 340         DBG("modem %p path %s device %p", modem, modem->path, modem->device);
 341
 342         if (modem->device == NULL)
 343                 return;
 344
 345         connman_device_remove_all_networks(modem->device);
 346         connman_device_unregister(modem->device);
 347         connman_device_unref(modem->device);
 348
 349         modem->device = NULL;
 350 }
 351
 352 static void remove_modem(gpointer data)
 353 {
 354         struct modem_data *modem = data;
 355
 356         modem_remove_device(modem);
 357
 358         g_free(modem->path);
 359
 360         g_free(modem);
 361 }
 362
 363 static void remove_network(gpointer data)
 364 {
 365         struct network_info *info = data;
 366
 367         connman_network_unref(info->network);
 368
 369         g_free(info);
 370 }
 371
 372 static char *get_ident(const char *path)
 373 {
 374         char *pos;
 375
 376         if (*path != '/')
 377                 return NULL;
 378
 379         pos = strrchr(path, '/');
 380         if (pos == NULL)
 381                 return NULL;
 382
 383         return pos + 1;
 384 }
 385
 386 static void create_service(struct connman_network *network)
 387 {
 388         const char *path;
 389         char *group;
 390
 391         DBG("");
 392
 393         path = connman_network_get_string(network, "Path");
 394
 395         group = get_ident(path);
 396
 397         connman_network_set_group(network, group);
 398 }
 399
 400 static int network_probe(struct connman_network *network)
 401 {
 402         return 0;
 403 }
 404
 405 static gboolean pending_network_is_available(struct connman_network *network)
 406 {
 407         /* Modem or network may be removed */
 408         if (network == NULL || connman_network_get_device(network) == NULL) {
 409                 DBG("Modem or network was removed");
 410                 return FALSE;
 411         }
 412
 413         return TRUE;
 414 }
 415
 416 static void set_connected(struct network_info *info,
 417                                 connman_bool_t connected)
 418 {
 419         DBG("network %p connected %d", info->network, connected);
 420
 421         switch (info->ipv4_method) {
 422         case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
 423         case CONNMAN_IPCONFIG_METHOD_OFF:
 424         case CONNMAN_IPCONFIG_METHOD_MANUAL:
 425         case CONNMAN_IPCONFIG_METHOD_AUTO:
 426                 return;
 427
 428         case CONNMAN_IPCONFIG_METHOD_FIXED:
 429                 connman_network_set_ipv4_method(info->network,
 430                                                         info->ipv4_method);
 431                 connman_network_set_ipaddress(info->network,
 432                                                         &info->ipv4_address);
 433
 434                 break;
 435
 436         case CONNMAN_IPCONFIG_METHOD_DHCP:
 437                 connman_network_set_ipv4_method(info->network,
 438                                                         info->ipv4_method);
 439
 440                 break;
 441         }
 442
 443         connman_network_set_connected(info->network, connected);
 444 }
 445
 446 static void set_active_reply(DBusPendingCall *call, void *user_data)
 447 {
 448         char const *path = user_data;
 449         DBusMessage *reply;
 450         DBusError error;
 451         struct network_info *info;
 452
 453         info = g_hash_table_lookup(network_hash, path);
 454
 455         reply = dbus_pending_call_steal_reply(call);
 456
 457         if (info == NULL)
 458                 goto done;
 459
 460         DBG("path %s network %p", path, info->network);
 461
 462         if (!pending_network_is_available(info->network))
 463                 goto done;
 464
 465         dbus_error_init(&error);
 466
 467         if (dbus_set_error_from_message(&error, reply)) {
 468                 connman_error("SetProperty(Active) %s %s",
 469                                 error.name, error.message);
 470
 471                 if (connman_network_get_index(info->network) < 0)
 472                         connman_network_set_error(info->network,
 473                                 CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
 474
 475                 dbus_error_free(&error);
 476         } else if (connman_network_get_index(info->network) >= 0)
 477                 set_connected(info, TRUE);
 478
 479 done:
 480         dbus_message_unref(reply);
 481
 482         dbus_pending_call_unref(call);
 483 }
 484
 485 static int set_network_active(struct connman_network *network)
 486 {
 487         dbus_bool_t value = TRUE;
 488         const char *path = connman_network_get_string(network, "Path");
 489
 490         DBG("network %p, path %s", network, path);
 491
 492         return set_property(path, OFONO_CONTEXT_INTERFACE,
 493                                 "Active", DBUS_TYPE_BOOLEAN, &value,
 494                                 set_active_reply, g_strdup(path), g_free);
 495 }
 496
 497 static int set_network_inactive(struct connman_network *network)
 498 {
 499         int err;
 500         dbus_bool_t value = FALSE;
 501         const char *path = connman_network_get_string(network, "Path");
 502
 503         DBG("network %p, path %s", network, path);
 504
 505         err = set_property(path, OFONO_CONTEXT_INTERFACE,
 506                                 "Active", DBUS_TYPE_BOOLEAN, &value,
 507                                 NULL, NULL, NULL);
 508
 509         if (err == -EINPROGRESS)
 510                 err = 0;
 511
 512         return err;
 513 }
 514
 515 static int network_connect(struct connman_network *network)
 516 {
 517         struct connman_device *device;
 518         struct modem_data *modem;
 519
 520         DBG("network %p", network);
 521
 522         device = connman_network_get_device(network);
 523         if (device == NULL)
 524                 return -ENODEV;
 525
 526         modem = connman_device_get_data(device);
 527         if (modem == NULL)
 528                 return -ENODEV;
 529
 530         if (modem->registered == FALSE)
 531                 return -ENOLINK;
 532
 533         if (modem->powered == FALSE)
 534                 return -ENOLINK;
 535
 536         if (modem->roaming_allowed == FALSE && modem->roaming == TRUE)
 537                 return -ENOLINK;
 538
 539         return set_network_active(network);
 540 }
 541
 542 static int network_disconnect(struct connman_network *network)
 543 {
 544         DBG("network %p", network);
 545
 546         if (connman_network_get_index(network) < 0)
 547                 return -ENOTCONN;
 548
 549         connman_network_set_associating(network, FALSE);
 550
 551         return set_network_inactive(network);
 552 }
 553
 554 static void network_remove(struct connman_network *network)
 555 {
 556         char const *path = connman_network_get_string(network, "Path");
 557
 558         DBG("network %p path %s", network, path);
 559
 560         g_hash_table_remove(network_hash, path);
 561 }
 562
 563 static struct connman_network_driver network_driver = {
 564         .name           = "network",
 565         .type           = CONNMAN_NETWORK_TYPE_CELLULAR,
 566         .probe          = network_probe,
 567         .remove         = network_remove,
 568         .connect        = network_connect,
 569         .disconnect     = network_disconnect,
 570 };
 571
 572 static void get_dns(DBusMessageIter *array, struct network_info *info)
 573 {
 574         DBusMessageIter entry;
 575         gchar *nameservers = NULL, *nameservers_old = NULL;
 576
 577         DBG("");
 578
 579
 580         dbus_message_iter_recurse(array, &entry);
 581
 582         while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
 583                 const char *dns;
 584
 585                 dbus_message_iter_get_basic(&entry, &dns);
 586
 587                 DBG("dns %s", dns);
 588
 589                 if (nameservers == NULL) {
 590
 591                         nameservers = g_strdup(dns);
 592                 } else {
 593
 594                         nameservers_old = nameservers;
 595                         nameservers = g_strdup_printf("%s %s",
 596                                                 nameservers_old, dns);
 597                         g_free(nameservers_old);
 598                 }
 599
 600                 dbus_message_iter_next(&entry);
 601         }
 602
 603         connman_network_set_nameservers(info->network, nameservers);
 604
 605         g_free(nameservers);
 606 }
 607
 608 static void update_settings(DBusMessageIter *array,
 609                                 struct network_info *info)
 610 {
 611         DBusMessageIter dict;
 612         char *address = NULL, *netmask = NULL, *gateway = NULL;
 613         const char *interface = NULL;
 614
 615         DBG("network %p", info->network);
 616
 617         if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
 618                 return;
 619
 620         dbus_message_iter_recurse(array, &dict);
 621
 622         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
 623                 DBusMessageIter entry, value;
 624                 const char *key, *val;
 625
 626                 dbus_message_iter_recurse(&dict, &entry);
 627                 dbus_message_iter_get_basic(&entry, &key);
 628
 629                 DBG("key %s", key);
 630
 631                 dbus_message_iter_next(&entry);
 632                 dbus_message_iter_recurse(&entry, &value);
 633
 634                 if (g_str_equal(key, "Interface") == TRUE) {
 635                         int index;
 636
 637                         dbus_message_iter_get_basic(&value, &interface);
 638
 639                         DBG("interface %s", interface);
 640
 641                         index = connman_inet_ifindex(interface);
 642                         if (index >= 0) {
 643                                 connman_network_set_index(info->network, index);
 644                         } else {
 645                                 connman_error("Can not find interface %s",
 646                                                                 interface);
 647                                 break;
 648                         }
 649                 } else if (g_str_equal(key, "Method") == TRUE) {
 650                         const char *method;
 651
 652                         dbus_message_iter_get_basic(&value, &method);
 653
 654                         if (g_strcmp0(method, "static") == 0) {
 655
 656                                 info->ipv4_method =
 657                                         CONNMAN_IPCONFIG_METHOD_FIXED;
 658                         } else if (g_strcmp0(method, "dhcp") == 0) {
 659
 660                                 info->ipv4_method =
 661                                         CONNMAN_IPCONFIG_METHOD_DHCP;
 662                                 break;
 663                         }
 664                 } else if (g_str_equal(key, "Address") == TRUE) {
 665                         dbus_message_iter_get_basic(&value, &val);
 666
 667                         address = g_strdup(val);
 668
 669                         DBG("address %s", address);
 670                 } else if (g_str_equal(key, "Netmask") == TRUE) {
 671                         dbus_message_iter_get_basic(&value, &val);
 672
 673                         netmask = g_strdup(val);
 674
 675                         DBG("netmask %s", netmask);
 676                 } else if (g_str_equal(key, "DomainNameServers") == TRUE) {
 677
 678                         get_dns(&value, info);
 679                 } else if (g_str_equal(key, "Gateway") == TRUE) {
 680                         dbus_message_iter_get_basic(&value, &val);
 681
 682                         gateway = g_strdup(val);
 683
 684                         DBG("gateway %s", gateway);
 685                 }
 686
 687                 dbus_message_iter_next(&dict);
 688         }
 689
 690
 691         if (info->ipv4_method == CONNMAN_IPCONFIG_METHOD_FIXED) {
 692                 connman_ipaddress_set_ipv4(&info->ipv4_address, address,
 693                                                 netmask, gateway);
 694         }
 695
 696         /* deactive, oFono send NULL inteface before deactive signal */
 697         if (interface == NULL)
 698                 connman_network_set_index(info->network, -1);
 699
 700         g_free(address);
 701         g_free(netmask);
 702         g_free(gateway);
 703 }
 704
 705 static int add_network(struct connman_device *device,
 706                         const char *path, DBusMessageIter *dict)
 707 {
 708         struct modem_data *modem = connman_device_get_data(device);
 709         struct connman_network *network;
 710         struct network_info *info;
 711         char *ident;
 712         const char *hash_path;
 713         char const *operator;
 714         dbus_bool_t active = FALSE;
 715
 716         DBG("modem %p device %p path %s", modem, device, path);
 717
 718         ident = get_ident(path);
 719
 720         network = connman_device_get_network(device, ident);
 721         if (network != NULL)
 722                 return -EALREADY;
 723
 724         info = g_hash_table_lookup(network_hash, path);
 725         if (info != NULL) {
 726                 DBG("path %p already exists with device %p", path,
 727                         connman_network_get_device(info->network));
 728                 if (connman_network_get_device(info->network))
 729                         return -EALREADY;
 730                 g_hash_table_remove(network_hash, path);
 731         }
 732
 733         network = connman_network_create(ident, CONNMAN_NETWORK_TYPE_CELLULAR);
 734         if (network == NULL)
 735                 return -ENOMEM;
 736
 737         info = g_try_new0(struct network_info, 1);
 738         if (info == NULL) {
 739                 connman_network_unref(network);
 740                 return -ENOMEM;
 741         }
 742
 743         connman_ipaddress_clear(&info->ipv4_address);
 744         connman_ipaddress_clear(&info->ipv6_address);
 745         info->network = network;
 746
 747         connman_network_set_string(network, "Path", path);
 748         hash_path = connman_network_get_string(network, "Path");
 749         if (hash_path == NULL) {
 750                 connman_network_unref(network);
 751                 g_free(info);
 752                 return -EIO;
 753         }
 754
 755         create_service(network);
 756
 757         connman_network_ref(network);
 758         g_hash_table_insert(network_hash, (char *) hash_path, info);
 759
 760         connman_network_set_available(network, TRUE);
 761         connman_network_set_index(network, -1);
 762
 763         operator = connman_device_get_string(device, "Operator");
 764         if (operator)
 765                 connman_network_set_name(network, operator);
 766
 767         if (modem->has_strength)
 768                 connman_network_set_strength(network, modem->strength);
 769
 770         connman_network_set_roaming(network, modem->roaming);
 771
 772         while (dbus_message_iter_get_arg_type(dict) == DBUS_TYPE_DICT_ENTRY) {
 773                 DBusMessageIter entry, value;
 774                 const char *key;
 775
 776                 dbus_message_iter_recurse(dict, &entry);
 777                 dbus_message_iter_get_basic(&entry, &key);
 778
 779                 dbus_message_iter_next(&entry);
 780                 dbus_message_iter_recurse(&entry, &value);
 781
 782                 if (g_str_equal(key, "Type")) {
 783                         const char *type;
 784
 785                         dbus_message_iter_get_basic(&value, &type);
 786                         if (g_strcmp0(type, "internet") != 0) {
 787                                 DBG("path %p type %s", path, type);
 788                                 goto error;
 789                         }
 790                 } else if (g_str_equal(key, "Settings"))
 791                         update_settings(&value, info);
 792                 else if (g_str_equal(key, "Active") == TRUE)
 793                         dbus_message_iter_get_basic(&value, &active);
 794
 795                 dbus_message_iter_next(dict);
 796         }
 797
 798         if (connman_device_add_network(device, network) != 0)
 799                 goto error;
 800
 801         /* Connect only if requested to do so */
 802         if (active && connman_network_get_connecting(network) == TRUE)
 803                 set_connected(info, active);
 804
 805         return 0;
 806
 807 error:
 808         connman_network_unref(network);
 809         g_hash_table_remove(network_hash, hash_path);
 810         return -EIO;
 811 }
 812
 813 static void check_networks_reply(DBusPendingCall *call, void *user_data)
 814 {
 815         char *path = user_data;
 816         struct modem_data *modem;
 817         DBusMessage *reply;
 818         DBusMessageIter array, entry, value, properties;
 819
 820         DBG("path %s", path);
 821
 822         modem = g_hash_table_lookup(modem_hash, path);
 823         if (modem == NULL)
 824                 return;
 825         if (modem->device == NULL)
 826                 return;
 827
 828         reply = dbus_pending_call_steal_reply(call);
 829
 830         if (dbus_message_has_signature(reply, "a(oa{sv})") == FALSE)
 831                 goto done;
 832
 833         dbus_message_iter_init(reply, &array);
 834
 835         dbus_message_iter_recurse(&array, &entry);
 836
 837         while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRUCT) {
 838                 char const *network_path;
 839
 840                 dbus_message_iter_recurse(&entry, &value);
 841                 dbus_message_iter_get_basic(&value, &network_path);
 842
 843                 dbus_message_iter_next(&value);
 844                 dbus_message_iter_recurse(&value, &properties);
 845
 846                 add_network(modem->device, network_path, &properties);
 847
 848                 dbus_message_iter_next(&entry);
 849         }
 850
 851 done:
 852         dbus_message_unref(reply);
 853
 854         dbus_pending_call_unref(call);
 855 }
 856
 857 static void check_networks(struct modem_data *modem)
 858 {
 859         char const *path = modem->path;
 860
 861         DBG("modem %p path %s", modem, path);
 862
 863         call_ofono(path, OFONO_GPRS_INTERFACE, "GetContexts",
 864                         check_networks_reply, g_strdup(path), g_free,
 865                         DBUS_TYPE_INVALID);
 866 }
 867
 868 static void modem_clear_network_errors(struct modem_data *modem)
 869 {
 870         struct connman_device *device = modem->device;
 871         GHashTableIter i;
 872         gpointer value;
 873
 874         if (device == NULL)
 875                 return;
 876
 877         g_hash_table_iter_init(&i, network_hash);
 878
 879         while (g_hash_table_iter_next(&i, NULL, &value)) {
 880                 struct network_info *info = value;
 881
 882                 if (connman_network_get_device(info->network) == device)
 883                         connman_network_clear_error(info->network);
 884         }
 885 }
 886
 887 static void modem_operator_name_changed(struct modem_data *modem,
 888                                         char const *name)
 889 {
 890         struct connman_device *device = modem->device;
 891         GHashTableIter i;
 892         gpointer value;
 893
 894         if (device == NULL)
 895                 return;
 896
 897         connman_device_set_string(device, "Operator", name);
 898
 899         for (g_hash_table_iter_init(&i, network_hash);
 900              g_hash_table_iter_next(&i, NULL, &value);) {
 901                 struct network_info *info = value;
 902
 903                 if (connman_network_get_device(info->network) == device) {
 904                         connman_network_set_name(info->network, name);
 905                         connman_network_update(info->network);
 906                 }
 907         }
 908 }
 909
 910 static void modem_strength_changed(struct modem_data *modem, uint8_t strength)
 911 {
 912         struct connman_device *device = modem->device;
 913         GHashTableIter i;
 914         gpointer value;
 915
 916         modem->strength = strength;
 917         modem->has_strength = TRUE;
 918
 919         if (device == NULL)
 920                 return;
 921
 922         for (g_hash_table_iter_init(&i, network_hash);
 923              g_hash_table_iter_next(&i, NULL, &value);) {
 924                 struct network_info *info = value;
 925
 926                 if (connman_network_get_device(info->network) == device) {
 927                         connman_network_set_strength(info->network, strength);
 928                         connman_network_update(info->network);
 929                 }
 930         }
 931 }
 932
 933 static void modem_roaming_changed(struct modem_data *modem,
 934                                         char const *status)
 935 {
 936         struct connman_device *device = modem->device;
 937         connman_bool_t roaming = FALSE;
 938         connman_bool_t registered = FALSE;
 939         connman_bool_t was_roaming = modem->roaming;
 940         GHashTableIter i;
 941         gpointer value;
 942
 943         if (g_str_equal(status, "roaming"))
 944                 roaming = TRUE;
 945         else if (g_str_equal(status, "registered"))
 946                 registered = TRUE;
 947
 948         registered = registered || roaming;
 949
 950         if (modem->roaming == roaming && modem->registered == registered)
 951                 return;
 952
 953         modem->registered = registered;
 954         modem->roaming = roaming;
 955
 956         if (roaming == was_roaming)
 957                 return;
 958
 959         if (device == NULL)
 960                 return;
 961
 962         g_hash_table_iter_init(&i, network_hash);
 963
 964         while (g_hash_table_iter_next(&i, NULL, &value)) {
 965                 struct network_info *info = value;
 966
 967                 if (connman_network_get_device(info->network) == device) {
 968                         connman_network_set_roaming(info->network, roaming);
 969                         connman_network_update(info->network);
 970                 }
 971         }
 972 }
 973
 974 static void modem_registration_removed(struct modem_data *modem)
 975 {
 976         modem->registered = FALSE;
 977         modem->roaming = FALSE;
 978 }
 979
 980 static void modem_registration_changed(struct modem_data *modem,
 981                                         DBusMessageIter *entry)
 982 {
 983         DBusMessageIter iter;
 984         const char *key;
 985         int type;
 986         connman_uint8_t strength;
 987         char const *name, *status, *mcc_s;
 988
 989         dbus_message_iter_get_basic(entry, &key);
 990
 991         DBG("key %s", key);
 992
 993         dbus_message_iter_next(entry);
 994
 995         dbus_message_iter_recurse(entry, &iter);
 996
 997         type = dbus_message_iter_get_arg_type(&iter);
 998         if (type != DBUS_TYPE_BYTE && type != DBUS_TYPE_STRING)
 999                 return;
1000
1001         if (g_str_equal(key, "Name") && type == DBUS_TYPE_STRING) {
1002                 dbus_message_iter_get_basic(&iter, &name);
1003                 modem_operator_name_changed(modem, name);
1004         } else if (g_str_equal(key, "Strength") && type == DBUS_TYPE_BYTE) {
1005                 dbus_message_iter_get_basic(&iter, &strength);
1006                 modem_strength_changed(modem, strength);
1007         } else if (g_str_equal(key, "Status") && type == DBUS_TYPE_STRING) {
1008                 dbus_message_iter_get_basic(&iter, &status);
1009                 modem_roaming_changed(modem, status);
1010         } else if (g_str_equal(key, "MobileCountryCode") &&
1011                                         type == DBUS_TYPE_STRING) {
1012                 int mcc;
1013                 char *alpha2;
1014
1015                 dbus_message_iter_get_basic(&iter, &mcc_s);
1016
1017                 mcc = atoi(mcc_s);
1018                 if (mcc > 799)
1019                         return;
1020
1021                 alpha2 = mcc_country_codes[mcc - 200];
1022                 connman_technology_set_regdom(alpha2);
1023         }
1024
1025 }
1026
1027 static gboolean reg_changed(DBusConnection *connection,
1028                                 DBusMessage *message, void *user_data)
1029 {
1030         const char *path = dbus_message_get_path(message);
1031         struct modem_data *modem;
1032         DBusMessageIter iter;
1033
1034         DBG("path %s", path);
1035
1036         modem = g_hash_table_lookup(modem_hash, path);
1037         if (modem == NULL)
1038                 return TRUE;
1039
1040         if (dbus_message_iter_init(message, &iter))
1041                 modem_registration_changed(modem, &iter);
1042
1043         return TRUE;
1044 }
1045
1046 static void check_registration_reply(DBusPendingCall *call, void *user_data)
1047 {
1048         char const *path = user_data;
1049         struct modem_data *modem;
1050         DBusMessage *reply;
1051         DBusMessageIter array, dict, entry;
1052
1053         DBG("path %s", path);
1054
1055         modem = g_hash_table_lookup(modem_hash, path);
1056         if (modem == NULL)
1057                 return;
1058
1059         reply = dbus_pending_call_steal_reply(call);
1060
1061         if (dbus_message_iter_init(reply, &array) == FALSE)
1062                 goto done;
1063
1064         if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_ARRAY)
1065                 goto done;
1066
1067         dbus_message_iter_recurse(&array, &dict);
1068         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
1069                 dbus_message_iter_recurse(&dict, &entry);
1070                 modem_registration_changed(modem, &entry);
1071                 dbus_message_iter_next(&dict);
1072         }
1073
1074 done:
1075         dbus_message_unref(reply);
1076
1077         dbus_pending_call_unref(call);
1078 }
1079
1080 static void check_registration(struct modem_data *modem)
1081 {
1082         char const *path = modem->path;
1083
1084         DBG("modem %p path %s", modem, path);
1085
1086         call_ofono(path, OFONO_REGISTRATION_INTERFACE, GET_PROPERTIES,
1087                         check_registration_reply, g_strdup(path), g_free,
1088                         DBUS_TYPE_INVALID);
1089 }
1090
1091 static void modem_gprs_changed(struct modem_data *modem,
1092                                         DBusMessageIter *entry)
1093 {
1094         DBusMessageIter iter;
1095         const char *key;
1096         int type;
1097         dbus_bool_t value;
1098
1099         dbus_message_iter_get_basic(entry, &key);
1100
1101         DBG("key %s", key);
1102
1103         dbus_message_iter_next(entry);
1104
1105         dbus_message_iter_recurse(entry, &iter);
1106
1107         type = dbus_message_iter_get_arg_type(&iter);
1108
1109         if (type != DBUS_TYPE_BOOLEAN)
1110                 return;
1111
1112         dbus_message_iter_get_basic(&iter, &value);
1113
1114         if (g_str_equal(key, "Attached") == TRUE) {
1115                 DBG("Attached %d", value);
1116
1117                 modem->attached = value;
1118
1119                 if (value)
1120                         modem_clear_network_errors(modem);
1121         } else if (g_str_equal(key, "Powered") == TRUE) {
1122                 DBG("Powered %d", value);
1123
1124                 modem->powered = value;
1125         } else if (g_str_equal(key, "RoamingAllowed") == TRUE) {
1126                 DBG("RoamingAllowed %d", value);
1127
1128                 modem->roaming_allowed = value;
1129         }
1130 }
1131
1132 static void check_gprs_reply(DBusPendingCall *call, void *user_data)
1133 {
1134         char const *path = user_data;
1135         struct modem_data *modem;
1136         DBusMessage *reply;
1137         DBusMessageIter array, dict, entry;
1138
1139         DBG("path %s", path);
1140
1141         modem = g_hash_table_lookup(modem_hash, path);
1142         if (modem == NULL)
1143                 return;
1144
1145         reply = dbus_pending_call_steal_reply(call);
1146
1147         if (dbus_message_iter_init(reply, &array) == FALSE)
1148                 goto done;
1149
1150         if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_ARRAY)
1151                 goto done;
1152
1153         dbus_message_iter_recurse(&array, &dict);
1154         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
1155                 dbus_message_iter_recurse(&dict, &entry);
1156                 modem_gprs_changed(modem, &entry);
1157                 dbus_message_iter_next(&dict);
1158         }
1159
1160 done:
1161         dbus_message_unref(reply);
1162
1163         dbus_pending_call_unref(call);
1164
1165         check_networks(modem);
1166 }
1167
1168 static void check_gprs(struct modem_data *modem)
1169 {
1170         char const *path = modem->path;
1171
1172         DBG("modem %p path %s", modem, path);
1173
1174         call_ofono(path, OFONO_GPRS_INTERFACE, GET_PROPERTIES,
1175                         check_gprs_reply, g_strdup(path), g_free,
1176                         DBUS_TYPE_INVALID);
1177 }
1178
1179 static void add_device(const char *path, const char *imsi)
1180 {
1181         struct modem_data *modem;
1182         struct connman_device *device;
1183
1184         DBG("path %s imsi %s", path, imsi);
1185
1186         if (path == NULL)
1187                 return;
1188
1189         if (imsi == NULL)
1190                 return;
1191
1192         modem = g_hash_table_lookup(modem_hash, path);
1193         if (modem == NULL)
1194                 return;
1195
1196         if (modem->device) {
1197                 if (!g_strcmp0(imsi, connman_device_get_ident(modem->device)))
1198                         return;
1199
1200                 modem_remove_device(modem);
1201         }
1202
1203         if (strlen(imsi) == 0)
1204                 return;
1205
1206         device = connman_device_create(imsi, CONNMAN_DEVICE_TYPE_CELLULAR);
1207         if (device == NULL)
1208                 return;
1209
1210         connman_device_set_ident(device, imsi);
1211
1212         connman_device_set_string(device, "Path", path);
1213
1214         connman_device_set_data(device, modem);
1215
1216         if (connman_device_register(device) < 0) {
1217                 connman_device_unref(device);
1218                 return;
1219         }
1220
1221         modem->device = device;
1222
1223         if (modem->has_reg)
1224                 check_registration(modem);
1225
1226         if (modem->has_gprs)
1227                 check_gprs(modem);
1228 }
1229
1230 static void sim_properties_reply(DBusPendingCall *call, void *user_data)
1231 {
1232         const char *path = user_data;
1233         const char *imsi = NULL;
1234         DBusMessage *reply;
1235         DBusMessageIter array, dict;
1236
1237         DBG("path %s", path);
1238
1239         reply = dbus_pending_call_steal_reply(call);
1240
1241         if (dbus_message_iter_init(reply, &array) == FALSE)
1242                 goto done;
1243
1244         if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_ARRAY)
1245                 goto done;
1246
1247         dbus_message_iter_recurse(&array, &dict);
1248
1249         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
1250                 DBusMessageIter entry, value;
1251                 const char *key;
1252
1253                 dbus_message_iter_recurse(&dict, &entry);
1254                 dbus_message_iter_get_basic(&entry, &key);
1255
1256                 dbus_message_iter_next(&entry);
1257                 dbus_message_iter_recurse(&entry, &value);
1258
1259                 if (g_str_equal(key, "SubscriberIdentity")) {
1260                         dbus_message_iter_get_basic(&value, &imsi);
1261                         add_device(path, imsi);
1262                 }
1263
1264                 dbus_message_iter_next(&dict);
1265         }
1266
1267 done:
1268         dbus_message_unref(reply);
1269
1270         dbus_pending_call_unref(call);
1271 }
1272
1273 static void get_imsi(const char *path)
1274 {
1275         DBG("path %s", path);
1276
1277         call_ofono(path, OFONO_SIM_INTERFACE, GET_PROPERTIES,
1278                         sim_properties_reply, g_strdup(path), g_free,
1279                         DBUS_TYPE_INVALID);
1280 }
1281
1282 static int gprs_change_powered(const char *path, dbus_bool_t powered)
1283 {
1284         DBG("path %s powered %d", path, powered);
1285
1286         return set_property(path, OFONO_GPRS_INTERFACE, "Powered",
1287                                 DBUS_TYPE_BOOLEAN, &powered,
1288                                 NULL, NULL, NULL);
1289 }
1290
1291 static int modem_change_powered(const char *path, dbus_bool_t powered)
1292 {
1293         DBG("path %s powered %d", path, powered);
1294
1295         return set_property(path, OFONO_MODEM_INTERFACE, "Powered",
1296                                 DBUS_TYPE_BOOLEAN, &powered,
1297                                 NULL, NULL, NULL);
1298 }
1299
1300
1301 static gboolean modem_has_interface(DBusMessageIter *array,
1302                                         char const *interface)
1303 {
1304         DBusMessageIter entry;
1305
1306         dbus_message_iter_recurse(array, &entry);
1307
1308         while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
1309                 const char *element;
1310
1311                 dbus_message_iter_get_basic(&entry, &element);
1312
1313                 if (g_strcmp0(interface, element) == 0)
1314                         return TRUE;
1315
1316                 dbus_message_iter_next(&entry);
1317         }
1318
1319         return FALSE;
1320 }
1321
1322 static gboolean modem_has_sim(DBusMessageIter *array)
1323 {
1324         return modem_has_interface(array, OFONO_SIM_INTERFACE);
1325 }
1326
1327 static gboolean modem_has_reg(DBusMessageIter *array)
1328 {
1329         return modem_has_interface(array, OFONO_REGISTRATION_INTERFACE);
1330 }
1331
1332 static gboolean modem_has_gprs(DBusMessageIter *array)
1333 {
1334         return modem_has_interface(array, OFONO_GPRS_INTERFACE);
1335 }
1336
1337 static void add_modem(const char *path, DBusMessageIter *prop)
1338 {
1339         struct modem_data *modem;
1340         dbus_bool_t powered = FALSE;
1341         dbus_bool_t online = FALSE;
1342         dbus_bool_t has_online = FALSE;
1343         dbus_bool_t locked = FALSE;
1344         gboolean has_sim = FALSE;
1345         gboolean has_reg = FALSE;
1346         gboolean has_gprs = FALSE;
1347
1348         modem = g_hash_table_lookup(modem_hash, path);
1349
1350         if (modem != NULL)
1351                 return;
1352
1353         modem = g_try_new0(struct modem_data, 1);
1354         if (modem == NULL)
1355                 return;
1356
1357         modem->path = g_strdup(path);
1358         modem->device = NULL;
1359         modem->available = TRUE;
1360
1361         g_hash_table_insert(modem_hash, g_strdup(path), modem);
1362
1363         while (dbus_message_iter_get_arg_type(prop) == DBUS_TYPE_DICT_ENTRY) {
1364                 DBusMessageIter entry, value;
1365                 const char *key;
1366
1367                 dbus_message_iter_recurse(prop, &entry);
1368                 dbus_message_iter_get_basic(&entry, &key);
1369
1370                 dbus_message_iter_next(&entry);
1371                 dbus_message_iter_recurse(&entry, &value);
1372
1373                 if (g_str_equal(key, "Powered") == TRUE)
1374                         dbus_message_iter_get_basic(&value, &powered);
1375                 else if (g_str_equal(key, "Lockdown") == TRUE)
1376                         dbus_message_iter_get_basic(&value, &locked);
1377                 else if (g_str_equal(key, "Online") == TRUE) {
1378                         has_online = TRUE;
1379                         dbus_message_iter_get_basic(&value, &online);
1380                 } else if (g_str_equal(key, "Interfaces") == TRUE) {
1381                         has_sim = modem_has_sim(&value);
1382                         has_reg = modem_has_reg(&value);
1383                         has_gprs = modem_has_gprs(&value);
1384                 }
1385
1386                 dbus_message_iter_next(prop);
1387         }
1388
1389         if (locked)
1390                 return;
1391
1392         if (!powered)
1393                 modem_change_powered(path, TRUE);
1394
1395         modem->has_sim = has_sim;
1396         modem->has_reg = has_reg;
1397         modem->has_gprs = has_gprs;
1398
1399         update_modem_online(modem, online);
1400
1401         if (has_sim)
1402                 get_imsi(path);
1403 }
1404
1405 static void manager_modems_reply(DBusPendingCall *call, void *user_data)
1406 {
1407         DBusMessage *reply;
1408         DBusError error;
1409         DBusMessageIter array, dict;
1410
1411         DBG("");
1412
1413         reply = dbus_pending_call_steal_reply(call);
1414
1415         if (dbus_message_has_signature(reply, "a(oa{sv})") == FALSE)
1416                 goto done;
1417
1418         dbus_error_init(&error);
1419
1420         if (dbus_set_error_from_message(&error, reply)) {
1421                 connman_error("ModemManager.GetModems() %s %s",
1422                                 error.name, error.message);
1423                 dbus_error_free(&error);
1424                 goto done;
1425         }
1426
1427         if (dbus_message_iter_init(reply, &array) == FALSE)
1428                 goto done;
1429
1430         dbus_message_iter_recurse(&array, &dict);
1431
1432         while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_STRUCT) {
1433                 DBusMessageIter value, properties;
1434                 const char *modem_path;
1435
1436                 dbus_message_iter_recurse(&dict, &value);
1437                 dbus_message_iter_get_basic(&value, &modem_path);
1438
1439                 dbus_message_iter_next(&value);
1440                 dbus_message_iter_recurse(&value, &properties);
1441
1442                 /* Add modem */
1443                 add_modem(modem_path, &properties);
1444
1445                 dbus_message_iter_next(&dict);
1446         }
1447
1448 done:
1449         dbus_message_unref(reply);
1450
1451         dbus_pending_call_unref(call);
1452 }
1453
1454 static void ofono_connect(DBusConnection *connection, void *user_data)
1455 {
1456         DBG("connection %p", connection);
1457
1458         modem_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
1459                                                 g_free, remove_modem);
1460
1461         network_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
1462                                                 NULL, remove_network);
1463
1464         call_ofono("/", OFONO_MANAGER_INTERFACE, GET_MODEMS,
1465                         manager_modems_reply, NULL, NULL,
1466                         DBUS_TYPE_INVALID);
1467 }
1468
1469 static void ofono_disconnect(DBusConnection *connection, void *user_data)
1470 {
1471         DBG("connection %p", connection);
1472
1473         if (modem_hash == NULL)
1474                 return;
1475
1476         g_hash_table_destroy(modem_hash);
1477
1478         modem_hash = NULL;
1479 }
1480
1481 static gboolean modem_changed(DBusConnection *connection, DBusMessage *message,
1482                                 void *user_data)
1483 {
1484         const char *path = dbus_message_get_path(message);
1485         struct modem_data *modem;
1486         DBusMessageIter iter, value;
1487         const char *key;
1488
1489         DBG("path %s", path);
1490
1491         modem = g_hash_table_lookup(modem_hash, path);
1492         if (modem == NULL)
1493                 return TRUE;
1494
1495         if (dbus_message_iter_init(message, &iter) == FALSE)
1496                 return TRUE;
1497
1498         dbus_message_iter_get_basic(&iter, &key);
1499
1500         dbus_message_iter_next(&iter);
1501         dbus_message_iter_recurse(&iter, &value);
1502
1503         if (g_str_equal(key, "Powered") == TRUE) {
1504                 dbus_bool_t powered;
1505
1506                 dbus_message_iter_get_basic(&value, &powered);
1507                 if (powered == TRUE)
1508                         return TRUE;
1509
1510                 modem->has_sim = FALSE;
1511                 modem->has_reg = FALSE;
1512                 modem->has_gprs = FALSE;
1513
1514                 modem_remove_device(modem);
1515         } else if (g_str_equal(key, "Online") == TRUE) {
1516                 dbus_bool_t online;
1517
1518                 dbus_message_iter_get_basic(&value, &online);
1519
1520                 update_modem_online(modem, online);
1521         } else if (g_str_equal(key, "Lockdown") == TRUE) {
1522                 dbus_bool_t locked;
1523
1524                 dbus_message_iter_get_basic(&value, &locked);
1525
1526                 if (!locked)
1527                         modem_change_powered(path, TRUE);
1528
1529         } else if (g_str_equal(key, "Interfaces") == TRUE) {
1530                 gboolean has_sim = modem_has_sim(&value);
1531                 gboolean has_reg = modem_has_reg(&value);
1532                 gboolean had_reg = modem->has_reg;
1533                 gboolean has_gprs = modem_has_gprs(&value);
1534                 gboolean had_gprs = modem->has_gprs;
1535
1536                 modem->has_sim = has_sim;
1537                 modem->has_reg = has_reg;
1538                 modem->has_gprs = has_gprs;
1539
1540                 if (modem->device == NULL) {
1541                         if (has_sim)
1542                                 get_imsi(modem->path);
1543                 } else if (!has_sim) {
1544                         modem_remove_device(modem);
1545                 } else {
1546                         if (has_reg && !had_reg)
1547                                 check_registration(modem);
1548                         else if (had_reg && !has_reg)
1549                                 modem_registration_removed(modem);
1550
1551                         if (has_gprs && !had_gprs) {
1552                                 gprs_change_powered(modem->path, TRUE);
1553                                 check_gprs(modem);
1554                         }
1555                 }
1556         }
1557
1558         return TRUE;
1559 }
1560
1561 static gboolean sim_changed(DBusConnection *connection, DBusMessage *message,
1562                                 void *user_data)
1563 {
1564         const char *path = dbus_message_get_path(message);
1565         struct modem_data *modem;
1566         DBusMessageIter iter, value;
1567         const char *key;
1568
1569         DBG("path %s", path);
1570
1571         modem = g_hash_table_lookup(modem_hash, path);
1572         if (modem == NULL)
1573                 return TRUE;
1574
1575         if (dbus_message_iter_init(message, &iter) == FALSE)
1576                 return TRUE;
1577
1578         dbus_message_iter_get_basic(&iter, &key);
1579
1580         dbus_message_iter_next(&iter);
1581         dbus_message_iter_recurse(&iter, &value);
1582
1583         if (g_str_equal(key, "SubscriberIdentity") == TRUE) {
1584                 char *imsi;
1585
1586                 dbus_message_iter_get_basic(&value, &imsi);
1587
1588                 add_device(path, imsi);
1589         } else if (g_str_equal(key, "Present") == TRUE) {
1590                 dbus_bool_t present;
1591
1592                 dbus_message_iter_get_basic(&value, &present);
1593
1594                 if (present)
1595                         return TRUE;
1596
1597                 if (modem->device != NULL)
1598                         modem_remove_device(modem);
1599
1600                 modem->has_gprs = FALSE;
1601                 modem->has_reg = FALSE;
1602         }
1603
1604         return TRUE;
1605 }
1606
1607 static gboolean gprs_changed(DBusConnection *connection, DBusMessage *message,
1608                                 void *user_data)
1609 {
1610         const char *path = dbus_message_get_path(message);
1611         struct modem_data *modem;
1612         DBusMessageIter iter;
1613
1614         DBG("path %s", path);
1615
1616         modem = g_hash_table_lookup(modem_hash, path);
1617         if (modem == NULL)
1618                 return TRUE;
1619
1620         if (dbus_message_iter_init(message, &iter))
1621                 modem_gprs_changed(modem, &iter);
1622
1623         return TRUE;
1624 }
1625
1626 static gboolean context_added(DBusConnection *connection,
1627                                 DBusMessage *message, void *user_data)
1628 {
1629         const char *path = dbus_message_get_path(message);
1630         const char *network_path;
1631         struct modem_data *modem;
1632         DBusMessageIter iter, properties;
1633
1634         DBG("path %s", path);
1635
1636         modem = g_hash_table_lookup(modem_hash, path);
1637         if (modem == NULL || modem->device == NULL)
1638                 return TRUE;
1639
1640         if (dbus_message_iter_init(message, &iter) == FALSE)
1641                 return TRUE;
1642
1643         dbus_message_iter_get_basic(&iter, &network_path);
1644
1645         dbus_message_iter_next(&iter);
1646         dbus_message_iter_recurse(&iter, &properties);
1647
1648         add_network(modem->device, network_path, &properties);
1649
1650         return TRUE;
1651 }
1652
1653 static gboolean context_removed(DBusConnection *connection,
1654                                 DBusMessage *message, void *user_data)
1655 {
1656         const char *path = dbus_message_get_path(message);
1657         const char *network_path, *identifier;
1658         struct modem_data *modem;
1659         struct network_info *info;
1660         DBusMessageIter iter;
1661
1662         DBG("path %s", path);
1663
1664         modem = g_hash_table_lookup(modem_hash, path);
1665         if (modem == NULL || modem->device == NULL)
1666                 return TRUE;
1667
1668         if (dbus_message_iter_init(message, &iter) == FALSE)
1669                 return TRUE;
1670
1671         dbus_message_iter_get_basic(&iter, &network_path);
1672
1673         info = g_hash_table_lookup(network_hash, network_path);
1674         if (info == NULL)
1675                 return TRUE;
1676
1677         identifier = connman_network_get_identifier(info->network);
1678         connman_device_remove_network(modem->device, identifier);
1679
1680         return TRUE;
1681 }
1682
1683 static gboolean modem_added(DBusConnection *connection,
1684                                 DBusMessage *message, void *user_data)
1685 {
1686         DBusMessageIter iter, properties;
1687         const char *modem_path;
1688
1689         DBG("");
1690
1691         if (dbus_message_iter_init(message, &iter) == FALSE)
1692                 return TRUE;
1693
1694         dbus_message_iter_get_basic(&iter, &modem_path);
1695
1696         dbus_message_iter_next(&iter);
1697         dbus_message_iter_recurse(&iter, &properties);
1698
1699         add_modem(modem_path, &properties);
1700
1701         return TRUE;
1702 }
1703
1704 static gboolean modem_removed(DBusConnection *connection,
1705                                 DBusMessage *message, void *user_data)
1706 {
1707         DBusMessageIter iter;
1708         const char *modem_path;
1709
1710         DBG("");
1711
1712         if (dbus_message_iter_init(message, &iter) == FALSE)
1713                 return TRUE;
1714
1715         dbus_message_iter_get_basic(&iter, &modem_path);
1716
1717         g_hash_table_remove(modem_hash, modem_path);
1718
1719         return TRUE;
1720 }
1721
1722 static gboolean context_changed(DBusConnection *connection,
1723                                         DBusMessage *message, void *user_data)
1724 {
1725         const char *path = dbus_message_get_path(message);
1726         struct network_info *info;
1727         DBusMessageIter iter, value;
1728         const char *key;
1729
1730         DBG("path %s", path);
1731
1732         info = g_hash_table_lookup(network_hash, path);
1733         if (info == NULL)
1734                 return TRUE;
1735
1736         if (!pending_network_is_available(info->network)) {
1737                 g_hash_table_remove(network_hash, path);
1738                 return TRUE;
1739         }
1740
1741         if (dbus_message_iter_init(message, &iter) == FALSE)
1742                 return TRUE;
1743
1744         dbus_message_iter_get_basic(&iter, &key);
1745
1746         dbus_message_iter_next(&iter);
1747         dbus_message_iter_recurse(&iter, &value);
1748
1749         DBG("key %s", key);
1750
1751         if (g_str_equal(key, "Settings") == TRUE)
1752                 update_settings(&value, info);
1753         else if (g_str_equal(key, "Active") == TRUE) {
1754                 dbus_bool_t active;
1755
1756                 dbus_message_iter_get_basic(&value, &active);
1757
1758                 if (active == FALSE)
1759                         set_connected(info, active);
1760
1761                 /* Connect only if requested to do so */
1762                 if (active == TRUE &&
1763                         connman_network_get_connecting(info->network) == TRUE)
1764                         set_connected(info, active);
1765         }
1766
1767         return TRUE;
1768 }
1769
1770 static guint watch;
1771 static guint reg_watch;
1772 static guint sim_watch;
1773 static guint gprs_watch;
1774 static guint context_added_watch;
1775 static guint context_removed_watch;
1776 static guint modem_watch;
1777 static guint modem_added_watch;
1778 static guint modem_removed_watch;
1779 static guint context_watch;
1780
1781 static int ofono_init(void)
1782 {
1783         int err;
1784
1785         connection = connman_dbus_get_connection();
1786         if (connection == NULL)
1787                 return -EIO;
1788
1789         watch = g_dbus_add_service_watch(connection, OFONO_SERVICE,
1790                         ofono_connect, ofono_disconnect, NULL, NULL);
1791
1792         reg_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1793                                                 OFONO_REGISTRATION_INTERFACE,
1794                                                 PROPERTY_CHANGED,
1795                                                 reg_changed,
1796                                                 NULL, NULL);
1797
1798         gprs_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1799                                                 OFONO_GPRS_INTERFACE,
1800                                                 PROPERTY_CHANGED,
1801                                                 gprs_changed,
1802                                                 NULL, NULL);
1803
1804         context_added_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1805                                                 OFONO_GPRS_INTERFACE,
1806                                                 CONTEXT_ADDED,
1807                                                 context_added,
1808                                                 NULL, NULL);
1809
1810         context_removed_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1811                                                 OFONO_GPRS_INTERFACE,
1812                                                 CONTEXT_REMOVED,
1813                                                 context_removed,
1814                                                 NULL, NULL);
1815
1816         modem_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1817                                                 OFONO_MODEM_INTERFACE,
1818                                                 PROPERTY_CHANGED,
1819                                                 modem_changed,
1820                                                 NULL, NULL);
1821
1822         sim_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1823                                                 OFONO_SIM_INTERFACE,
1824                                                 PROPERTY_CHANGED,
1825                                                 sim_changed,
1826                                                 NULL, NULL);
1827
1828         modem_added_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1829                                                 OFONO_MANAGER_INTERFACE,
1830                                                 MODEM_ADDED,
1831                                                 modem_added,
1832                                                 NULL, NULL);
1833
1834         modem_removed_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1835                                                 OFONO_MANAGER_INTERFACE,
1836                                                 MODEM_REMOVED,
1837                                                 modem_removed,
1838                                                 NULL, NULL);
1839
1840         context_watch = g_dbus_add_signal_watch(connection, NULL, NULL,
1841                                                 OFONO_CONTEXT_INTERFACE,
1842                                                 PROPERTY_CHANGED,
1843                                                 context_changed,
1844                                                 NULL, NULL);
1845
1846         if (watch == 0 || gprs_watch == 0 || context_added_watch == 0 ||
1847                         context_removed_watch == 0 || modem_watch == 0 ||
1848                         reg_watch == 0 || sim_watch == 0 ||
1849                         modem_added_watch == 0 || modem_removed_watch == 0 ||
1850                                 context_watch == 0) {
1851                 err = -EIO;
1852                 goto remove;
1853         }
1854
1855         err = connman_network_driver_register(&network_driver);
1856         if (err < 0)
1857                 goto remove;
1858
1859         err = connman_device_driver_register(&modem_driver);
1860         if (err < 0) {
1861                 connman_network_driver_unregister(&network_driver);
1862                 goto remove;
1863         }
1864
1865         return 0;
1866
1867 remove:
1868         g_dbus_remove_watch(connection, watch);
1869         g_dbus_remove_watch(connection, sim_watch);
1870         g_dbus_remove_watch(connection, reg_watch);
1871         g_dbus_remove_watch(connection, gprs_watch);
1872         g_dbus_remove_watch(connection, context_added_watch);
1873         g_dbus_remove_watch(connection, context_removed_watch);
1874         g_dbus_remove_watch(connection, modem_watch);
1875         g_dbus_remove_watch(connection, modem_added_watch);
1876         g_dbus_remove_watch(connection, modem_removed_watch);
1877         g_dbus_remove_watch(connection, context_watch);
1878
1879         dbus_connection_unref(connection);
1880
1881         return err;
1882 }
1883
1884 static void ofono_exit(void)
1885 {
1886         g_dbus_remove_watch(connection, watch);
1887         g_dbus_remove_watch(connection, sim_watch);
1888         g_dbus_remove_watch(connection, reg_watch);
1889         g_dbus_remove_watch(connection, gprs_watch);
1890         g_dbus_remove_watch(connection, context_added_watch);
1891         g_dbus_remove_watch(connection, context_removed_watch);
1892         g_dbus_remove_watch(connection, modem_watch);
1893         g_dbus_remove_watch(connection, modem_added_watch);
1894         g_dbus_remove_watch(connection, modem_removed_watch);
1895         g_dbus_remove_watch(connection, context_watch);
1896
1897         ofono_disconnect(connection, NULL);
1898
1899         connman_device_driver_unregister(&modem_driver);
1900         connman_network_driver_unregister(&network_driver);
1901
1902         dbus_connection_unref(connection);
1903 }
1904
1905 CONNMAN_PLUGIN_DEFINE(ofono, "oFono telephony plugin", VERSION,
1906                 CONNMAN_PLUGIN_PRIORITY_DEFAULT, ofono_init, ofono_exit)